// 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++)

		{