/*

* Copyright (c) 1997-1999 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

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

*

*/

#include "EIKCONCL.H"

#include "EIKCONCL.PAN"

#include <eikconso.h>

#include <eikenv.h>

#include <eikappui.h>  

#include <basched.h>

#include <apgwgnam.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <eikdef.h>

#else

#include <eikdef.h>

#include <uikon/eikdefmacros.h>

#endif

#include <avkon.hrh>

#include <aknSctDialog.h>

#include <avkon.rsg>

#include <c32comm.h>

#include <aknappui.h>

GLDEF_C void Panic(TEikConClPanic aPanic)

	{

	_LIT(KPanicCat,"EIKON-CONCL");

	User::Panic(KPanicCat,aPanic);

	}

class CEikConsMessager;

class CCommsKeyReader : public CActive

	{

public:

	CCommsKeyReader(RComm& aComm, CEikConsMessager* aMessager);

	~CCommsKeyReader();

private:

	void RunL();

	void DoCancel();

	void Start();

private:

	RComm& iComm;

	CEikConsMessager* iMessager;

	TBuf8<1> iBuf;

	TBuf8<4> iMatch;

	};

class CCommsKeyWriter : public CActive

	{

public:

	CCommsKeyWriter(RComm& aComm);

	~CCommsKeyWriter();

	void Write(const TDesC& aDes);

private:

	void WriteIfReady();

	void RunL();

	void DoCancel();

	void AppendBlocking(TText8 aChar);

private:

	RComm& iComm;

	TBuf8<256> iBuf;

	TBuf8<256> iWrite;

	TBool iInFakeCancel;

	};

enum

	{

	EExit,

	ERead,

	EReadCancel,

	EWrite,

	ESetCursorPosAbs,

	ESetCursorPosRel,

	ESetCursorHeight,

	ESetTitle,

	EClearScreen,

	EClearToEndOfLine

	};

struct TFepKey

	{

	TText iLong;

	const TText* iLower;

	const TText* iUpper;

	};

const TFepKey KFepKeyTable[] = 

	{

		{ '0', _S(" 0\r"), _S(" 0\r") },

		{ '1', _S("\\.:1#*/-+=\"',()|`!$%^&_[]{};@~<>?"), _S("\\.:1#*/-+=\"',()|`!$%^&_[]{};@~<>?") },

		{ '2', _S("abc2"), _S("ABC2") },

		{ '3', _S("def3"), _S("DEF3") },

		{ '4', _S("ghi4"), _S("GHI4") },

		{ '5', _S("jkl5"), _S("JKL5") },

		{ '6', _S("mno6"), _S("MNO6") },

		{ '7', _S("pqrs7"), _S("PQRS7") },

		{ '8', _S("tuv8"), _S("TUV8") },

		{ '9', _S("wxyz9"), _S("WXYZ9") }

	};

const TText* const KModeNames[] = 

	{

	_S("Lower"),

	_S("Caps"),

	_S("Numeric")

	};

const TText* const KIOModeNames[] = 

	{

	_S("Screen"),

	_S("Serial"),

	_S("Ansi-Serial")

	};

_LIT(KCommModule, "IRCOMM");

_LIT(KCommPort, "IRCOMM::0");

//

// class CEikConsMessager

//

class CEikConsMessager : public CActive

	{

public:

	enum TMyFlags

		{

		EShift,

		EDigitPressed

		};

	enum TKeyMode

		{

		ELower,

		ECaps,

		ENumeric,

		ENumModes

		};

	enum TIOMode

		{

		EScreen,

		ESerial,

		EAnsi,

		ENumIOModes

		};

public:

	CEikConsMessager(CEikConsoleScreen* aScreen,RThread aParentThread);

	~CEikConsMessager();

	void ConstructL(CEikConsoleClient* aClient);

	void HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType);

	void AddKeyEvent(const TKeyEvent& aKeyEvent);

