// Copyright (c) 2008-2009 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 <e32cons.h>

 #include <e32keys.h>

 #include <e32base.h>

 #include <w32std.h>

 #include <gdi.h>

 #include <bitstd.h>

 #include <bitdev.h>

 const TInt KGroupId = 0x100039e7;

 class CWsConsoleMux;

 class CWsConsole;

 // Active object to listen to Wserv events. Only used when

 // application thread has installed an active scheduler

 //

 NONSHARABLE_CLASS(CWsKeyReader): public CActive

 	{

 public:

 	CWsKeyReader(CWsConsoleMux* aMux);

 	void MakeRequest();

 protected:

 	void RunL();

 	void DoCancel();

 private:

 	CWsConsoleMux* iMux; //uses

 	};

 // Master console to dispatch key events to relevant console in situation where 

 // a single application thread owns multiple instances of console (CConsoleBase).

 // Reference counted as only a single instance of this class will be created

 // for each thread.

 //

 NONSHARABLE_CLASS(CWsConsoleMux): public CBase

 	{

 public:

 	static TInt Open();

 	static void Close();

 	static CWsConsoleMux* Static();

 	~CWsConsoleMux();

 	void MakeRequest(CWsConsole* aConsole);

 	void CancelRequest(CWsConsole* aConsole);

 	void RequestComplete();

 	inline RWsSession& Session();

 	inline RWindowGroup& Group();

 	inline CWindowGc& Gc();

 	inline CWsScreenDevice& Screen();

 private:

 	static CWsConsoleMux* NewL();

 	CWsConsoleMux();

 	void ConstructL();

 private:

 	TInt iRefCount;

 	RWsSession iWs;

 	RWindowGroup iGroup;

 	CWsScreenDevice* iScr;

 	CWindowGc* iGc;

 	CWsConsole* iConsole;

 	CWsKeyReader* iReader;

 	};

 // Console that uses direct Wserv API. Each console will own a window and 

 // a bitmap for its backing store, but will be sharing Wserv session, window group,

 // screen device and window drawing context

 //

 NONSHARABLE_CLASS(CWsConsole): public CConsoleBase

 	{

 	friend class CWsConsoleMux;

 public:

 	CWsConsole();

 	virtual ~CWsConsole();

 	//from CConsoleBase 

 	virtual TInt Create(const TDesC &aTitle,TSize aSize);

 	virtual void Read(TRequestStatus &aStatus);

 	virtual void ReadCancel();

 	virtual void Write(const TDesC &aDes);

 	virtual TPoint CursorPos() const;

 	virtual void SetCursorPosAbs(const TPoint &aPoint);

 	virtual void SetCursorPosRel(const TPoint &aPoint);

 	virtual void SetCursorHeight(TInt aPercentage);

 	virtual void SetTitle(const TDesC &aTitle);

 	virtual void ClearScreen();

 	virtual void ClearToEndOfLine();

 	virtual TSize ScreenSize() const;

 	virtual TKeyCode KeyCode() const;

 	virtual TUint KeyModifiers() const;

 private:	

 	// for CWsConsoleMux

 	TRequestStatus* ReadStatus();

 	void SetKey(TUint aCode, TUint aModifier);

 	// internal

 	void ConstructL();

 	void DrawNow();

 	void Scroll();

 	TPoint WritePos();

 	void CarriageReturn();

 	void LineFeed();

 	void Left();

 	void Right();

 	void WriteChar(TText);

 private:

 	// window stuff

 	RWindow iWin;

 	TSize iWindowSize;

 	// back buffer

 	CFbsBitmap* iBitmap;

 	CFbsBitGc* iBitGc;

 	CFbsBitmapDevice* iBitDev;

 	// console stuff in chars dimension

 	TPoint iCursorPos; //The position of the cursor is on the baseline

 	TSize iSizeInChars;

 	// font stuff

 	CFont* iFont;

 	TSize iCharSize;

 	TInt iFontAscent;

 	TInt iFontDescent;

 	TKeyCode iKeyCode;

 	TUint iModifiers;

 	TTextCursor iTextCursor;

 	// master console

 	CWsConsoleMux* iMux;

 	TRequestStatus* iReadStatus;

 	};

 //

 // CWsKeyReader implementation

 //

 //

 //

 CWsKeyReader::CWsKeyReader(CWsConsoleMux* aMux):

 	CActive(CActive::EPriorityStandard),

 	iMux(aMux)	

 	{

 	CActiveScheduler::Add(this);

 	}

 void CWsKeyReader::MakeRequest()

 	{

 	SetActive();

 	iMux->Session().EventReady(&iStatus);

 	}

 void CWsKeyReader::RunL()

 	{

 	// let master console decide what to do

 	iMux->RequestComplete();

 	}

 void CWsKeyReader::DoCancel()

 	{

 	iMux->Session().EventReadyCancel();

 	}

 //

 // CWsConsoleMux implementation

 //

 //

 //

 TInt CWsConsoleMux::Open()

 	{

 	CWsConsoleMux* mux = (CWsConsoleMux*)Dll::Tls();

 	// not the first time, simply increment refcount

 	if (mux)

 		{

 		++mux->iRefCount;

 		return KErrNone;

 		}

 	// first time, let's create master console and

 	// stick it to TLS

 	TRAPD(err, mux = CWsConsoleMux::NewL());

 	if (err != KErrNone)

 		{

 		return err;

 		}

 	err = Dll::SetTls(mux);

 	if (err != KErrNone)

 		{

 		delete mux;

 		return err;

 		}

 	++mux->iRefCount;			

 	return KErrNone;

 	}

 void CWsConsoleMux::Close()

 	{

 	CWsConsoleMux* mux = (CWsConsoleMux*)Dll::Tls();

 	if (!mux)

 		{

 		return;

 		}

 	// destroy master console if this is the last use from

 	// this thread and reset TLS

 	if (--mux->iRefCount == 0)

 		{

 		delete mux;

 		Dll::FreeTls();

 		}

 	}

 CWsConsoleMux* CWsConsoleMux::Static()

 	{

 	return (CWsConsoleMux*)Dll::Tls();

 	}

 CWsConsoleMux::CWsConsoleMux()

 	{

 	}

 CWsConsoleMux::~CWsConsoleMux()

 	{

 	delete iReader;

 	delete iGc;

 	delete iScr;

 	iGroup.Close();

 	iWs.Close();

 	}

 CWsConsoleMux* CWsConsoleMux::NewL()

 	{

 	CWsConsoleMux* mux = new(ELeave) CWsConsoleMux;

 	CleanupStack::PushL(mux);

 	mux->ConstructL();

 	CleanupStack::Pop(mux);

 	return mux;

 	}

 void CWsConsoleMux::ConstructL()

 	{

 	TInt err = iWs.Connect();

 	User::LeaveIfError(err);

 	iScr = new(ELeave) CWsScreenDevice(iWs);

 	err = iScr->Construct();

 	User::LeaveIfError(err);

 	iGc = new(ELeave) CWindowGc(iScr);

 	err = iGc->Construct();

 	User::LeaveIfError(err);

 	iGroup = RWindowGroup(iWs);

 	err = iGroup.Construct(KGroupId, ETrue);

 	User::LeaveIfError(err);

 	// we will be using active object to listen to Wserv events

 	// only if this thread already has active scheduler

 	//

 	if (CActiveScheduler::Current())

 		{

 		iReader = new(ELeave) CWsKeyReader(this);

 		}

 	}

 RWsSession& CWsConsoleMux::Session()

  	{

  	return iWs;

  	}

 RWindowGroup& CWsConsoleMux::Group()

 	{

 	return iGroup;

 	}

 CWindowGc& CWsConsoleMux::Gc()

 	{

 	return *iGc;

 	}

 CWsScreenDevice& CWsConsoleMux::Screen()

 	{

 	return *iScr;

 	}

 void CWsConsoleMux::MakeRequest(CWsConsole* aConsole)

 	{

 	if (!iReader)

 		{

 		// client does not have scheduler, ideally we should use

 		// secondary thread to make this asynchronous.

 		//

 		// however, we can get away with this because application 

 		// that doesn't use active scheduler will be calling asynchronous console read 

 		// and immediately followed by WaitForRequest e.g.

 		//

 		// while (1)

 		//	{

 		//	...

 		//	console->Read(status);

 		//	User::WaitForRequest(status);

 		//	...

 		//	}

 		//

 		TWsEvent event;

 		// keep going until we got key event

 		do

 			{

 			TRequestStatus s;

 			s = KRequestPending;

 			iWs.EventReady(&s);

 			User::WaitForRequest(s);

 			iWs.GetEvent(event);

 			}

 		while (event.Type() != EEventKey);

 		aConsole->SetKey(event.Key()->iCode, event.Key()->iModifiers);

 		TRequestStatus* pS = aConsole->ReadStatus();

 		User::RequestComplete(pS, KErrNone);

 		}

 	else

 		{

 		iConsole = aConsole;

 		iReader->MakeRequest();

 		}

 	}

 // called from key listener RunL

 //

 void CWsConsoleMux::RequestComplete()

 	{

 	TWsEvent event;

 	iWs.GetEvent(event);

 	if (event.Type() == EEventKey)

 		{

 		iConsole->SetKey(event.Key()->iCode, event.Key()->iModifiers);

 		TRequestStatus* pS = iConsole->ReadStatus();

 		User::RequestComplete(pS, KErrNone);

 		iConsole = NULL;

 		}

 	else

 		{

 		// keep going until we got key event

 		//

 		iReader->MakeRequest();

 		}

 	}

 void CWsConsoleMux::CancelRequest(CWsConsole* aConsole)

 	{

 	if (iReader && iConsole == aConsole)

 		{

 		iReader->Cancel();

 		}

 	}

 //

 // CWsConsole implementation

 //

 //

 //

 CWsConsole::CWsConsole()

 	{

 	}

 CWsConsole::~CWsConsole()

 	{

 	if(iBitGc)

 		{

 		iBitGc->DiscardFont();

 		}

 	if(iBitDev)

 		{

 		iBitDev->ReleaseFont(iFont);

 		}

 	delete iBitGc;

 	delete iBitDev;

 	delete iBitmap;	

 	iWin.Close();

 	iMux->Session().Flush();

 	CWsConsoleMux::Close();

 	}

 TInt CWsConsole::Create(const TDesC& /*aTitle*/, TSize /*aSize*/)

 	{

 	// we must not push this object to cleanup stack during construction because

 	// caller will explicitly call delete on this object when Create() returns error

 	//

 	TRAPD(err, ConstructL());

 	return err;

 	}

 void CWsConsole::ConstructL()

 	{

 	TInt err = CWsConsoleMux::Open();

 	User::LeaveIfError(err);

 	iMux = CWsConsoleMux::Static();

 	iWindowSize = iMux->Screen().SizeInPixels();

 	iBitmap = new(ELeave) CFbsBitmap;

 	err = iBitmap->Create(iWindowSize, EGray2);

 	User::LeaveIfError(err);

 	iBitDev = CFbsBitmapDevice::NewL(iBitmap);

 	err = iBitDev->CreateContext(iBitGc);

 	User::LeaveIfError(err);

 	iBitGc->SetPenColor(KRgbBlack);

 	iBitGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

 	iBitGc->SetBrushColor(KRgbWhite);

 	iBitGc->Clear();

 	TFontSpec fs(_L("DejaVu Sans Mono"), 12);

 	err = iBitDev->GetNearestFontToDesignHeightInPixels(iFont, fs);

 	User::LeaveIfError(err);

 	iBitGc->UseFont(iFont);

 	// uses monospace font to get uniform glpyh size

 	iCharSize.iHeight = iFont->FontMaxAscent() + iFont->FontMaxDescent();

 	iCharSize.iWidth = iFont->MaxCharWidthInPixels();

 	iFontAscent = iFont->FontMaxAscent();

 	iFontDescent= iFont->FontMaxDescent();

 	// cursor represent char position in character-based area

 	// eshell is using 0,0 based

 	iCursorPos = TPoint(1,1);

 	// console size in number of characters and lines

 	iSizeInChars.iWidth = iWindowSize.iWidth / iCharSize.iWidth;

 	iSizeInChars.iHeight = iWindowSize.iHeight / iCharSize.iHeight;

 	iTextCursor.iType = TTextCursor::ETypeRectangle;

 	iTextCursor.iHeight = iCharSize.iHeight;

 	iTextCursor.iAscent = iFontAscent;

 	iTextCursor.iWidth = iCharSize.iWidth;

 	iTextCursor.iFlags = 0;

 	iTextCursor.iColor = KRgbWhite;

 	iWin = RWindow(iMux->Session());

 	err = iWin.Construct(iMux->Group(), (TInt)this);

 	User::LeaveIfError(err);

 	iWin.Activate();

 	iMux->Session().Flush();

 	}

 TRequestStatus* CWsConsole::ReadStatus()

 	{

 	return iReadStatus;

 	}

 void CWsConsole::SetKey(TUint aCode, TUint aModifier) 

 	{

 	iKeyCode = (TKeyCode)aCode;

 	iModifiers = aModifier;

 	}

 TPoint CWsConsole::WritePos()

 	{

 	return TPoint((iCursorPos.iX - 1) * iCharSize.iWidth, (iCursorPos.iY - 1) * iCharSize.iHeight + iFontAscent);

 	}

 void CWsConsole::Read(TRequestStatus &aStatus)

 	{

 	iReadStatus = &aStatus;

 	*iReadStatus = KRequestPending;

 	iMux->MakeRequest(this);

 	}

 void CWsConsole::ReadCancel()

 	{

 	iMux->CancelRequest(this);

 	iReadStatus = NULL;

 	}

 void CWsConsole::CarriageReturn()

 	{

 	iCursorPos.iX = 1;

 	}

 void CWsConsole::LineFeed()

 	{

 	CarriageReturn();

 	if (iCursorPos.iY < iSizeInChars.iHeight)

 		{

 		++iCursorPos.iY;

 		}

 	else

 		{

 		Scroll();

 		}

 	}

 void CWsConsole::Left()

 	{

 	if (iCursorPos != TPoint(1,1))

 		{

 		if (iCursorPos.iX == 1)

 			{

 			iCursorPos.iX += iSizeInChars.iWidth;

 			--iCursorPos.iY;

 			}

 		--iCursorPos.iX;

 		}

 	}

 void CWsConsole::Right()

 	{

 	++iCursorPos.iX;

 	if (iCursorPos.iX > iSizeInChars.iWidth)

 		{

 		LineFeed();

 		}

 	}

 void CWsConsole::Write(const TDesC& aDes)

 	{

 	const TInt length = aDes.Length();

 	if (length == 0)

 		{

 		return;

 		}

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

 		{

 		switch (aDes[i])

 			{

 			case 0x07:

 				RDebug::Print(_L("WSCON: End of command line!"));

 				break;

 			case 0x0a:

 				LineFeed();

 				break;

 			case 0x0d:

 				CarriageReturn();

 				break;

 			default:

 				WriteChar(aDes[i]);

 				break;

 			}

 		}

 	DrawNow();

 	}

 void CWsConsole::WriteChar(TText aChar)

 	{

 	TBuf<1> s;

 	s.Append(aChar);

 	// use draw text box to clear the glpyh box

 	TPoint writePos = WritePos();

 	TRect r(writePos.iX, writePos.iY-iFontAscent,writePos.iX+iCharSize.iWidth, writePos.iY+iFontDescent);

 	iBitGc->DrawText(s, r, iFontAscent);

 	Right();

 	}

 TPoint CWsConsole::CursorPos() const

 	{

 	// eshell is using 0,0 based

 	return iCursorPos - TPoint(1,1);

 	}

 void CWsConsole::SetCursorPosAbs(const TPoint& aPoint)

 	{

 	// eshell is using 0,0 based

 	iCursorPos = aPoint + TPoint(1,1);

 	iMux->Group().SetTextCursor(iWin, WritePos(), iTextCursor);

 	}

 void CWsConsole::SetCursorPosRel(const TPoint& aPoint)

 	{

 	iCursorPos += aPoint;

 	iMux->Group().SetTextCursor(iWin, WritePos(), iTextCursor);

 	}

 void CWsConsole::SetCursorHeight(TInt aPercentage)

 	{

 	if (aPercentage == 0)

 		{

 		// none

 		iTextCursor.iHeight = 0;

 		}

 	else if (aPercentage == 100)

 		{

 		// insert

 		iTextCursor.iHeight = iCharSize.iHeight;

 		iTextCursor.iAscent = iFontAscent;

 		}

 	else

 		{

 		// normal

 		iTextCursor.iHeight = 1;

 		iTextCursor.iAscent = 0;

 		}

 	iMux->Group().SetTextCursor(iWin, WritePos(), iTextCursor);

 	}

 void CWsConsole::SetTitle(const TDesC& /*aTitle*/)

 	{

 	}

 void CWsConsole::ClearScreen()

 	{

 	iBitGc->Clear();

 	iCursorPos.iX = iCursorPos.iY = 1;

 	DrawNow();

 	}

 void CWsConsole::ClearToEndOfLine()

 	{

 	iMux->Group().CancelTextCursor();

 	TPoint writePos = WritePos();

 	TRect r(writePos.iX, writePos.iY-iFontAscent, iWindowSize.iWidth, writePos.iY+iFontDescent);

 	iBitGc->Clear(r);

 	DrawNow();

 	iMux->Group().SetTextCursor(iWin, WritePos(), iTextCursor);

 	}

 TSize CWsConsole::ScreenSize() const

 	{

 	return iSizeInChars;

 	}

 TKeyCode CWsConsole::KeyCode() const

 	{

 	return iKeyCode;

 	}

 TUint CWsConsole::KeyModifiers() const

 	{

 	return iModifiers;

 	}

 void CWsConsole::DrawNow()

 	{

 	iWin.Invalidate();

 	iWin.BeginRedraw();

 	iMux->Gc().Activate(iWin);

 	iMux->Gc().BitBlt(TPoint(0,0), iBitmap);

 	iMux->Gc().Deactivate();

 	iWin.EndRedraw();

 	iMux->Session().Flush();

 	}

 void CWsConsole::Scroll()

 	{

 	TRect r(0, iCharSize.iHeight, iWindowSize.iWidth, iSizeInChars.iHeight * iCharSize.iHeight);

 	iBitGc->CopyRect(TPoint(0, -iCharSize.iHeight), r);

 	// clear last line

 	TRect rect(0, WritePos().iY-iFontAscent, iWindowSize.iWidth, iWindowSize.iHeight);

 	iBitGc->Clear(rect);

 	}

 extern "C" EXPORT_C TAny *NewConsole()

 	{

 	return new CWsConsole;

 	}