// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// f32\etshell\ts_edshl.cpp

// CLineEdit and CShell code

// 

//

#include <e32hal.h>

#include "ts_std.h"

#include "ts_clicomp.h"

#include "cleanuputils.h"

CLineEdit* CShell::TheEditor;

CFileMan* CShell::TheFileMan;

TBuf<KMaxFileName> CShell::currentPath;

RFs CShell::TheFs;

CConsoleBase* CShell::TheConsole;

CCliCompleter* CShell::TheCliCompleter;

class CFileManObserver : public MFileManObserver

	{

	TControl NotifyFileManEnded();

	};

MFileManObserver::TControl CFileManObserver::NotifyFileManEnded()

//

// Print out what CFileMan is doing

//

	{

	TInt err=CShell::TheFileMan->GetLastError();

	TFileName srcfile;

	CShell::TheFileMan->GetCurrentSource(srcfile);

	if (err!=KErrNone)

		{

		if(err == KErrNotReady)

			{

			FOREVER

				{

				CShell::TheConsole->Printf(_L("Not ready - Retry? [y/n]\n"));

				TChar key = CShell::TheConsole->Getch();

				key.UpperCase();

				if(key == 'Y')

					{

					return(MFileManObserver::ERetry);

					}

				if(key == 'N')

					{

					return(MFileManObserver::EAbort);

					}

				}

			}

		else

			{

			CShell::TheConsole->Printf(_L("Error %d\n"),err);

			}

		}

	else

		{			

		switch (CShell::TheFileMan->CurrentAction())

			{

			case CFileMan::ECopy:

				CShell::TheConsole->Printf(_L("Copied %S\n"),&srcfile);

				break;

			case CFileMan::EAttribs:

				CShell::TheConsole->Printf(_L("Setting Attributes for %S\n"),&srcfile);

				break;

			case CFileMan::EDelete:

				CShell::TheConsole->Printf(_L("Deleted %S\n"),&srcfile);

				break;

			case CFileMan::EMove:

				CShell::TheConsole->Printf(_L("Moved %S\n"),&srcfile);

				break;

			case CFileMan::ERename:

				CShell::TheConsole->Printf(_L("Renamed %S\n"),&srcfile);

				break;

			case CFileMan::ERmDir:

				CShell::TheConsole->Printf(_L("RmDir deleted %S\n"),&srcfile);

				break;

			default:

				CShell::TheConsole->Printf(_L("Unknown action %S\n"),&srcfile);

				break;

				}

		}

	return(MFileManObserver::EContinue);

	}

LOCAL_C TInt charToDrive(TChar aChar,TInt& aDrive)

//

// Convert the drive character to a drive index.

//

	{

	TInt r=RFs::CharToDrive(aChar,aDrive);

	return(r);

	}

CLineEdit::CLineEdit()

//

// Constructor

//

	{

	}

CLineEdit::~CLineEdit()

//

// Destroy the line editor

//

	{

    if (iHistory)

        {

        TInt count=iHistory->Count();

        while (count--)

            User::Free((*iHistory)[count]);

        delete iHistory;

        }

	}

CLineEdit* CLineEdit::NewL(CConsoleBase* aConsole,TInt aMaxHistory)

//

// Create a new line editor

//

	{

	CLineEdit* pE=new(ELeave) CLineEdit;

    CleanupStack::PushL(pE);

	pE->iHistory=new(ELeave) CArrayFixFlat<HBufC*>(aMaxHistory+2);

	pE->iConsole=aConsole;

	pE->iMaxHistory=aMaxHistory;

	pE->iWidth=CShell::TheConsole->ScreenSize().iWidth;

	pE->iHeight=CShell::TheConsole->ScreenSize().iHeight;

	// !E32WindowServer Text Shell Console has frame 

	// of 2 characters each vertically and horizontally.

	// !Windowserver Shell Console does not.

	// Assume no Frame is present !

	TFindServer findServer;

	TFullName wsName;

	TInt err = KErrNone;

	pE->iFrameSizeChar=TSize(0,0);

	// Find: !E32WindowServer is running?

	while (err=findServer.Next(wsName), err==KErrNone)

		{

		if(err=wsName.FindF(KE32WindowServer), err!=KErrNotFound)

			{

			// E32WindowServer is running. 

			// Frame is present ! Frame Size is (2,2) !

			pE->iFrameSizeChar=TSize(2,2);

			break;

			}

		}

    CleanupStack::Pop();

	return(pE);

	}

TInt CLineEdit::Lines()

//

// The number of lines being edited.

