// line_editor.cpp

// 

// Copyright (c) 2006 - 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 "line_editor.h"

#include <f32file.h>

#include <fshell/ioutils.h>

#include <fshell/common.mmh>

using namespace IoUtils;

//

// Constants.

//

_LIT(KSpace, " ");

_LIT(KNewLine, "\r\n");

_LIT(KBackspace, "\x08 \x08");

//

// RConsole.

//

RConsole::RConsole(MAbstractConsoleWriter& aStdout)

	: iStdout(aStdout), iCursorPos(TPoint(0, 0)), iCursorMode(EInsert), iCursorVisible(EFalse)

	{

	iStdout.GetScreenSize(iSize);

	SetCursorVisible(ETrue);

	}

void RConsole::Close()

	{

	iScrollObservers.Close();

	}

void RConsole::Start()

	{

	Refresh();

	}

void RConsole::Refresh()

	{

	iStdout.GetScreenSize(iSize);

	iStdout.GetCursorPos(iCursorPos);

	}

void RConsole::Write(const TDesC &aDes)

	{

	const TInt desLength = aDes.Length();

	for (TInt i = 0; i < desLength; ++i)

		{

		switch(aDes[i])

			{

			case 0x00:	// Null.

				break;

			case 0x07:	// Bell.

				break;

			case 0x08:	// Backspace.

			case 0x7f:	// Delete.

				CursorLeft();

				break;

			case 0x09:	// Tab.

			case 0x0b:	// Vertical tab.

			case 0x0c:  // Form feed.

				// These should already have been swallowed by CLineEditor::HandleKey.

				ASSERT(FALSE);

				break;

			case 0x0a:

				LineFeed();

				break;

			case 0x0d:

				CarriageReturn();

				break;

			default:

				CursorRight();

			}

		}

	iStdout.Write(aDes);

	}

void RConsole::SetCursorPosAbs(const TPoint& aPoint)

	{

	iCursorPos = aPoint;

	iStdout.SetCursorPosAbs(aPoint);

	}

void RConsole::SetCursorPosRel(const TPoint& aPoint)

	{

	iCursorPos += aPoint;

	iStdout.SetCursorPosRel(aPoint);

	}

void RConsole::MoveCursorLeft()

	{

	CursorLeft();

	iStdout.SetCursorPosAbs(iCursorPos);

	}

void RConsole::MoveCursorRight()

	{

	CursorRight();

	iStdout.SetCursorPosAbs(iCursorPos);

	}

void RConsole::SetCursorMode(TCursorMode aMode)

	{

	iCursorMode = aMode;

	SetCursorVisible(iCursorVisible);

	}

void RConsole::SetCursorVisible(TBool aVisible)

	{

	iCursorVisible = aVisible;

	iStdout.SetCursorHeight(iCursorVisible ? (iCursorMode == EInsert ? 20 : 100) : 0);

	}

void RConsole::ClearToEndOfLine()

	{

	iStdout.ClearToEndOfLine();

	// no affect on cursor position

	}

void RConsole::Clear()

	{

	iStdout.ClearScreen();

	iCursorPos.iX = iCursorPos.iY = 0;

	}

TPoint RConsole::PosFrom(const TPoint& aStartPos, TInt aLength) const

	{

	// if the width is 0 we'll enter an infinite loop below.

	if (iSize.iWidth == 0) return TPoint(aStartPos.iX + aLength, aStartPos.iY);

	TPoint endPos(aStartPos);

	if (aLength > 0)

		{

		while (aLength)

			{

			const TInt min = Min(iSize.iWidth - endPos.iX, aLength);

			aLength -= min;

			if ((endPos.iX + min) < iSize.iWidth)

				{

				endPos.iX += min;

				}

			else

				{

				ASSERT((endPos.iX + min) == iSize.iWidth);

				endPos.iX = 0;

				++endPos.iY;

				}

			}

		}

	else

		{

		aLength = -aLength;

		while (aLength)

			{

			const TInt min = Min(endPos.iX, aLength);

			if (min == 0)

				{

				endPos.iX = (iSize.iWidth - 1);

				--endPos.iY;

				--aLength;

				}

			else 

				{

				endPos.iX -= min;

				aLength -= min;

				}

			}

		}

	return endPos;

	}

TPoint RConsole::CursorPos() const

	{

	return iCursorPos;

	}

TInt RConsole::AddObserver(MConsoleScrollObserver& aObserver)

	{

	return iScrollObservers.Append(&aObserver);

	}

void RConsole::RemoveObserver(MConsoleScrollObserver& aObserver)

	{

	const TInt numObservers = iScrollObservers.Count();

	for (TInt i = 0; i < numObservers; ++i)

		{

		if (iScrollObservers[i] == &aObserver)

			{

			iScrollObservers.Remove(i);

			return;

			}

		}

	ASSERT(EFalse);

	}

TSize RConsole::Size() const

	{

	return iSize;

	}

