// lrtextview.cpp
// 
// Copyright (c) 2009 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
// 
// Initial Contributors:
// Accenture - Initial contribution
//

#include "lrtextview.h"
#include <e32cons.h>
#include "filebuffer.h"
#include <fshell/common.mmh>
#include <fshell/ltkutils.h>

const TInt KLastCtrlChar = 0x1f;	//Last control char in ASCII
const TInt KCtrlHTab = 0x09;		//Horizontal Tab

CLRTextView* CLRTextView::NewL(MConsoleProvider& aConsoleProvider, CFedBufferBase& aBuffer)
	{
	CLRTextView* self = new (ELeave) CLRTextView(aConsoleProvider, aBuffer);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CLRTextView::~CLRTextView()
	{
	delete iLineData;
	delete iMarkFlasher;
	}

CLRTextView::CLRTextView(MConsoleProvider& aConsoleProvider, CFedBufferBase& aBuffer)
	: CTextView(aConsoleProvider, aBuffer), iMarkDocPos(-1), iOldNextLine(-1)
	{
	}

void CLRTextView::ConstructL()
	{
	iLineData = new(ELeave) CLineData;
	CTextView::ConstructL();
	iMarkFlasher = CPeriodic::NewL(CActive::EPriorityStandard);
	}

//MDeferredClose
TBool CLRTextView::TryCloseL()
	{
	if (!iBuffer.Modified())
		{
		return ETrue; // Ok to close now
		}
	else
		{
		TKeyCode ch = iConsoleProvider.Query(_L("Save changes to file? (yes/no/cancel) "), _L("ync\x1B"));
		if (ch == 'c' || ch == EKeyEscape) return EFalse;
		if (ch == 'y')
			{
			TInt err = Save();
			if (err) return EFalse; // Don't allow exit if the save failed
			}
		return ETrue;
		}
	}

TInt CLRTextView::Save()
	{
	if (!iBuffer.Editable() || iLineIsErrorMessage) return KErrNotSupported;
	
	CancelMark();
	TBool wasOpen = iBuffer.IsOpen();
	TInt err = KErrNone;
	const TDesC& name = iBuffer.Title();
	if (name.Length())
		{
		iConsoleProvider.InfoPrint(_L("Saving"));
		TRAP(err, iBuffer.SaveL(name, ETrue));
		HandleSaveResult(err, wasOpen, iBuffer.Title());
		return err;
		}
	else
		{
		return SaveAs();
		}
	}

TInt CLRTextView::SaveAs()
	{
	if (!iBuffer.Editable() || iLineIsErrorMessage) return KErrNotSupported;
	
	CancelMark();
	TBool wasOpen = iBuffer.IsOpen();
	TFileName name = iBuffer.Title();
	TInt err = KErrCancel;
	TBool go = iConsoleProvider.QueryFilename(_L("Save as: "), name);
	if (go)
		{
		iConsoleProvider.InfoPrint(_L("Saving"));
		TRAP(err, iBuffer.SaveL(name, EFalse));
		if (err == KErrAlreadyExists)
			{
			if (iConsoleProvider.Query(_L("File already exists. Replace? (yes/no) "), _L("yn")) == 'y')
				{
				iConsoleProvider.InfoPrint(_L("Saving"));
				TRAP(err, iBuffer.SaveL(name, ETrue));
				}
			}
		HandleSaveResult(err, wasOpen, iBuffer.Title());
		}
	return err;
	}

void CLRTextView::HandleSaveResult(TInt aError, TBool aWasOpen, const TDesC& aName)
	{
	if (aError == KErrNone)
		{
		TRAP_IGNORE(DoRedrawL()); // Not only can QueryFilename mess up the screen, saving the file could change the line endings and thus change the character counts, meaning we need to recalculate & redraw
		iConsoleProvider.InfoPrint(_L("Save succeeded"));
		}
	else if (aWasOpen && !iBuffer.IsOpen())
		{
		// An error occurred after the original file was closed. This is fatal so we need to put up a dialog to that effect
		iLine.Format(_L("Temp file @ %S"), &aName);
		iLineIsErrorMessage = ETrue;
		UpdateStatus();
		iConsoleProvider.InfoPrint(_L("Failed to rename temp file (%d)"), aError);
		}
	else
		{
		// Failed to save, but we didn't mess with the original so we can carry on using it
		TRAP_IGNORE(DoRedrawL()); // Not only can QueryFilename mess up the screen, saving the file could change the line endings and thus change the character counts, meaning we need to recalculate & redraw
		switch (aError)
			{
			case KErrDiskFull:
				iConsoleProvider.InfoPrint(_L("Disk full, couldn't save file"));
				break;
			case KErrNoMemory:
				iConsoleProvider.InfoPrint(_L("Out of memory!"));
				break;
			case KErrPathNotFound:
				iConsoleProvider.InfoPrint(_L("KErrPathNotFound. Directory doesn't exist?"));
				break;
			case KErrGeneral:
				iConsoleProvider.InfoPrint(_L("Couldn't save file. No idea why"));
				break;
			case KErrBadName:
				iConsoleProvider.InfoPrint(_L("Bad file name"));
				break;
			case KErrAccessDenied:
				iConsoleProvider.InfoPrint(_L("Access denied. Read-only file or disk?"));
				break;
			default:
				iConsoleProvider.InfoPrint(_L("Unable to save file: %d"), aError);
				break;
			}
		}
	}

//MKeyConsumer
TBool CLRTextView::ConsumeKeyL(const TKeyCode& aCode)
	{
	TBool handled = ETrue;
	switch(aCode)
		{
		case EKeyUpArrow:
			MoveCursor(0, -1); break;
		case EKeyDownArrow:
			MoveCursor(0, 1); break;
		case EKeyLeftArrow:
			MoveCursor(-1, 0); break;
		case EKeyRightArrow:
			MoveCursor(1, 0); break;
		case EKeyPageUp:
		case CTRL('u'):
			MoveCursor(0, -iWindow.iHeight); break;
		case EKeyPageDown:
		case CTRL('d'):
			MoveCursor(0, iWindow.iHeight); break;
		case EKeyHome:
			UpdateCursor(TPoint(0, iCursor.iY));
			break;
		case CTRL('t'):
			iCursor.SetXY(0, 0);
			RequestData(ETrue, 0); break;
		case CTRL('b'):
			GoToLine(KMaxTInt); break;
		case EKeyEnd:
			{
			TInt pos = iLineData->LastValidPosition(iCursor.iY);
			UpdateCursor(TPoint(pos, iCursor.iY));
			break;
			}
		case EKeyBackspace:
			DeleteTextL(-1);
			break;
		case EKeyDelete:
			DeleteTextL(1);
			break;
		case CTRL('s'):
			Save();
			break;
		case CTRL('a'):
			SaveAs();
			break;
		case CTRL('k'):
			DeleteCurrentLineL();
			break;
		case CTRL('g'):
			GoToLine();
			break;
		case CTRL('f'):
			Find();
			break;
		case CTRL('v'):
			PasteL();
			break;
		case CTRL('c'):
			if (MarkActive()) CopyOrCutL(EFalse);
			else SetMark();
			break;
		case CTRL('x'):
			if (MarkActive()) CopyOrCutL(ETrue);
			else SetMark();
			break;
		default:
			handled = EFalse;
			break;
		}

	if (!handled && (aCode == EKeyEnter || aCode == EKeyTab || TChar(aCode).IsPrint()))
		{
		TBuf<1> buf;
		buf.Append(aCode);
		InsertTextL(buf);
		handled = ETrue;
		}
	return handled;
}

void CLRTextView::MoveCursor(TInt aX, TInt aY)
	{
	if (aX) ASSERT(aY == 0);
	if (aY) ASSERT(aX == 0); // Can't handle moving in both axes at once

	TInt line = iCursor.iY;
	TInt dir = (aX > 0) ? 1 : -1;
	TInt newX = iCursor.iX;
	while (aX)
		{
		newX += dir;
		if (newX < 0)
			{
			// Move to end of previous line
			newX = iWindow.iWidth; // Validate cursor will fix this, in the case where this causes us to scroll up a line
			aY--;
			break; // We don't really support seeking further than one line either way
			}
		else if (newX >= iWindow.iWidth-1)
			{
			// Move to start of next line
			newX = 0;
			aY++;
			break; // We don't really support seeking further than one line either way
			}

		if (iLineData->IsScreenPositionValid(line, newX))
			{
			aX -= dir;
			}
		}

	if (line + aY < 0)
		{
		// Scroll up
		SeekData(iLineData->DocumentPosition(0), aY);
		}
	else if (line + aY >= iWindow.iHeight)
		{
		// Scroll down
		SeekData(iLineData->DocumentPosition(0), aY);
		}
	else
		{
		// Just update cursor
		if (iLineData->IsScreenPositionValid(line + aY, 0))
			{
			// If the line len is -1 it means the doc doesn't extend as far as this line, therefore we shouldn't allow the cursor to be moved to it
			UpdateCursor(TPoint(newX, iCursor.iY + aY));
			}
		}
	}

void CLRTextView::DoResizeL(const TWindow& /*aOldWindow*/)
	{
	DoRedrawL();
	}

void CLRTextView::DoRedrawL()
	{
	iLineData->EnsureCapacityL(iWindow.iWidth, iWindow.iHeight);
	ValidateCursor();
	RequestData(ETrue, iLineData->DocumentPosition(0));
	}

void CLRTextView::DoDrawL()
	{
	DoDrawL(iRecursiveUpdateFlag ? *iRecursiveUpdateFlag : ETrue);
	}

void CLRTextView::DoDrawL(TBool aUpdateCursorAndStatus)
	{
	if (iDrawPoint == TPoint(iWindow.iX, iWindow.iY))
		{
		iLineData->SetDocumentPositionForLine(0, iRange.iLocation);
		iLineData->SetFileLineNumberForLine(0, iRangeStartLineNumber);
		}

	ASSERT(iRange.iLength == iDes.Length());
	HideCursor(); // Don't show the cursor while we're moving it around drawing - will be shown again by UpdateCursor
	for (iCurrentDrawDocIndex = 0; iCurrentDrawDocIndex < iDes.Length(); iCurrentDrawDocIndex++)
		{
		TUint16 c = iDes[iCurrentDrawDocIndex];
		if(iDrawPoint.iY >= iWindow.NextY())
			{
			break;
			}
		if(c <= KLastCtrlChar)
			HandleControlChar();
		else
			AppendChar(c);
		}

	TBool moreData = !iBuffer.DocumentPositionIsEof(iRange.Max());
	TBool filledScreen = iDrawPoint.iY >= iWindow.NextY();
	if (!filledScreen)
		{
		WriteChars();
		LineFinished();
		}
	if (!moreData)
		{
		iDrawPoint.iY++; // Start from the line *after* the line we were on
		// In the case where we've finished writing but haven't filled the screen, we need to blank the rest of it (because to avoid flicker we don't do ClearScreens)
		while (iDrawPoint.iY < iWindow.NextY())
			{
			iDrawPoint.iX = iWindow.iX;
			iLine.Copy(_L("^"));
			WriteChars();
			TInt lineNum = iDrawPoint.iY - iWindow.iY;
			iLineData->SetDocumentPositionForLine(lineNum+1, iLineData->DocumentPosition(lineNum));
			iLineData->SetFileLineNumberForLine(lineNum, -1);
			iLineData->LineFinishedAt(lineNum, -1);
			iDrawPoint.iY++;
			}
		}

	if (filledScreen || !moreData)
		{
		// Finished - null iDes and restore cursor
		iDes.Set(NULL, 0);
		if (aUpdateCursorAndStatus)
			{
			UpdateCursor(iCursor);
			}
		}
	else
		{
		TBool flagSet = EFalse;
		if (!iRecursiveUpdateFlag)
			{
			iRecursiveUpdateFlag = &aUpdateCursorAndStatus;
			flagSet = ETrue;
			}
		// More data needed to fill the screen
		RequestData(EFalse, iRange.Max());
		if (flagSet) iRecursiveUpdateFlag = NULL;
		}
}

void CLRTextView::ValidateCursor()
	{	
	CTextView::ValidateCursor();
	TInt maxX = iWindow.iWidth - 1;
	TInt line = iCursor.iY;
	while (iCursor.iX > 0 && !iLineData->IsScreenPositionValid(line, iCursor.iX))
		{
		// In case the cursor ended up in the dead space in the middle of a tab character
		iCursor.iX--;
		}
	while (line > 0 && !iLineData->IsScreenPositionValid(line, 0))
		{
		// In case the cursor has ended up in dead space
		iCursor.iY--;
		line--;
		}
	maxX = iLineData->LastValidPosition(line);
	if(iCursor.iX > maxX)
		iCursor.iX = maxX;
	}

void CLRTextView::HandleControlChar()
	{
	TUint8 c = iDes[iCurrentDrawDocIndex];
	if (c == KCtrlHTab)
		{
		TInt pos = iDrawPoint.iX - iWindow.iX + iLine.Length();
		TInt numToWrite = TabWidth() - (pos % TabWidth()); // Tabs align to 4-column boundaries rather than just outputting 4 spaces
		numToWrite = Min(numToWrite, iWindow.iWidth-1-pos); // In case the tab causes a line continuation, we want to make sure the tab ends at the end of the line so the following character will start at column zero
		for(TInt i=0; i<numToWrite; i++)
			{
			TInt line = iDrawPoint.iY - iWindow.iY;
			TInt col = iDrawPoint.iX - iWindow.iX + iLine.Length();
			AppendChar(' ');
			if (i > 0) iLineData->SetPositionIsValid(line, col, EFalse); // i==0 (ie the first screen position of the tab) is a valid place to move the cursor to
			}
		}
	else if (c == '\r')
		{
		if (iCurrentDrawDocIndex+1 < iDes.Length() && iDes[iCurrentDrawDocIndex+1] == '\n') iCurrentDrawDocIndex++; // Skip over the CR to the LF
		WriteLine();
		}
	else if (c == '\n')
		{
		WriteLine();
		}
	else
		{
		// unknown control char - so escape it
		AppendChar('.');
		}
	}

void CLRTextView::AppendChar(TUint16 aChar)
	{
	iLine.Append(TChar(aChar));
	iLineData->SetPositionIsValid(iDrawPoint.iY - iWindow.iY, iDrawPoint.iX - iWindow.iX + iLine.Length(), ETrue);
	if(iDrawPoint.iX + iLine.Length() == iWindow.NextX()-1)
		{
		WriteChars();
		WriteLineContinue();
		GoToNextLine();
		}
	}

//Writes the current line on the screen and moves to the next verse and line
void CLRTextView::WriteLine()
	{
	TInt thisLine = iDrawPoint.iY-iWindow.iY;
	WriteChars();
	GoToNextLine();
	iLineData->SetFileLineNumberForLine(thisLine+1, iLineData->FileLineNumber(thisLine) + 1);
	if (iOldNextLine != -1 && thisLine+1 == iOldNextLine && iLineData->DocumentPosition(iOldNextLine) == iOldNextLineDocPos + iPredictedOldNextLineDocPosDelta)
		{
		// We have drawn everything we need to, and the drawing didn't cause the former next line to move
		iDrawPoint.iY = iWindow.NextY();
		UpdateDocumentPositionsStartingAtLine(iOldNextLine+1, iPredictedOldNextLineDocPosDelta);
		}
	iOldNextLine = -1;
	}

//Writes the current line on the screen
void CLRTextView::WriteChars()
	{
	/* As an performance optimisation, we avoid calling ClearScreen when redrawing. Therefore we must ensure we 
	 * write to the entire line to prevent artifacts. 
	 *
	 * There are 2 approaches to this - either using CConsoleBase::ClearToEndOfLine or padding the line with 
	 * spaces up to the window width. ClearToEndOfLine is really slow in WINSCW tshell which is why it's not
	 * used by default. On target it's probably more efficient to use it.
	 */
	TPoint drawPoint(iDrawPoint);
	TPoint endPoint(drawPoint.iX + iLine.Length(), drawPoint.iY);
	iConsole.SetCursorPosAbs(drawPoint);
#ifdef FSHELL_WSERV_SUPPORT
// text windowserver is really slow at ClearToEndOfLine
#define USE_CLEARTOENDOFLINE
#endif
#ifdef USE_CLEARTOENDOFLINE
	iConsole.Write(iLine);
	iConsole.ClearToEndOfLine();
#else
	iLine.AppendFill(' ', iWindow.iWidth - (iDrawPoint.iX-iWindow.iX) - iLine.Length());
	iConsole.Write(iLine);
#endif
	iLine.Zero();
	// Remember to reset the console pos and the drawpoint to the end of the line proper in case the WriteChars 
	// was to half a line and the rest of the line is in another block.
	iDrawPoint = endPoint;
	iConsole.SetCursorPosAbs(iDrawPoint);
	}

// Moves to the next screen line but doesn't move to the next file line (used when a line is longer than the width of the window)
void CLRTextView::GoToNextLine()
	{
	LineFinished();
	iDrawPoint.iX = iWindow.iX;
	iDrawPoint.iY++;
	iLineData->SetPositionIsValid(iDrawPoint.iY-iWindow.iY, 0, ETrue);
	}

void CLRTextView::LineFinished()
	{
	TInt currentLine = iDrawPoint.iY - iWindow.iY;
	if (currentLine == iWindow.iHeight) return; // This can happen (and is ok) when drawing the last line of the screen
	iLineData->LineFinishedAt(currentLine, iDrawPoint.iX - iWindow.iX);
	iLineData->SetDocumentPositionForLine(currentLine+1, iRange.iLocation+iCurrentDrawDocIndex+1); // Plus one cos we haven't drawn the first character of the next line yet
	}

void CLRTextView::WriteLineContinue()
	{
	CColorConsoleBase* cons = iConsoleProvider.ColorConsole();
	if (cons) cons->SetTextAttribute(ETextAttributeHighlight);
	_LIT(KContinuation, "\\");
	iConsole.Write(KContinuation);
	if (cons) cons->SetTextAttribute(ETextAttributeNormal);

	TInt thisLine = iDrawPoint.iY-iWindow.iY;
	iLineData->SetFileLineNumberForLine(thisLine+1, iLineData->FileLineNumber(thisLine)); // The new line has the same file number as the current line, because it's a continuation line
	}

TInt CLRTextView::DocumentPosition() const
	{
	TInt line = iCursor.iY;
	TInt pos = iLineData->DocumentPosition(line);
	for (TInt i = 0; i < iCursor.iX; i++)
		{
		if (iLineData->IsScreenPositionValid(line, i)) pos++;
		}
	return pos;
	}

void CLRTextView::InsertTextL(const TDesC& aText)
	{
	if (!iBuffer.Editable() || iLineIsErrorMessage) return;
	
	CancelMark();
	TInt pos = DocumentPosition();
	iBuffer.InsertTextL(pos, aText);
	if (iCursor.iX == iWindow.iWidth-1)
		{
		// If the cursor is over a line continuation character (which it will be if it gets to this value) move cursor to the real insertion point at the start of the next line before doing anything - makes the logic much easier!
		MoveCursor(1, 0);
		}

	// If we can be sure it won't cause a reflow, shortcut the requesting and redrawing mechanism, for performance reasons
	TPoint cursorPos = WindowLocationForDocumentPosition(pos);
	TInt lineNum = cursorPos.iY;
	TBool posWasAtEndOfLine = cursorPos.iX == iLineData->LastValidPosition(lineNum) && cursorPos.iX + aText.Length() < iWindow.iWidth-1;
	if (posWasAtEndOfLine && aText.Locate('\t') == KErrNotFound && aText.Locate('\r') == KErrNotFound)
		{
		// Can't optimise if the text contains tabs or newlines, we need to do the full algorithm in that case
		iConsole.Write(aText);
		for (TInt i = 0; i < aText.Length(); i++)
			{
			iLineData->SetPositionIsValid(lineNum, cursorPos.iX + 1 + i, ETrue); // Each added char makes the character position one after that character valid
			}
		for (TInt l = lineNum+1; l <= iWindow.iHeight; l++)
			{
			iLineData->SetDocumentPositionForLine(l, iLineData->DocumentPosition(l) + aText.Length());
			}
		MoveCursor(aText.Length(),0);
		}
	else
		{
		RedrawFromPositionToEndOfLine(pos, aText.Length());
		CenterDocPosOnScreen(pos + aText.Length());
		}
	}

void CLRTextView::RedrawFromPositionToEndOfLine(TInt aDocumentPosition, TInt aNumCharsInserted)
	{
	TPoint point = WindowLocationForDocumentPosition(aDocumentPosition);
	ASSERT(point.iY >= 0);
	iDrawPoint = point + iWindow.Origin();
	// Try and avoid redrawing the whole screen if the RequestData doesn't make the line longer (in terms of screen lines)
	TInt lastScreenLineForCurrentLine = point.iY;
	while (iLineData->FileLineNumber(lastScreenLineForCurrentLine+1) == iLineData->FileLineNumber(lastScreenLineForCurrentLine))
		{
		// We have to allow for the current line wrapping onto additional screen lines
		lastScreenLineForCurrentLine++;
		}
	iOldNextLine = lastScreenLineForCurrentLine + 1;
	iOldNextLineDocPos = iLineData->DocumentPosition(iOldNextLine);
	iPredictedOldNextLineDocPosDelta = aNumCharsInserted;
	RequestData(EFalse, aDocumentPosition);
	}

void CLRTextView::DeleteTextL(TInt aNumChars)
	{
	if (!iBuffer.Editable() || iLineIsErrorMessage) return;

	CancelMark();
	ASSERT(aNumChars >= -1); // Can't backspace more than one character
	TInt pos = DocumentPosition();
	TRange range;
	if (aNumChars < 0)
		range = TRange(pos + aNumChars, -aNumChars);
	else
		range = TRange(pos, aNumChars);
	range.Intersect(TRange(0, KMaxTInt)); // Clamp the range to zero

	if (range.iLength)
		{
		iBuffer.DeleteTextL(range);
		TInt line = iCursor.iY;
		if (aNumChars == -1) MoveCursor(-1, 0);
		// Seems to be an issue using RedrawFromPositionToEndOfLine when deleting from the start of a line - since we know it wouldn't be worth using it in that case, don't do it.
		if (iCursor.iY == line && aNumChars == -1)
			{
			RedrawFromPositionToEndOfLine(range.iLocation, -range.iLength);
			}
		else
			{
			iDrawPoint = iCursor + iWindow.Origin();
			RequestData(EFalse, DocumentPosition());
			}
		}
	}

void CLRTextView::DeleteCurrentLineL()
	{
	if (!iBuffer.Editable() || iLineIsErrorMessage) return;

	CancelMark();
	TInt currentLine = iCursor.iY;
	TInt lineStart = iLineData->DocumentPosition(currentLine);
	TInt lineLen = iLineData->DocumentPosition(currentLine+1) - lineStart;
	if (lineLen > 0)
		{
		TRange range(lineStart, lineLen);
		iBuffer.DeleteTextL(range);
		iDrawPoint = TPoint(iWindow.iX, iWindow.iY + iCursor.iY);
		RequestData(EFalse, lineStart);
		}
	}

void CLRTextView::UpdateCursor(const TPoint& aNewPos)
	{
	CTextView::UpdateCursor(aNewPos);
	UpdateStatus();
	}

void CLRTextView::UpdateStatus()
	{
	if (iLineIsErrorMessage)
		{
		iConsoleProvider.WriteStatus(iLine, KNullDesC);
		return;
		}

	_LIT(KUnknownDelim, "CRLF"); // Since that's what it will get output as
	_LIT(KUnknownEnc, "UTF-8"); // ditto
	const TDesC* lineEnding = &KUnknownDelim;
#define CASE_LIT(res, x, y) case x: { _LIT(KName, y); res = &KName; break; }
	switch(iBuffer.DelimiterType())
		{
		CASE_LIT(lineEnding, EDelimLF, "LF")
		CASE_LIT(lineEnding, EDelimCR, "CR")
		CASE_LIT(lineEnding, EDelimCRLF, "CRLF")
		CASE_LIT(lineEnding, EDelimUnicode, "UniLF")
		default:
			break;
		}
	const TDesC* encoding = &KUnknownEnc;
	switch (iBuffer.Encoding())
		{
		CASE_LIT(encoding, EEncodingNarrow, "8-bit")
		CASE_LIT(encoding, EEncodingUtf8, "UTF-8")
		CASE_LIT(encoding, EEncodingUtf16LE, "UTF-16LE")
		CASE_LIT(encoding, EEncodingUtf16BE, "UTF-16BE")
		default:
			break;
		}

	const TDesC* modified = &KNullDesC;
	if (iBuffer.Modified())
		{
		_LIT(KMod, "(*)");
		modified = &KMod;
		}

	TInt currentLine = iLineData->FileLineNumber(iCursor.iY) + 1; // Human-readable line numbers are always shown as 1-based
	TInt currentCol = iCursor.iX + 1; // Human-readable col numbers are always shown as 1-based, annoying as it is we will do the same
	TInt docPos = DocumentPosition();
	_LIT(KStatus, "%S %S %S Ln:%d Col:%d Char:%d");
	_LIT(KShortStatus, "%S %S %S Ln:%d");
	_LIT(KMarkStatus, "Mark@%d. ^X/^C to complete. Ln:%d Ch:%d");
	const TDesC* title = &iBuffer.Title();
	_LIT(KUntitled, "untitled");
	if (title->Length() == 0) title = &KUntitled;
	if (MarkActive())
		{
		iConsoleProvider.WriteStatus(KNullDesC, KMarkStatus, iMarkDocPos, currentLine, docPos);
		}
	else if (iConsole.ScreenSize().iWidth < 50)
		{
		iConsoleProvider.WriteStatus(*title, KShortStatus, modified, lineEnding, encoding, currentLine);
		}
	else
		{
		iConsoleProvider.WriteStatus(*title, KStatus, modified, lineEnding, encoding, currentLine, currentCol, docPos);
		}
	}

void CLRTextView::GoToLine()
	{
	TBuf<32> lineText;
	TBool go = iConsoleProvider.QueryText(_L("Go to line: "), lineText);
	if (go == EFalse) return;

	TLex lex(lineText);
	TBool gotoLine = ETrue;
	if (lex.Peek() == 'c')
		{
		// Go to character pos
		lex.Inc();
		gotoLine = EFalse;
		}

	TInt pos;
	TInt err = lex.Val(pos);
	if (err || pos <= 0)
		{
		iConsoleProvider.InfoPrint(_L("Couldn't parse line number '%S'"), &lineText);
		return;
		}

	if (gotoLine && pos > 1)
		{
		GoToLine(pos-1); // -1 to change 1-based display number to internal 0-based.
		}
	else
		{
		CenterDocPosOnScreen(pos-1);
		}
	}

void CLRTextView::GoToLine(TInt aLine)
	{
	TInt err = iBuffer.SeekFromOffset(*this, 0, aLine, KMaxTInt); 
	if (err)
		{
		HandleDataLoadError(err);
		}
	else
		{
		CenterDocPosOnScreen(iRange.iLocation);
		}
	}

void CLRTextView::Find()
	{
	TBool searchBackwards = EFalse;
	TBool proceed = iConsoleProvider.QueryText(_L("Find text: "), iFindText);
	while (proceed)
		{
		TInt nextLineStart = iLineData->DocumentPosition(iCursor.iY + 1);
		iConsoleProvider.InfoPrint(_L("Searching..."));
		TInt found = iBuffer.Find(nextLineStart, iFindText, searchBackwards);
		if (found == KErrNotFound)
			{
			iConsoleProvider.InfoPrint(_L("Cannot find '%S'"), &iFindText);
			proceed = EFalse;
			}
		else if (found < 0)
			{
			iConsoleProvider.InfoPrint(_L("Error during searching: %d"), found);
			proceed = EFalse;
			}
		else
			{
			CenterDocPosOnScreen(found);
			/*TKeyCode ch = iConsoleProvider.Query(_L("Search again? (next/previous/cancel) "));
			if (ch == 'n')
				{
				searchBackwards = EFalse;
				continue;
				}
			else if (ch == 'p')
				{
				searchBackwards = ETrue;
				continue;
				}
			else*/
				{
				proceed = EFalse;
				}
			}
		}
	}

void CLRTextView::CenterDocPosOnScreen(TInt aDocumentPosition)
	{
	const TInt numScreenLines = iWindow.iHeight;
	TPoint point = WindowLocationForDocumentPosition(aDocumentPosition);
	if (point.iY != -1)
		{
		// pos is on screen already - just move the cursor
		UpdateCursor(point);
		return;
		}

	TInt err = iBuffer.SeekFromOffset(*this, aDocumentPosition, -(numScreenLines/2), iWindow.iWidth-1);
	if (err)
		{
		HandleDataLoadError(err);
		}
	else
		{
		iDrawPoint.SetXY(iWindow.iX, iWindow.iY);
		DoDrawL(EFalse); // EFalse to say we will update the cursor and status ourselves
		UpdateCursor(WindowLocationForDocumentPosition(aDocumentPosition));
		}
	}

void CLineData::EnsureCapacityL(TInt aWidth, TInt aHeight)
	{
	if (!iDocPosAndLine || (TUint)User::AllocLen(iDocPosAndLine) < sizeof(TInt)*2 * (aHeight+1))
		{
		User::Free(iDocPosAndLine);
		iDocPosAndLine = NULL;
		iDocPosAndLine = (TInt*)User::AllocZL(sizeof(TInt)*2*(aHeight+1));
		}
	iLineLen = aWidth-1;
	TInt lineWidthBytes = ((iLineLen+7)&~7)/8;
	TInt screenBytes = lineWidthBytes * (aHeight+1);
	if (!iScreenIndexes || User::AllocLen(iScreenIndexes) < screenBytes)
		{
		User::Free(iScreenIndexes);
		iScreenIndexes = NULL;
		iScreenIndexes = (TUint8*)User::AllocZL(screenBytes);
		}
	SetPositionIsValid(0, 0, ETrue); // This position is always valid even if the document is empty
	}

TInt CLineData::DocumentPosition(TInt aLine) const
	{
	return iDocPosAndLine[aLine*2];
	}

TInt CLineData::FileLineNumber(TInt aLine) const
	{
	return iDocPosAndLine[aLine*2 + 1];
	}

const TUint8& CLineData::ByteForPos(TInt aLine, TInt aCol, TInt& aOffset) const
	{
	return const_cast<CLineData*>(this)->ByteForPos(aLine, aCol, aOffset);
	}

TUint8& CLineData::ByteForPos(TInt aLine, TInt aCol, TInt& aOffset)
	{
	TInt lineWidthBytes = ((iLineLen+7)&~7)/8;
	TInt byteIndex = aLine*lineWidthBytes + aCol/8;
	aOffset = aCol%8;
	TUint8& b = iScreenIndexes[byteIndex];
	return b;
	}

TBool CLineData::IsScreenPositionValid(TInt aLine, TInt aCol) const
	{
	TInt offset;
	TUint8 b = ByteForPos(aLine, aCol, offset);
	return b & (1 << offset);
	}

void CLineData::SetDocumentPositionForLine(TInt aLine, TInt aDocumentPosition)
	{
	ASSERT(iDocPosAndLine && aLine*2*sizeof(TInt) < (TUint)User::AllocLen(iDocPosAndLine));
	iDocPosAndLine[aLine*2] = aDocumentPosition;
	}

void CLineData::SetFileLineNumberForLine(TInt aLine, TInt aFileLineNumber)
	{
	ASSERT(iDocPosAndLine && (aLine*2+1)*sizeof(TInt) < (TUint)User::AllocLen(iDocPosAndLine));
	iDocPosAndLine[aLine*2 + 1] = aFileLineNumber;
	}

void CLineData::SetPositionIsValid(TInt aLine, TInt aCol, TBool aValid)
	{
	TInt offset;
	TUint8& b = ByteForPos(aLine, aCol, offset);
	if (aValid)
		{
		b |= (1<<offset);
		}
	else
		{
		b &= ~(1<<offset);
		}
	}

void CLineData::LineFinishedAt(TInt aLine, TInt aCol)
	{
	if (aCol >=0 && aCol < iLineLen) SetPositionIsValid(aLine, aCol, ETrue); //  The last position on the line is valid even though nothing is drawn there
	TInt offset;
	TUint8& b = ByteForPos(aLine, aCol+1, offset); // Plus one as we want to clear everything beyond the aCol position
	// Clear everything above the offset'th bit
	b &= (1 << offset) - 1;
	// And clear all bytes from b to the end of the line
	TUint8* endb = &ByteForPos(aLine, iLineLen-1, offset);
	// Armv5 doesn't like passing in a length of zero to memset, not sure why. Anyway, check there are actually some other bytes that need clearing
	if (endb > &b)
		{
		Mem::FillZ((&b)+1, endb - &b);
		}
	}

CLineData::~CLineData()
	{
	User::Free(iDocPosAndLine);
	User::Free(iScreenIndexes);
	}

TInt CLineData::LastValidPosition(TInt aLine) const
	{
	TInt offset;
	TInt pos = iLineLen-1; // Start comparing from the last possible valid position
	const TUint8* b = &ByteForPos(aLine, pos, offset);
	while(*b == 0)
		{
		b--; // Optimisation to skip over blanks
		pos -= offset+1;
		offset = 7;
		}

	while (offset >= 0 && ((*b) & (1<<offset)) == 0)
		{
		pos--;
		offset--;
		}
	ASSERT(IsScreenPositionValid(aLine, pos)); // Something's gone very wrong in the logic of this function if this assert is not true!
	return pos;
	}

void CLRTextView::CopyToClipboardL(const TDesC& aBuf)
	{
	LtkUtils::CopyToClipboardL(aBuf, &iConsoleProvider.Fs());
	}

HBufC* CLRTextView::GetFromClipboardL()
	{
	return LtkUtils::GetFromClipboardL(&iConsoleProvider.Fs());
	}

void CLRTextView::PasteL()
	{
	HBufC* text = GetFromClipboardL();
	CleanupStack::PushL(text);
	if (text->Length() == 0)
		{
		iConsoleProvider.InfoPrint(_L("Nothing to paste"));
		}
	else
		{
		InsertTextL(*text);
		}
	CleanupStack::PopAndDestroy(text);
	}

TPoint CLRTextView::WindowLocationForDocumentPosition(TInt aDocumentPosition) const
	{
	TPoint result(-1,-1); // We return this if doc pos is not on screen
	const TInt numScreenLines = iWindow.iHeight;
	if (aDocumentPosition >= iLineData->DocumentPosition(0) && aDocumentPosition < iLineData->DocumentPosition(numScreenLines))
		{
		// pos is on screen
		for (TInt line = 0; line < numScreenLines; line++)
			{
			if (aDocumentPosition < iLineData->DocumentPosition(line+1))
				{
				result.iY = line;
				TInt docPos = iLineData->DocumentPosition(line);
				TInt column = 0;
				// Find the column screen position whose document position is what we want
				for (; docPos <= aDocumentPosition; column++)
					{
					if (iLineData->IsScreenPositionValid(line, column))
						{
						docPos++;
						}
					}
				result.iX = column-1;
				break;
				}
			}
		}
	return result;
	}

void CLRTextView::SetMark()
	{
	iMarkFlasher->Cancel();
	iMarkDocPos = DocumentPosition();
	iMarkShown = EFalse;
	const TInt KFlashInterval = 500000;
	iMarkFlasher->Start(0, KFlashInterval, TCallBack(&FlashMark, this));
	UpdateStatus();
	iConsoleProvider.InfoPrint(_L("Mark set. Move cursor then press ^X/^C to cut/copy"));
	}

void CLRTextView::CancelMark()
	{
	if (MarkActive())
		{
		iMarkFlasher->Cancel();
		if (WindowLocationForDocumentPosition(iMarkDocPos).iY != -1)
			{
			// If the mark pos is on screen, redraw it to get rid of the '*'
			RedrawFromPositionToEndOfLine(iMarkDocPos, 0);
			}
		}
	}

TInt CLRTextView::FlashMark(TAny* aSelf)
	{
	static_cast<CLRTextView*>(aSelf)->DoFlashMark();
	return 1;
	}

void CLRTextView::DoFlashMark()
	{
	TPoint markPos = WindowLocationForDocumentPosition(iMarkDocPos);
	if (markPos.iY != -1)
		{
		TPoint cursor = iConsole.CursorPos();
		iConsole.SetCursorPosAbs(markPos);
		if (iMarkShown)
			iConsole.Write(_L(" "));
		else
			iConsole.Write(_L("*"));
		iMarkShown = !iMarkShown;
		iConsole.SetCursorPosAbs(cursor);
		}
	}

TBool CLRTextView::MarkActive() const
	{
	return iMarkFlasher->IsActive();
	}

void CLRTextView::CopyOrCutL(TBool aCut)
	{
	TInt docPos = DocumentPosition();
	const TInt start = Min(docPos, iMarkDocPos);
	const TInt len = Abs(docPos - iMarkDocPos);
	CancelMark();
	RBuf textCopy;
	CleanupClosePushL(textCopy);
	TInt dataPos = start;
	while(ETrue)
		{
		TInt err = iBuffer.GetData(*this, dataPos);
		if (err)
			{
			HandleDataLoadError(err);
			CleanupStack::PopAndDestroy(&textCopy);
			return;
			}
		else
			{
			TPtrC text = iDes.Left(len - textCopy.Length());
			if (textCopy.MaxLength() == 0 && len <= iRange.iLength)
				{
				// All fits in one buffer, no need to copy anything!
				CopyToClipboardL(text);
				break;
				}
			else
				{
				// Need to do some copying
				if (textCopy.MaxLength() == 0) textCopy.CreateL(len);
				textCopy.Append(text);
				dataPos += text.Length();
				if (textCopy.Length() == len)
					{
					// Done
					CopyToClipboardL(textCopy);
					break;
					}
				}
			}
		}
	CleanupStack::PopAndDestroy(&textCopy);
	if (aCut)
		{
		TRange range(start, len);
		iBuffer.DeleteTextL(range);
		iCursor = WindowLocationForDocumentPosition(start);
		if (iCursor.iY == -1)
			{
			// Start of the selection is offscreen - force a scroll
			CenterDocPosOnScreen(start);
			}
		else
			{
			iDrawPoint = iCursor + iWindow.Origin();
			RequestData(EFalse, start);
			}
		iConsoleProvider.InfoPrint(_L("Text cut to clipboard"));
		}
	else
		{
		iConsoleProvider.InfoPrint(_L("Text copied to clipboard"));
		}
	}

void CLRTextView::UpdateDocumentPositionsStartingAtLine(TInt aLine, TInt aDelta)
	{
	// This is important because even though we can optimise away the drawing, when a line has changed
	// length but not caused wrapping, we still need to make sure the document positions of all the
	// lines we didn't draw are correct to reflect the extra characters.
	for (TInt i = aLine; i < iWindow.iHeight+1; i++)
		{
		iLineData->SetDocumentPositionForLine(i, iLineData->DocumentPosition(i) + aDelta);
		}
	}