// Copyright (c) 1996-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:

 // e32\drivers\edisp\epoc\generic\wd_vt100.cpp

 // Display/Keyboard driver using VT100 terminal

 // 

 //

 #include "ws_std.h"

 #include <d32comm.h>

 #include <e32svr.h>

 /**

  * Define a comms driver and port to use.

  */

 //#define __USE_RDEBUG_OUTPUT

 #define __USE_SERIAL_INPUT

 const TInt KPortNumber=1;

 #if defined(__USE_SERIAL_INPUT) || !defined(__USE_RDEBUG_OUTPUT)

 #define __COMMS_DRIVER_NEEDED

 _LIT(KPddName,"EUART");

 _LIT(KLddName,"ECOMM");

 #endif

 class CSerialKeyboard : public CActive

 	{

 public:

 	static CSerialKeyboard* NewL();

 	~CSerialKeyboard();

 	void GetKey();

 public:

 	CSerialKeyboard();

 	void ConstructL();

 	void RunL();

 	void DoCancel();

 	TInt KeyCode();

 public:

 #ifdef __COMMS_DRIVER_NEEDED

 	RBusDevComm iDevComm;

 	TBuf8<1> iBuf;

 #endif

 	};

 #define SHIFTED(x)   (0x8000|(x))

 #define ISSHIFTED(x) (0x8000&(x))

 #define FUNCED(x)    (0x4000|(x))

 #define ISFUNCED(x)  (0x4000&(x))

 #define CTRLED(x)    (0x2000|(x))

 #define ISCTRLED(x)  (0x2000&(x))

 #define STDKEY(x)    (0x1FFF&(x))

 const TUint16 convertCode[] =

 	{

 /*00 NUL*/  EStdKeyNull,

 /*01 SOH*/  CTRLED('A'),	// ^A

 /*02 STX*/  CTRLED('B'),	// ^B

 /*03 ETX*/  CTRLED('C'),	// ^C

 /*04 EOT*/  CTRLED('D'),	// ^D

 /*05 ENQ*/  CTRLED('E'),	// ^E

 /*06 ACK*/  CTRLED('F'),	// ^F

 /*07 BEL*/  CTRLED('G'),	// ^G

 /*08 BS */  EStdKeyBackspace,

 /*09 TAB*/  CTRLED(FUNCED('5')),

 /*0a LF */  CTRLED('J'),	// ^J

 /*0b VT */  CTRLED('K'),	// ^K

 /*0c FF */  CTRLED('L'),	// ^L

 /*0d CR */  EStdKeyEnter,

 /*0e SO */  CTRLED('N'),	// ^N

 /*0f SI */  CTRLED('O'),	// ^O

 /*10 DLE*/  CTRLED('P'),	// ^P

 /*11 DC1*/  CTRLED('Q'),	// ^Q

 /*12 DC2*/  CTRLED('R'),	// ^R

 /*13 DC3*/  CTRLED('S'),	// ^S

 /*14 DC4*/  CTRLED('T'),	// ^T

 /*15 NAK*/  CTRLED('U'),	// ^U

 /*16 SYN*/  CTRLED('V'),	// ^V

 /*17 ETB*/  CTRLED('W'),	// ^W

 /*18 CAN*/  CTRLED('X'),	// ^X

 /*19 EM */  CTRLED('Y'),	// ^Y

 /*1a SUB*/  CTRLED('Z'),	// ^Z

 /*1b ESC*/  EStdKeyEscape,

 /*1c FS */  EStdKeyNull,	// ^backslash -> ignored

 /*1d GS */  EStdKeyNull,	// ^] -> ignored

 /*1e RS */  EStdKeyNull,	// ^^ -> ignored

 /*1f US */  EStdKeyNull,	// ^_ -> ignored

 /*20*/  EStdKeySpace,

 /*21*/  SHIFTED('1'),       // !

 /*22*/  SHIFTED('2'),       // "

 /*23*/  EStdKeyHash,        // #

 /*24*/  SHIFTED('4'),       // $

 /*25*/  SHIFTED('5'),       // %

 /*26*/  SHIFTED('7'),       // &

 /*27*/  EStdKeySingleQuote,

 /*28*/  SHIFTED('9'),       // (

 /*29*/  SHIFTED('0'),       // )

 /*2a*/  SHIFTED('8'),       // *

 /*2b*/  SHIFTED(EStdKeyEquals), // +

 /*2c*/  EStdKeyComma,       // ,

 /*2d*/  EStdKeyMinus,       // -

 /*2e*/  EStdKeyFullStop,    // .

 /*2f*/  EStdKeyForwardSlash,// forward slash

 /*30*/  '0',

 /*31*/  '1',

 /*32*/  '2',

 /*33*/  '3',

 /*34*/  '4',

 /*35*/  '5',

 /*36*/  '6',

 /*37*/  '7',

 /*38*/  '8',

 /*39*/  '9',

 /*3a*/  SHIFTED(EStdKeySemiColon),  // :

 /*3b*/  EStdKeySemiColon,           // ;

 /*3c*/  SHIFTED(EStdKeyComma),      // <

 /*3d*/  EStdKeyEquals,              // =

 /*3e*/  SHIFTED(EStdKeyFullStop),   // >

 /*3f*/  SHIFTED(EStdKeyForwardSlash), // ?

 /*40*/  SHIFTED(EStdKeySingleQuote),  // @

 /*41*/  SHIFTED('A'),

 /*42*/  SHIFTED('B'),

 /*43*/  SHIFTED('C'),

 /*44*/  SHIFTED('D'),

 /*45*/  SHIFTED('E'),

 /*46*/  SHIFTED('F'),

 /*47*/  SHIFTED('G'),

 /*48*/  SHIFTED('H'),

 /*49*/  SHIFTED('I'),

 /*4a*/  SHIFTED('J'),

 /*4b*/  SHIFTED('K'),

 /*4c*/  SHIFTED('L'),

 /*4d*/  SHIFTED('M'),

 /*4e*/  SHIFTED('N'),

 /*4f*/  SHIFTED('O'),

 /*50*/  SHIFTED('P'),

 /*51*/  SHIFTED('Q'),

 /*52*/  SHIFTED('R'),

 /*53*/  SHIFTED('S'),

 /*54*/  SHIFTED('T'),

 /*55*/  SHIFTED('U'),

 /*56*/  SHIFTED('V'),

 /*57*/  SHIFTED('W'),

 /*58*/  SHIFTED('X'),

 /*59*/  SHIFTED('Y'),

 /*5a*/  SHIFTED('Z'),

 /*5b*/  EStdKeySquareBracketLeft,   // [

 /*5c*/  EStdKeyBackSlash,           // backslash

 /*5d*/  EStdKeySquareBracketRight,  // ]

 /*5e*/  SHIFTED('6'),               // ^

 /*5f*/  SHIFTED(EStdKeyMinus),      // _

 /*60*/  EStdKeyXXX,					// Actually `

 /*61*/  'A',

 /*62*/  'B',

 /*63*/  'C',

 /*64*/  'D',

 /*65*/  'E',

 /*66*/  'F',

 /*67*/  'G',

 /*68*/  'H',

 /*69*/  'I',

 /*6a*/  'J',

 /*6b*/  'K',

 /*6c*/  'L',

 /*6d*/  'M',

 /*6e*/  'N',

 /*6f*/  'O',

 /*70*/  'P',

 /*71*/  'Q',

 /*72*/  'R',

 /*73*/  'S',

 /*74*/  'T',

 /*75*/  'U',

 /*76*/  'V',

 /*77*/  'W',

 /*78*/  'X',

 /*79*/  'Y',

 /*7a*/  'Z',

 /*7b*/  SHIFTED(EStdKeySquareBracketLeft),  // {

 /*7c*/  SHIFTED(EStdKeyBackSlash),          // |

 /*7d*/  SHIFTED(EStdKeySquareBracketRight),	// }

 /*7e*/  SHIFTED(EStdKeyHash),				// ~

 /*7f*/  EKeyDelete

 	};

 CSerialKeyboard* CSerialKeyboard::NewL()

 	{

 	CSerialKeyboard* self = new(ELeave) CSerialKeyboard;

 	self->ConstructL();

 	return self;

 	}

 CSerialKeyboard::CSerialKeyboard()

 	:	CActive(0)

 	{

 	}

 void CSerialKeyboard::ConstructL()

 	{

 #ifdef __COMMS_DRIVER_NEEDED

 	// load and connect to serial port

 	TInt r=User::LoadPhysicalDevice(KPddName);

 	if (r!=KErrNone && r!=KErrAlreadyExists)

 		User::Leave(r);

 	r=User::LoadLogicalDevice (KLddName);

 	if (r!=KErrNone && r!=KErrAlreadyExists)

 		User::Leave(r);

 	r=iDevComm.Open(KPortNumber);

 	User::LeaveIfError(r);

 	TCommConfig cfgBuf;

 	TCommConfigV01& cfg=cfgBuf();

 	iDevComm.Config(cfgBuf);

 	cfg.iRate=EBps115200;

 	cfg.iDataBits=EData8;

 	cfg.iStopBits=EStop1;

 	cfg.iParity=EParityNone;

 	cfg.iHandshake=0;//KConfigObeyXoff|KConfigSendXoff;

 	cfg.iFifo=EFifoEnable;

 	cfg.iTerminatorCount=0;

 	cfg.iSIREnable=ESIRDisable;

 	User::LeaveIfError(iDevComm.SetConfig(cfgBuf));

 #endif

 	CActiveScheduler::Add(this);

 	}

 CSerialKeyboard::~CSerialKeyboard()

 	{

 	Cancel();

 	}

 void CSerialKeyboard::GetKey()

 	{

 	__ASSERT_ALWAYS(!IsActive(), User::Panic(_L("CSerialKeyboard"),1));

 	// wait for a key

 #ifdef __USE_SERIAL_INPUT

 	iDevComm.Read(iStatus,iBuf,1);

 #endif

 	SetActive();

 	}

 TInt CSerialKeyboard::KeyCode()

 	{

 	TInt c=-1;

 #ifdef __USE_SERIAL_INPUT

 	if (iBuf.Length()>0)

 		c=iBuf[0];

 #endif

 	return c;

 	}

 void CSerialKeyboard::RunL()

 	{

 	TInt c=KeyCode();

 	if (c>=0)

 		{

 		// convert character to keycode and shift, func, ctrl status

 		TUint16 code = convertCode[c];

 		TBool isShifted = ISSHIFTED(code);

 		TBool isFunced = ISFUNCED(code);

 		TBool isCtrled = ISCTRLED(code);

 		TUint8 stdKey = STDKEY(code);

 		TRawEvent e;

 		// post it as a sequence of events

 		if (isShifted)

 			{

 			e.Set(TRawEvent::EKeyDown,EStdKeyRightShift,0);

 			UserSvr::AddEvent(e);

 			}

 		if (isCtrled)

 			{

 			e.Set(TRawEvent::EKeyDown,EStdKeyLeftCtrl,0);

 			UserSvr::AddEvent(e);

 			}

 		if (isFunced)

 			{

 			e.Set(TRawEvent::EKeyDown,EStdKeyLeftFunc,0);

 			UserSvr::AddEvent(e);

 			}

 		e.Set(TRawEvent::EKeyDown,stdKey,0);

 		UserSvr::AddEvent(e);

 		e.Set(TRawEvent::EKeyUp,stdKey,0);

 		UserSvr::AddEvent(e);

 		if (isFunced)

 			{

 			e.Set(TRawEvent::EKeyUp,EStdKeyLeftFunc,0);

 			UserSvr::AddEvent(e);

 			}

 		if (isCtrled)

 			{

 			e.Set(TRawEvent::EKeyUp,EStdKeyLeftCtrl,0);

 			UserSvr::AddEvent(e);

 			}

 		if (isShifted)

 			{

 			e.Set(TRawEvent::EKeyUp,EStdKeyRightShift,0);

 			UserSvr::AddEvent(e);

 			}

 		}

 	// get another key

 	GetKey();

 	}

 void CSerialKeyboard::DoCancel()

 	{

 #ifdef __USE_SERIAL_INPUT

 	iDevComm.ReadCancel();

 #endif

 	}

 class CScreenDriverVT100 : public CScreenDriver

 	{

 public:

 	CScreenDriverVT100();

 	virtual void Init(TSize &aScreenSize,TSize &aFontSize);

 	virtual void Blit(const TText *aBuffer,TInt aLength,const TPoint &aPosition);

 	virtual TBool ScrollUp(const TRect& aRect);

 	virtual void Clear(const TRect& aRect);

 	virtual void SetPixel(const TPoint& aPoint,TUint8 aColour);

 	virtual TInt GetPixel(const TPoint& aPoint);

 	virtual void SetWord(const TPoint& aPoint,TInt aWord);

 	virtual TInt GetWord(const TPoint& aPoint);

 	virtual void SetLine(const TPoint& aPoint,const TPixelLine& aPixelLine);

 	virtual void GetLine(const TPoint& aPoint,TPixelLine& aPixelLine);

 	virtual TInt SetMode(TVideoMode aMode);

 	virtual void SetPaletteEntry(TColorIndex anIndex,TUint8 aRed,TUint8 aGreen,TUint8 aBlue) {}

 	virtual void GetPaletteEntry(TColorIndex anIndex,TUint8 &aRed,TUint8 &aGreen,TUint8 &aBlue) {}

 	virtual void SetForegroundColor(TColorIndex anIndex) {}

 	virtual void SetBackgroundColor(TColorIndex anIndex) {}

 	virtual void GetAttributeColors(TColorIndex* anArray) {}

 	//

 	void Update(const TRect &aRect);

 	void Print(const TDesC8& aDes);

 	TUint8 *iScreenBuffer;

 private:

 	CSerialKeyboard *iSerialKeyboard;

 	};

 const TInt KScreenWidth = 80;

 const TInt KScreenHeight = 24;

 CScreenDriverVT100::CScreenDriverVT100()

 //

 // Constructor

 //

 	{

 	}

 EXPORT_C CScreenDriver *CScreenDriver::New()

 //

 // Return the actual screen driver.

 //

 	{

     CScreenDriverVT100 *pS=new CScreenDriverVT100;

 	pS->iScreenBuffer=new TUint8 [KScreenWidth*KScreenHeight];

 	return pS;

 	}

 void CScreenDriverVT100::Init(TSize& aScreenSize, TSize& aFontSize)

 	{

 	// Report screen information

 	aFontSize=TSize(8,10);

 	aScreenSize=TSize(KScreenWidth,KScreenHeight);

 	// start keyboard

 	TRAPD(r,iSerialKeyboard = CSerialKeyboard::NewL());

     // must panic if there are not enough resources to continue

     __ASSERT_ALWAYS(r==KErrNone, User::Panic(_L("CSerialKeyboard"),2));

 	iSerialKeyboard->GetKey();

 	}

 TInt CScreenDriverVT100::SetMode(TVideoMode aMode)

 //

 // Set the screen mode

 //

 	{

 	return(KErrNotSupported);

 	}

 void CScreenDriverVT100::Update(const TRect &aRect)

 	{

 	TBuf8<0x100> buf;

 	TInt i;

 	for (i=aRect.iTl.iY; i<=aRect.iBr.iY; i++)

 		{

 		buf.Format(_L8("\x1b[%02d;%02dH"), i+1, aRect.iTl.iX+1);

 		TPtrC8 ptr(iScreenBuffer+(aRect.iTl.iX+i*KScreenWidth),aRect.iBr.iX-aRect.iTl.iX);

 		buf.Append(ptr);

 		Print(buf);

 		}

 	Print(_L8("\x1b[01;01H"));

 	}

 void CScreenDriverVT100::Blit(const TText *aBuffer, TInt aLength, const TPoint &aPosition)

 //

 // Write contiguous block of characters to some segment of a line on the display

 //

 	{

 	TUint8 *ptr=iScreenBuffer+(aPosition.iX+aPosition.iY*KScreenWidth);

 	const TText* endBuf = aBuffer + aLength;

 	while (aBuffer < endBuf)

 		*ptr++ = (TUint8)*aBuffer++;

 	Update(TRect(aPosition.iX, aPosition.iY, aPosition.iX+aLength, aPosition.iY));

 	}

 TBool CScreenDriverVT100::ScrollUp(const TRect& aRect)

 //

 // Scroll a rectangle of the screen up one line, don't update bottom line

 //

 	{

 	TInt j;

 	for (j=aRect.iTl.iY; j<aRect.iBr.iY; j++)

 		{

 		TUint8 *ptr=iScreenBuffer+(aRect.iTl.iX+j*KScreenWidth);

 		Mem::Copy(ptr, ptr+KScreenWidth, aRect.iBr.iX-aRect.iTl.iX);

 		}

 	if ((aRect.iTl.iX<=1) && (aRect.iBr.iX>=KScreenWidth-2))

 		{

 		// Optimisation: range of whole lines

 		TBuf8<0x100> buf;

 		// cursor pos

 		buf.Format(_L8("\x1b[%02d;%02dH\xd\xa\xba\x1b[%02dC\xba"), aRect.iBr.iY, 1, aRect.iBr.iX);

 		Print(buf);

 		// set scroll region

 		buf.Format(_L8("\x1b[%02d;%02dr\xd\xa"), aRect.iTl.iY+1, aRect.iBr.iY);

 		Print(buf);

 		Print(_L8("\x1b[01;01H"));

 		}

 	else

 		Update(aRect);

 	return(ETrue);

 	}

 void CScreenDriverVT100::Clear(const TRect& aRect)

 //

 // Clear a rectangle of the screen

 //

 	{

 	TInt j;

 	TBuf8<0x100> buf;

 	for (j=aRect.iTl.iY; j<=aRect.iBr.iY; j++)

 		{

 		TUint8 *ptr=iScreenBuffer+(aRect.iTl.iX+j*KScreenWidth);

 		Mem::FillZ(ptr, aRect.iBr.iX-aRect.iTl.iX);

 		}

 	if ((aRect.iTl.iY == aRect.iBr.iY) && (aRect.iTl.iX==0) && (aRect.iBr.iX==KScreenWidth-1))

 		{

 		// Optimisation: one whole line

 		buf.Format(_L8("\x1b[%02d;%02dH"), aRect.iTl.iY, 1);

 		Print(buf);

 		// Erase line

 		buf.Format(_L8("\x1b[2K"));

 		Print(buf);

 		Print(_L8("\x1b[01;01H"));

 		}

 	else if ((aRect.iTl.iY == 0) && (aRect.iBr.iY == KScreenHeight-1) &&

 						(aRect.iTl.iX == 0) && (aRect.iBr.iX == KScreenWidth-1))

 		{

 		// Optimisation: whole screen

 		buf.Format(_L8("\x1b[2J"));

 		Print(buf);

 		Print(_L8("\x1b[01;01H"));

 		}

 	else

 		Update(aRect);

 	}

 void CScreenDriverVT100::SetPixel(const TPoint& /*aPoint*/,TUint8 /*aColour*/)

 	{

 	}

 TInt CScreenDriverVT100::GetPixel(const TPoint& /*aPoint*/)

 	{

 	return 0;

 	}

 void CScreenDriverVT100::SetWord(const TPoint& /*aPoint*/,TInt /*aWord*/)

 	{

 	}

 TInt CScreenDriverVT100::GetWord(const TPoint& /*aPoint*/)

 	{

 	return 0;

 	}

 void CScreenDriverVT100::SetLine(const TPoint& /*aPoint*/,const TPixelLine& /*aPixelLine*/)

 	{

 	}

 void CScreenDriverVT100::GetLine(const TPoint& /*aPoint*/,TPixelLine& /*aPixelLine*/)

 	{

 	}

 void CScreenDriverVT100::Print(const TDesC8& aDes)

 	{

 #ifdef __USE_RDEBUG_OUTPUT

 	TBuf<256> unicodeBuf;

 	unicodeBuf.Copy(aDes);

 	RDebug::RawPrint(unicodeBuf);

 #else

 	RBusDevComm c=iSerialKeyboard->iDevComm;

 	TRequestStatus s;

 	c.Write(s,aDes);

 	User::WaitForRequest(s);

 #endif

 	}