void RConsole::CursorLeft()

	{

	if (iCursorPos.iX > 0)

		{

		// Not yet reached beginning of line.

		--iCursorPos.iX;

		}

	else if (iCursorPos.iY > 0)

		{

		// Reached beginning of line, so jump to end of line above.

		iCursorPos.iX = (iSize.iWidth - 1);

		--iCursorPos.iY;

		}

	}

void RConsole::CursorRight()

	{

	if (iCursorPos.iX < (iSize.iWidth - 1))

		{

		// Not yet reached the end of the line.

		++iCursorPos.iX;

		}

	else if (iCursorPos.iY < (iSize.iHeight - 1))

		{

		// Reached the end of the line and there's space below - jump to the beginning of the line below.

		iCursorPos.iX = 0;

		++iCursorPos.iY;

		}

	else

		{

		// Reached the end of the line and there's no space below - console will scroll up a line and jump to the beginning of the newly exposed line.

		iCursorPos.iX = 0;

		NotifyScrollObservers();

		}

	}

void RConsole::LineFeed()

	{

	if (iCursorPos.iY < (iSize.iHeight - 1))

		{

		iCursorPos.iX = 0;

		++iCursorPos.iY;

		}

	else

		{

		iCursorPos.iX = 0;

		NotifyScrollObservers();

		}

	}

void RConsole::CarriageReturn()

	{

	iCursorPos.iX = 0;

	}

void RConsole::NewLine()

	{

	iStdout.Write(KNewLine);

	iCursorPos.iX = 0;

	if (iCursorPos.iY < (iSize.iHeight - 1))

		{

		++iCursorPos.iY;

		}

	else

		{

		iCursorPos.iX = 0;

		NotifyScrollObservers();

		}

	}

void RConsole::NotifyScrollObservers()

	{

	const TInt numObservers = iScrollObservers.Count();

	for (TInt i = 0; i < numObservers; ++i)

		{

		iScrollObservers[i]->CsoHandleConsoleScrolled();

		}

	}

//

// TConsoleLine.

//

EXPORT_C TConsoleLine::TConsoleLine(RConsole& aConsole)

	: iConsole(aConsole), iPromptLength(0), iBufPos(0), iStartPos(aConsole.CursorPos()), iHidden(ETrue)

	{

	}

EXPORT_C void TConsoleLine::Start(const TDesC& aPrompt)

	{

	Start(aPrompt, KNullDesC);

	}

EXPORT_C void TConsoleLine::Start(const TDesC& aPrompt, const TDesC& aInitialInput)

	{

	if (iStarted)

		{

		Restart(aPrompt);

		return;

		}

	iStarted = ETrue;

	if (!iHidden)

		{

		iConsole.AddObserver(*this);

		}

	iConsole.Start();

	iBuf = aPrompt;

	iBuf.Append(aInitialInput);

	iPromptLength = aPrompt.Length();

	iBufPos = iBuf.Length();

	if (!iHidden)

		{

		Redraw();

		iConsole.SetCursorVisible(ETrue);

		}

	}

void TConsoleLine::Abort()

	{

	iStarted = EFalse;

	iConsole.RemoveObserver(*this);

	}

void TConsoleLine::Restart(const TDesC& aPrompt)

	{

	// a) Hide the cursor.

	// b) Move the cursor to the start of the line.

	// c) Create a buffer that will fully overwrite the old line.

	// d) Write the buffer to the console.

	// e) Set the cursor to the end of the new prompt.

	// f) Make the cursor visible again.

	iConsole.SetCursorVisible(EFalse);

	iConsole.SetCursorPosAbs(iStartPos);

	const TInt origBufLength = iBuf.Length();

	iBuf = aPrompt;

	if (iBuf.Length() < origBufLength)

		{

		iBuf.AppendFill(' ', origBufLength - iBuf.Length());

		}

	iConsole.Write(iBuf);

	iConsole.SetCursorPosAbs(iConsole.PosFrom(iStartPos, aPrompt.Length()));

	iBuf.SetLength(aPrompt.Length());

	iBufPos = aPrompt.Length();

	iConsole.SetCursorVisible(ETrue);

	}

EXPORT_C void TConsoleLine::Insert(TChar aChar)

	{

	TPtrC charDes((TUint16*)&aChar, 1);

	const TInt availableSpace = iBuf.MaxLength() - iBuf.Length();

	if (iBufPos < iBuf.Length())

		{

		if (availableSpace < 1)

			{

			iBuf.Delete(iBuf.Length() - 1, 1);

			}

		iBuf.Insert(iBufPos, charDes);

		iConsole.SetCursorVisible(EFalse);

		iConsole.Write(iBuf.Mid(iBufPos));

		iConsole.SetCursorPosAbs(iConsole.PosFrom(iConsole.CursorPos(), iBufPos - iBuf.Length() + 1));

		iConsole.SetCursorVisible(ETrue);

		iBufPos++;

		}

	else

		{

		ASSERT(iBufPos == iBuf.Length());

		if (availableSpace > 0)

			{

			++iBufPos;

			iBuf.Append(charDes);

			iConsole.Write(charDes);

			}

		}

	}