private: // overridden

	void RunL();

	void DoCancel();

private: // internal

	void CompleteReadRequest();

private: // fep like stuff

	void StartTimer();

	static TInt TimerCallBack(TAny* aThis);

	void DoTimer();

	void LaunchSCTL();

	void HandleDigit(const TKeyEvent& aKeyEvent, TEventCode aType);

	void StartCommsL();

	void StopComms();

	void WriteComms(const TDesC& aMsg);

private:

	CEikConsoleScreen* iScreen;

	RThread iParentThread;

	TRequestStatus* iReadStatus;

	TKeyEvent* iKeyEvent;

	TInt iMessage;

	const TAny* iParam;

	TRequestStatus* iReplyStatus;

	CCirBuf<TKeyEvent>* iKeyQ;

	// fep like stuff

	TKeyEvent iLastKey;

	CPeriodic* iTimer;

	TBitFlags iFlags;

	TInt iMultiStep;

	TKeyMode iKeyMode;

	TIOMode iIOMode;

	RCommServ iCommServ;

	RComm iComm;

	CCommsKeyReader* iReader;

	CCommsKeyWriter* iWriter;

	};

CEikConsMessager::CEikConsMessager(CEikConsoleScreen* aScreen,RThread aParentThread)

	: CActive(EActivePriorityIpcEventsHigh),

	iParentThread(aParentThread)

	{

	iScreen=aScreen;

	}

CEikConsMessager::~CEikConsMessager()

	{

	StopComms();

	delete iTimer;

	iParentThread.Close();

	delete iKeyQ;

	}

void CEikConsMessager::ConstructL(CEikConsoleClient* aClient)

	{

	iTimer = CPeriodic::NewL(EPriorityStandard);

	iKeyQ=new(ELeave) CCirBuf<TKeyEvent>;

	iKeyQ->SetLengthL(40);	// buffer length, too high? too low?

	iKeyEvent=(&aClient->iKeyEvent);

	aClient->iThreadStatus=(&iStatus);

	aClient->iMessage=(&iMessage);

	aClient->iParam=(&iParam);

	aClient->iReplyStatus=(&iReplyStatus);

	aClient->iScreen=iScreen;

	CActiveScheduler::Add(this);

	iStatus=KRequestPending;

	SetActive();

	}

void CEikConsMessager::DoCancel()

	{

	}

void CEikConsMessager::RunL()

	{

	switch (iMessage)

		{

	case EExit:

		CBaActiveScheduler::Exit();

		break;

	case ERead:

		if (iReadStatus)

			Panic(EEikConClPanicReadAlreadyOutstanding);

		iReadStatus=(TRequestStatus*)iParam;

		if (iKeyQ->Count()>0) // already a buffered event

			CompleteReadRequest();

		break;

	case EReadCancel:

		if (iReadStatus)

			iParentThread.RequestComplete(iReadStatus,KErrCancel);

		break;

	case EWrite:

		iScreen->Write(*(const TDesC*)iParam);

		if (iIOMode != EScreen)

			WriteComms(*(const TDesC*)iParam);

		break;

	case ESetCursorPosAbs:

		iScreen->SetCursorPosAbs(*(const TPoint*)iParam);

		if (iIOMode == EAnsi)

			{

			TPoint point = iScreen->CursorPos();

			TBuf<10> buf;

			buf.Format(_L("\033[%d;%dH"), point.iY, point.iX);

			WriteComms(buf);

			}

		break;

	case ESetCursorPosRel:

		iScreen->SetCursorPosRel(*(const TPoint*)iParam);

		if (iIOMode == EAnsi)

			{

			TPoint point = iScreen->CursorPos();

			TBuf<10> buf;

			buf.Format(_L("\033[%d;%dH"), point.iY, point.iX);

			WriteComms(buf);

			}

		break;

	case ESetCursorHeight:

		iScreen->SetCursorHeight((TInt)iParam);

		break;

	case EClearScreen:

		iScreen->ClearScreen();

		if (iIOMode == EAnsi)

			{

			WriteComms(_L("\033[2J"));

			}

		break;

	case EClearToEndOfLine:

		iScreen->ClearToEndOfLine();

		if (iIOMode == EAnsi)

			{

			WriteComms(_L("\033[K"));

			}

		break;

		}

	iStatus=KRequestPending;

	SetActive();

	iParentThread.RequestComplete(iReplyStatus,0);

	}