//

    {

    TInt nL=1;

    if (Buf().Length()>=iWidth-iFrameSizeChar.iWidth-iOrigin)

		nL+=(Buf().Length()+iOrigin)/(iWidth-iFrameSizeChar.iWidth);

    return(nL);

    }

TPoint CLineEdit::Where()

//

// Return the real cursor position.

//

    {

    if (iPos>=(iWidth-iFrameSizeChar.iWidth-iOrigin))

		return(TPoint((iPos+iOrigin)%(iWidth-iFrameSizeChar.iWidth),((iPos+iOrigin)/(iWidth-iFrameSizeChar.iWidth))+iLine));

	return(TPoint(iPos+iOrigin,iLine));

    }

void CLineEdit::ClearLine()

//

// Clears the line being edited.

//

    {

    if (Buf().Length())

		{

		TInt nL=Lines();

		while (nL--)

	    	{

	    	iConsole->SetPos(nL ? 0 : iOrigin,iLine+nL);

	    	iConsole->ClearToEndOfLine();

	    	}

		Buf().Zero();

		iPos=0;

		}

    }

void CLineEdit::ClearLast(TInt aCnt)

//

// Clears the last aCnt characters.

//

    {

    TInt aPos=iPos;

    iPos=((TInt)Buf().Length())-aCnt;

    while (iPos<((TInt)Buf().Length()))

		{

		TPoint p=Where();

		iConsole->SetCursorPosAbs(p);

		iConsole->ClearToEndOfLine();

		iPos+=(iWidth-p.iX);

		}

    iPos=aPos;

    }

void CLineEdit::Recall()

//

// Recall a line for editing.

//

    {

	if (iRecall!=(-1))

		{

		ClearLine();

		HBufC* pL=(*iHistory)[iRecall];

		Buf()=(*pL);

		iConsole->Write(Buf());

		iPos=Buf().Length();

		TInt nL=Lines();

		if ((iLine+nL)>iHeight)

			iLine -= iLine + nL - iHeight;	

		}

    }

TInt CLineEdit::WordLeft()

//

// Position the cursor to the next word left.

//

    {

    TInt x=iPos-1;

    while (x && TChar(Buf()[x]).IsSpace())

		x--;

    while (x && TChar(Buf()[x]).IsGraph())

		x--;

    if (TChar(Buf()[x]).IsSpace())

		x++;

    return(x);

    }

TInt CLineEdit::WordRight()

//

// Position the cursor to the next word right.

//

    {

    TInt x=iPos;

    while (x<(TInt)Buf().Length() && TChar(Buf()[x]).IsGraph())

		x++;

    while (x<(TInt)Buf().Length() && TChar(Buf()[x]).IsSpace())

		x++;

    return(x);

    }

void CLineEdit::Cursor()

//

// Position the cursor.

//

    {

    iConsole->SetCursorPosAbs(Where());

    }

void CLineEdit::Refresh()

//

// Refresh the line.

//

    {

	iConsole->SetCursorHeight(ECursorNone);

    iConsole->SetPos(iOrigin,iLine);

    iConsole->Write(Buf());

	Cursor();

	iConsole->SetCursorHeight(iMode==EEditOverWrite ? ECursorNormal : ECursorInsert);

    }

TLineEditAction CLineEdit::Edit(const TDesC& aPrompt, TDes* aBuf, TBool aNewLine)

//

// Start the editor or a single key fetch.