EXPORT_C void TConsoleLine::Overwrite(TChar aChar)

	{

	if (iBufPos < iBuf.MaxLength())

		{

		TPtrC charDes((TUint16*)&aChar, 1);

		if (iBufPos < iBuf.Length())

			{

			iBuf.Replace(iBufPos++, 1, charDes);

			}

		else

			{

			ASSERT(iBufPos == iBuf.Length());

			iBuf.Append(charDes);

			++iBufPos;

			}

		iConsole.Write(charDes);

		}

	}

EXPORT_C void TConsoleLine::Replace(const TDesC& aDes)

	{

	// a) Hide the cursor.

	// b) Move the cursor to the start of the line (after the prompt).

	// c) Create a buffer that will fully overwrite the old line.

	// d) Write the buffer to the console.

	// e) Set the cursor to the end of the new line contents.

	// f) Make the cursor visible again.

	iConsole.SetCursorVisible(EFalse);

	iConsole.SetCursorPosAbs(iConsole.PosFrom(iStartPos, iPromptLength));

	const TInt origBufLength = iBuf.Length() - iPromptLength;

	iBuf.Delete(iPromptLength, origBufLength);

	iBuf.Append(aDes);

	if (aDes.Length() < origBufLength)

		{

		iBuf.AppendFill(' ', origBufLength - aDes.Length());

		}

	iConsole.Write(iBuf.Mid(iPromptLength));

	iConsole.SetCursorPosAbs(iConsole.PosFrom(iStartPos, iPromptLength + aDes.Length()));

	iBuf.SetLength(iPromptLength + aDes.Length());

	iBufPos = iPromptLength + aDes.Length();

	iConsole.SetCursorVisible(ETrue);

	}

EXPORT_C void TConsoleLine::Replace(TInt aFrom, const TDesC& aDes)

	{

	// a) Hide the cursor.

	// b) Move the cursor to aFrom.

	// c) Overwrite chars up to iBufPos.

	// d) Insert remaining chars (if any).

	// e) Make the cursor visible again.

	aFrom += iPromptLength;

	ASSERT(iBufPos >= aFrom);

	iConsole.SetCursorVisible(EFalse);

	iConsole.SetCursorPosAbs(iConsole.PosFrom(iStartPos, aFrom));

	const TInt desLength = aDes.Length();

	const TInt numOverwriteChars = iBufPos - aFrom;

	TInt lengthAdjust = 0;

	if (numOverwriteChars > 0)

		{

		iBuf.Replace(aFrom, numOverwriteChars, aDes.Left(numOverwriteChars));

		if (desLength < numOverwriteChars)

			{

			lengthAdjust = numOverwriteChars - desLength;

			iBuf.AppendFill(' ', lengthAdjust);

			iBufPos -= lengthAdjust;

			}

		}

	const TInt numInsertChars = desLength - numOverwriteChars;

	if (numInsertChars > 0)

		{

		iBuf.Insert(iBufPos, aDes.Mid(numOverwriteChars));

		iBufPos += numInsertChars;

		}

	iConsole.Write(iBuf.Mid(aFrom));

	iBuf.SetLength(iBuf.Length() - lengthAdjust);

	iConsole.SetCursorPosAbs(iConsole.PosFrom(iStartPos, aFrom + aDes.Length()));

	iConsole.SetCursorVisible(ETrue);

	}

EXPORT_C void TConsoleLine::Redraw()

	{

	if (!iStarted) return;

	iConsole.Refresh();

	iStartPos = iConsole.CursorPos();

	if (iStartPos.iX > 0)

		{

		iConsole.NewLine();

		iStartPos = iConsole.CursorPos();

		}

	iConsole.Write(iBuf);

	iConsole.SetCursorPosAbs(iConsole.PosFrom(iStartPos, iBufPos));

	}

EXPORT_C void TConsoleLine::End()

	{

	iStarted = EFalse;

	if (!iHidden)

		{

		iConsole.RemoveObserver(*this);

		if (iBufPos < iBuf.Length())

			{

			iConsole.SetCursorPosAbs(iConsole.PosFrom(iStartPos, iBuf.Length()));

			}

		iConsole.NewLine();

		}

	}

EXPORT_C void TConsoleLine::DeleteLeft()

	{

	if (iBufPos > iPromptLength)

		{

		iBuf.Delete(--iBufPos, 1);

		iConsole.SetCursorVisible(EFalse);

		if (iBufPos == iBuf.Length())

			{

			iConsole.Write(KBackspace);

			}

		else

			{

			iBuf.Append(KSpace);

			iConsole.MoveCursorLeft();

			TPoint cursorPos(iConsole.CursorPos());

			iConsole.Write(iBuf.Mid(iBufPos));

			iBuf.SetLength(iBuf.Length() - 1);

			iConsole.SetCursorPosAbs(cursorPos);

			}

		iConsole.SetCursorVisible(ETrue);

		}

	}

EXPORT_C void TConsoleLine::DeleteRight()

	{

	if (iBufPos < iBuf.Length())

		{

		iBuf.Delete(iBufPos, 1);

		iConsole.SetCursorVisible(EFalse);

		TPoint cursorPos(iConsole.CursorPos());

		iBuf.Append(KSpace);