void CEikConsMessager::CompleteReadRequest()

	{

	if (iReadStatus)

		{ 

		iKeyQ->Remove(iKeyEvent);;

		iParentThread.RequestComplete(iReadStatus,0);

		}

	}

void CEikConsMessager::HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

	{

	iFlags.Assign(EShift, aKeyEvent.iModifiers & EModifierShift);

	if ('0' <= aKeyEvent.iScanCode && aKeyEvent.iScanCode <= '9')

		{

		HandleDigit(aKeyEvent, aType);

		}

	else if (aKeyEvent.iScanCode == EStdKeyHash)

		{

		if (aType == EEventKeyDown)

			{

			if (iFlags[EShift])

				{

				iIOMode = TIOMode((iIOMode+1)%ENumIOModes);

				User::InfoPrint(TPtrC(KIOModeNames[iIOMode]));

				if (iIOMode == ESerial)

					{

					StartCommsL();

					}

				else if (iIOMode == EScreen)

					StopComms();

				}

			else

				{

				iKeyMode = TKeyMode((iKeyMode+1)%ENumModes);

				User::InfoPrint(TPtrC(KModeNames[iKeyMode]));

				}

			iTimer->Cancel();

			}

		}

	else if (aType == EEventKey)

		{

		if (aKeyEvent.iCode == '*')

			{

			LaunchSCTL();

			iTimer->Cancel();

			}

		else if (aKeyEvent.iCode != EKeyF21)

			{

			AddKeyEvent(aKeyEvent);

			iTimer->Cancel();

			}

		}

	}

void CEikConsMessager::AddKeyEvent(const TKeyEvent& aKeyEvent)

	{

	TInt ret=iKeyQ->Add(&aKeyEvent);

	if (ret==0)

		CEikonEnv::Beep();

	if (iKeyQ->Count()==1) // client may be waiting on this key event

		CompleteReadRequest();

	}

void CEikConsMessager::LaunchSCTL()

	{

    TBuf<8> specialChars;

    TBool shift = !COMPARE_BOOLS(iFlags[EShift], (iKeyMode==ECaps));

    TInt sctCase = (shift ? EAknSCTUpperCase : EAknSCTLowerCase);

    CAknCharMapDialog* dialog=new(ELeave) CAknCharMapDialog(sctCase, specialChars);

    if (dialog->ExecuteLD(R_AVKON_SPECIAL_CHARACTER_TABLE_DIALOG))

        {

        TKeyEvent event =  { 0, 0, 0, 0 };

        for ( TInt ii = 0; ii < specialChars.Length(); ii++)

            {

            if ( specialChars[ii] == 0x000A ) // 0x000A is line feed

                {

                event.iCode = EKeyEnter;

                event.iScanCode = EKeyEnter;

                }

            else

                {

                event.iCode = specialChars[ii];

                event.iScanCode = specialChars[ii];

                }

            AddKeyEvent(event);

            }

        }

    }