//

	{

	iBuf = aBuf;

	if(aNewLine)

		{

		iMode = EEditInsert;

		iConsole->Write(aPrompt);

		iConsole->SetCursorHeight(iMode == EEditOverWrite ? ECursorNormal : ECursorInsert);

		iOrigin = iConsole->WhereX();

		iLine = iConsole->WhereY();  

		}

	if(iBuf->Length() == 0)

		{			

		iPos = 0;

		}

	Refresh();

	iRecall = (-1);

	TInt hCount = iHistory->Count();

	if (hCount > iMaxHistory)

		{

		hCount = iMaxHistory;

		}

	FOREVER

		{

		TChar gChar = iConsole->Getch();

		switch (gChar)

	    	{

		case EKeyEscape:

	    	ClearLine();

			iRecall=(-1);

	    	break;

		case EKeyHome:

	    	iPos=0;

	    	Cursor();

	    	break;

		case EKeyLeftArrow:

	    	if (iPos)

                {

                if(iConsole->KeyModifiers()==EModifierCtrl)

                    iPos=WordLeft();

                else

    				iPos--;

                Cursor();

                }

	    	break;

		case EKeyRightArrow:

	    	if (iPos<((TInt)Buf().Length()))

                {

                if(iConsole->KeyModifiers()==EModifierCtrl)

                    iPos=WordRight();

                else

    				iPos++;

                Cursor();

                }

	    	break;

		case EKeyEnd:

	    	iPos=((TInt)Buf().Length());

	    	Cursor();

	    	break;

		case EKeyPageUp:

	    	if (hCount==0)

				break;

	    	iRecall=hCount-1;

	    	Recall();

	    	break;

		case EKeyUpArrow:

	    	if (iRecall==(-1))	//	Beginning of history

				{

				if (hCount==0)

		    		break;

				iRecall=0;

				}

	    	else if (iRecall>=(hCount-1))	//	End

				{

				ClearLine();

				iRecall=(-1);

				break;

				}

	    	else

				iRecall++;

	    	Recall();

	    	break;

		case EKeyDownArrow:

	    	if (iRecall==(-1))

				{

				if (hCount==0)

		    		break;

				iRecall=hCount-1;

				}

	    	else if (iRecall==0)

				{

				ClearLine();

				iRecall=(-1);

				break;

				}

	    	else

				iRecall--;

	    	Recall();

	    	break;

		case EKeyPageDown:

	    	if (hCount==0)

				break;

	    	iRecall=0;

	    	Recall();

	    	break;

		case EKeyEnter:

			NewLine();

			StoreBufferHistory();		

	    	return EShellCommand;

		case EKeyBackspace:

	    	if (iPos)

				{

				TInt iN=1;

				if (iConsole->KeyModifiers()==EModifierCtrl)

		    		iN=iPos-WordLeft();

				ClearLast(iN);

				iPos-=iN;

				Buf().Delete(iPos,iN);

				Refresh();

				}

	    	break;

		case EKeyDelete:

	    	if (iPos<((TInt)Buf().Length()))

				{

				TInt iN=1;

				if (iConsole->KeyModifiers()==EModifierCtrl)

		    		iN=WordRight()-iPos;

				ClearLast(iN);

				Buf().Delete(iPos,iN);

				Refresh();

				}

	    	break;

		case EKeyInsert:

	    	iMode=(iMode==EEditOverWrite ? EEditInsert : EEditOverWrite);

			iConsole->SetCursorHeight(iMode==EEditOverWrite ? ECursorNormal : ECursorInsert);

	    	break;

		case EKeyTab:

			return ECommandCompletion;

		default:

   	    	if (!gChar.IsPrint())

				break;

	    	if (iMode==EEditOverWrite && iPos<((TInt)Buf().Length()))

				Buf()[iPos++]=(TText)gChar;

	    	else if (Buf().Length()<KShellMaxCommandLine)

				{

				TInt oL=Lines();

				TBuf<0x02> b;

				b.Append(gChar);

				Buf().Insert(iPos++,b);

				TInt nL=Lines();

				if (nL!=oL)

		    		{

		    		iConsole->SetCursorHeight(ECursorNone);

		    		iConsole->SetPos(0,iLine+oL-1);

		    		iConsole->Write(_L("\n"));

		    		iConsole->SetPos(0,iLine);

		    		if (iLine+nL>iHeight-iFrameSizeChar.iHeight)

						iLine=iHeight-iFrameSizeChar.iHeight-nL;

		    		}

				}

			else

				{

				iConsole->Write(_L("\7"));

				iConsole->SetPos((iOrigin+iPos)%(iWidth-iFrameSizeChar.iWidth),iLine+Lines()-1);

				break;

				}

			Refresh();

			}

		}

	}

void CLineEdit::NewLine()

	{

 	iConsole->SetCursorHeight(ECursorNone);

 	iLine += (Lines() - 1);

 	iConsole->SetPos(0, iLine);

 	iConsole->Write(_L("\n")); // Just a line feed

 	iRecall = (-1);

	}

void CLineEdit::StoreBufferHistory()

	{

    Buf().TrimRight(); 

	if (Buf().Length()>=1)

		{

        //-- find out if we already have exactly the same command in the history.

        //-- if it is there, don't add a new item, just move it to the top

        for(TInt i=0; i<iHistory->Count(); ++i)

        {

            HBufC* pCmd = iHistory->At(i);    

            const TDesC& cmdLine = pCmd->Des();

            if(cmdLine == Buf())

            {

                iHistory->Delete(i);

                TRAP_IGNORE(iHistory->InsertL(0, pCmd));

                return;

            }

        }

        if (iHistory->Count()==iMaxHistory+1)

			{

			User::Free((*iHistory)[iMaxHistory]);

    		iHistory->Delete(iMaxHistory);

			}

        HBufC* pB=Buf().Alloc();

		if(pB != NULL)