void CEikConsMessager::HandleDigit(const TKeyEvent& aKeyEvent, TEventCode aType)

	{

	TText digit = TText(aKeyEvent.iScanCode);

	__ASSERT_DEBUG('0' <= digit && digit <= '9', Panic(EEikConClPanicIllegalFepChar));

	TBool shift = !COMPARE_BOOLS(iFlags[EShift], (iKeyMode==ECaps));

	const TFepKey& fepKey = KFepKeyTable[digit - '0'];

	TPtrC keys(shift ? fepKey.iUpper : fepKey.iLower);

	if (iKeyMode == ENumeric)

		{

		if (aType == EEventKey)

			{

			AddKeyEvent(aKeyEvent);

			iTimer->Cancel();

			}

		}

	else

		{

		if (aType == EEventKeyDown)

			{

			iFlags.Set(EDigitPressed);

			if (digit == iLastKey.iScanCode)

				{

				iMultiStep = (iMultiStep + 1) % keys.Length();

				TKeyEvent del = {EKeyBackspace, EStdKeyBackspace, 0, 0};

				AddKeyEvent(del);

				TKeyEvent event = {keys[iMultiStep], keys[iMultiStep], 0, 0};

				AddKeyEvent(event);

				}

			else

				{

				iMultiStep = 0;

				TKeyEvent event = {keys[iMultiStep], keys[iMultiStep], 0, 0};

				AddKeyEvent(event);

				}

			StartTimer();

			iLastKey = aKeyEvent;

			}

		else if (aType == EEventKeyUp)

			{

			iFlags.Clear(EDigitPressed);

			}

		}

	}

void CEikConsMessager::StartTimer()

	{

	iTimer->Cancel();

	iTimer->Start(800000, 1000000, TCallBack(TimerCallBack, this));

	}

TInt CEikConsMessager::TimerCallBack(TAny* aThis)

	{

	((CEikConsMessager*)aThis)->DoTimer();

	return 0;

	}

void CEikConsMessager::DoTimer()

	{

	if (iFlags[EDigitPressed])

		{

		TText digit = TText(iLastKey.iScanCode);

		__ASSERT_DEBUG('0' <= digit && digit <= '9', Panic(EEikConClPanicIllegalFepChar));

		TText key = KFepKeyTable[digit - '0'].iLong;

		TKeyEvent del = {EKeyBackspace, EStdKeyBackspace, 0, 0};

		AddKeyEvent(del);

		TKeyEvent event = {key, key, 0, 0};

		AddKeyEvent(event);

		iFlags.Clear(EDigitPressed);

		}

	iLastKey.iScanCode = 0;

	iMultiStep = 0;

	}

void CEikConsMessager::StartCommsL()

	{

	User::LeaveIfError(iCommServ.Connect());

	User::LeaveIfError(iCommServ.LoadCommModule(KCommModule));

	User::LeaveIfError(iComm.Open(iCommServ, KCommPort, ECommExclusive));

	TCommConfig cBuf;

	iComm.Config(cBuf);

	TCommConfigV01& c=cBuf();

	c.iRate=EBps115200;

	c.iDataBits=EData8;

	c.iStopBits=EStop1;

	c.iParity=EParityNone;

	User::LeaveIfError(iComm.SetConfig(cBuf));

	delete iReader;

	iReader=0;

	iReader = new(ELeave) CCommsKeyReader(iComm, this);

	delete iWriter;

	iWriter=0;

	iWriter = new(ELeave) CCommsKeyWriter(iComm);

	}

void CEikConsMessager::StopComms()

	{

	delete iWriter;

	iWriter=0;

	delete iReader;

	iReader=0;

	iComm.Close();

	iCommServ.Close();

	}

void CEikConsMessager::WriteComms(const TDesC& aMsg)

	{

	if (iWriter)

		{

		iWriter->Write(aMsg);

		}

	}

struct TEscSeq

	{

	TText8 iText[4];

	TKeyCode iCode;

	TStdScanCode iScanCode;

	};

const TEscSeq KEscSeqs[] =

	{

		{"[?D", EKeyLeftArrow, EStdKeyLeftArrow},

		{"[?C", EKeyRightArrow, EStdKeyRightArrow},

		{"[?A", EKeyUpArrow, EStdKeyUpArrow},