// guicons.cpp

// 

// Copyright (c) 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 <fshell/common.mmh>

#include "guicons.h"

#include <ImageConversion.h>

#include <e32Math.h>

#include "defaultfontdata.inl"

const TInt KAttributeMapGranularity = 3;

const ConsoleAttributes::TColor KDefaultForegroundColor = ConsoleAttributes::EBlack;

const ConsoleAttributes::TColor KDefaultBackgroundColor = ConsoleAttributes::EWhite;

ConsoleAttributes::TAttributes DefaultAttributes()

	{

	return ConsoleAttributes::TAttributes(ConsoleAttributes::ENone, KDefaultForegroundColor, KDefaultBackgroundColor);

	}

TRgb MapColor(TUint aAttributes, ConsoleAttributes::TColor aColor)

	{

	TRgb rgb;

	switch (aColor)

		{

		case ConsoleAttributes::EBlack:

			if (aAttributes & ConsoleAttributes::EBold)

				{

				rgb = KRgbGray;

				}

			else

				{

				rgb = KRgbBlack;

				}

			break;

		case ConsoleAttributes::ERed:

			if (aAttributes & ConsoleAttributes::EBold)

				{

				rgb = KRgbRed;

				}

			else

				{

				rgb = KRgbDarkRed;

				}

			break;

		case ConsoleAttributes::EGreen:

			if (aAttributes & ConsoleAttributes::EBold)

				{

				rgb = KRgbGreen;

				}

			else

				{

				rgb = KRgbDarkGreen;

				}

			break;

		case ConsoleAttributes::EYellow:

			if (aAttributes & ConsoleAttributes::EBold)

				{

				rgb = KRgbYellow;

				}

			else

				{

				rgb = KRgbDarkYellow;

				}

			break;

		case ConsoleAttributes::EBlue:

			if (aAttributes & ConsoleAttributes::EBold)

				{

				rgb = KRgbBlue;

				}

			else

				{

				rgb = KRgbDarkBlue;

				}

			break;

		case ConsoleAttributes::EMagenta:

			if (aAttributes & ConsoleAttributes::EBold)

				{

				rgb = KRgbMagenta;

				}

			else

				{

				rgb = KRgbDarkMagenta;

				}

			break;

		case ConsoleAttributes::ECyan:

			if (aAttributes & ConsoleAttributes::EBold)

				{

				rgb = KRgbCyan;

				}

			else

				{

				rgb = KRgbDarkCyan;

				}

			break;

		case ConsoleAttributes::EWhite:

			if (aAttributes & ConsoleAttributes::EBold)

				{

				rgb = KRgbWhite;

				}

			else

				{

				rgb = KRgbWhite;//KRgbGray;

				}

			break;

		case ConsoleAttributes::EReset:

		case ConsoleAttributes::EUnchanged:

		default:

			ASSERT(EFalse);

		}

	if (aAttributes & ConsoleAttributes::EInverse)

		{

		rgb = ~rgb;

		}

	return rgb;

	}

void SignalSemaphore(TAny* aSemaphore)

	{

	((RSemaphore*)aSemaphore)->Signal();

	}

void CleanupSignalSemaphorePushL(RSemaphore& aSemaphore)

	{

	CleanupStack::PushL(TCleanupItem(SignalSemaphore, &aSemaphore));

	}

void WaitForRequest(TAny* aStatus)

	{

	User::WaitForRequest(*(TRequestStatus*)aStatus);

	}

void CleanupWaitForRequestPushL(TRequestStatus& aStatus)

	{

	CleanupStack::PushL(TCleanupItem(WaitForRequest, &aStatus));

	}

//______________________________________________________________________________

//						CConsoleControl

EXPORT_C CConsoleControl* CConsoleControl::NewL(TInt aBufferSize, MConsoleUi* aUi)

	{

	CConsoleControl* self = new(ELeave)CConsoleControl(aUi, aBufferSize);

	CleanupStack::PushL(self);

	self->ConstructL(CConsoleFont::NewL(KDefaultFontImageData));

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CConsoleControl* CConsoleControl::NewL(TInt aBufferSize, const TDesC& aFontFile, MConsoleUi* aUi)

	{

	CConsoleControl* self = new(ELeave)CConsoleControl(aUi, aBufferSize);

	CleanupStack::PushL(self);

	self->ConstructL(CConsoleFont::NewL(aFontFile));

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CConsoleControl::~CConsoleControl()

	{

	delete iBlinkTimer;

	delete iFont;

	iCursor.Hide();

	iBuffer.ResetAndDestroy();

	iKeyQueue.Close();

	}

EXPORT_C void CConsoleControl::Closed()

	{

	if (iUi)

		{

		iUi->HandleConsoleClosed(this);

		}

	}

EXPORT_C void CConsoleControl::Draw(const TRect& aRect) const

	{

	CWindowGc& gc = SystemGc();

	gc.SetBrushStyle(CGraphicsContext::ENullBrush);

	gc.SetPenStyle(CGraphicsContext::ENullPen);

	// Need to do a clear here, to ensure we actually draw to all the pixels in aRect that we've been asked to draw. If we don't do that, wserv generally gets upset.

//	gc.SetBrushColor(KDefaultBackgroundColor);

//	gc.Clear(aRect);

	for (TInt y=0; y<iSizeChars.iHeight; ++y)

		{

		TViewPosition line(*this, 0, y);

		if (aRect.Intersects(LineRect(line)))

			{

			DrawLine(line, gc);

			}

		}

	if (iDrawNavigator)

		{

		// And draw the 5-way UI

#ifdef FSHELL_WSERV2_SUPPORT

		// XOR draw mode doesn't seem to be supported in recent wserv, so use a colour with alpha channel instead

		const TRgb col(15, 15, 15, 128);

		gc.SetDrawMode(CGraphicsContext::EDrawModePEN);

#else

		const TRgb col(15,15,15);

		gc.SetDrawMode(CGraphicsContext::EDrawModeXOR);

#endif

		gc.SetBrushColor(col);

		gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

		gc.SetPenColor(col);

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

			{

			if (aRect.Intersects(iButtonRects[i]))

				{

				if (i == ECenter)

					{

					gc.DrawEllipse(iButtonRects[i]);

					}

				else

					{

					gc.DrawRect(iButtonRects[i]);

					}

				}

			}

		}

	}

EXPORT_C TCoeInputCapabilities CConsoleControl::InputCapabilities() const

	{

	return TCoeInputCapabilities(

				TCoeInputCapabilities::ENonPredictive 

			|	TCoeInputCapabilities::EAllText

			|	TCoeInputCapabilities::ENavigation

			);

	}

EXPORT_C void CConsoleControl::FocusChanged(TDrawNow)

	{

	iCursor.Update();

	if (IsFocused())

		{

		StartBlinking();

		}

	else

		{

		iBlinkTimer->Cancel();

		}

	}

EXPORT_C void CConsoleControl::HandlePointerEventL(const TPointerEvent& aPointerEvent)

	{

	if (aPointerEvent.iType == TPointerEvent::EButton1Down)

		{

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

			{

			if (iButtonRects[i].Contains(aPointerEvent.iPosition))

				{

				SimulateKeyL((TButton)i);

				iIgnoringDrags = ETrue;

				return;

				}

			}

		iIgnoringDrags = EFalse;

		}

	if (iIgnoringDrags) return;

	if (aPointerEvent.iType == TPointerEvent::EButton1Down)

		{

		iDragStart = aPointerEvent.iPosition;

		}

	if (aPointerEvent.iType == TPointerEvent::EDrag)

		{

		TPoint delta = iDragStart - aPointerEvent.iPosition;

		TInt lines = delta.iY / iFont->GlyphSize().iHeight;

		if (lines)

			{

			iViewWindow.iY += lines;

			ViewMoved();

			iDragStart.iY -= (lines * iFont->GlyphSize().iHeight);

			}

		}

	}

EXPORT_C TKeyResponse CConsoleControl::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

	{

	if ((!IsFocused()) || IsNonFocusing()) return EKeyWasNotConsumed;

	if (aType == EEventKey)

		{

		iKeyQueue.AppendL(aKeyEvent);

		SendKey();

#ifdef LOCAL_ECHO

		TUint code = aKeyEvent.iCode;

		if (code == '\r') code = '\n';

		TBuf<0x20> ip;

		ip.AppendFormat(_L("key %d"), code);

		User::InfoPrint(ip);

		TBuf<1> buf;

		buf.Append(TChar(code));

		Write(buf);

#endif

		return EKeyWasConsumed;

		}

	return EKeyWasNotConsumed;	

	}

EXPORT_C void CConsoleControl::InjectKeysL(const TDesC& aKeys)

	{

	for (TInt i=0; i<aKeys.Length(); ++i)

		{

		TKeyEvent key;

		key.iCode = aKeys[i];

		key.iModifiers = 0;

		iKeyQueue.AppendL(key);		

		}

	SendKey();

	}

void CConsoleControl::DrawLine(TViewPosition aLine, CBitmapContext& aDrawTo) const

	{

	CConsoleLine* line = GetLine(aLine);

	if (line)

		{

		line->Draw(aDrawTo, aLine);

		}

	}

TRect CConsoleControl::LineRect(TViewPosition aLine) const

	{

	return TRect(TScreenPosition(aLine).iPoint, TSize(iFont->GlyphSize().iWidth * iSizeChars.iWidth, iFont->GlyphSize().iHeight));

	}

EXPORT_C void CConsoleControl::SizeChanged()

	{

	TSize sizePixels = Size();

	TSize newSizeChars(sizePixels.iWidth / iFont->GlyphSize().iWidth, sizePixels.iHeight / iFont->GlyphSize().iHeight);

	if (newSizeChars != iSizeChars)

		{

		iSizeChars = newSizeChars;

		TRAP_IGNORE(SizeChangedL());

		}

	}

CConsoleControl::CConsoleControl(MConsoleUi* aUi, TInt aBufferSize)

	: iUi(aUi), iCursor(*this), iCurrentAttributes(ConsoleAttributes::ENone, KDefaultForegroundColor, KDefaultBackgroundColor), iBufferSize(aBufferSize)

	{

	}

void CConsoleControl::ConstructL(CConsoleFont* aFont)

	{

	iBlinkTimer = CPeriodic::NewL(CActive::EPriorityStandard);

	iFont = aFont;

	iCursor.SetFont(*iFont);

	SetCursorHeight(KDefaultCursorHeightPercentage);

	}

void CConsoleControl::SizeChangedL()

	{

	TInt bufferSize = Max(iBufferSize, iSizeChars.iHeight);

	for (TInt i=0; i<Min(iBuffer.Count(), bufferSize); ++i)

		{

		iBuffer[i]->SetWidthL(iSizeChars.iWidth);

		}

	while (iBuffer.Count() < bufferSize)

		{

		CConsoleLine* line = CConsoleLine::NewL(*this, *iFont, iSizeChars.iWidth);

		CleanupStack::PushL(line);

		iBuffer.AppendL(line);

		CleanupStack::Pop();

		}

	while (iBuffer.Count() > bufferSize)

		{

		delete iBuffer[iBuffer.Count()-1];

		iBuffer.Remove(iBuffer.Count()-1);

		}

	iCursor.Update();

	if (FivewayNavIsDisplaying()) SetDisplayFivewayNav(ETrue); // re-layout the onscreen nav if applicable

	}

CConsoleLine* CConsoleControl::GetLine(TBufferPosition aLine) const

	{

	return iBuffer[aLine.iPoint.iY];

	}

TPoint CConsoleControl::ViewPosition() const

	{

	return iViewWindow;

	}

TPoint CConsoleControl::CursorWindowPosition() const

	{

	return iCursorWindow;

	}

TSize CConsoleControl::GlyphSize() const

	{

	return iFont->GlyphSize();

	}

TBool CConsoleControl::IsSpecialChar(TChar aChar) const

	{

	switch(aChar)

		{

		case 0x00:	// Null.

		case 0x07:	// Bell.

		case 0x08:	// Backspace.

		case 0x7f:	// Delete.

		case 0x09:	// Tab.

		case 0x0a:	// Line feed.

		case 0x0b:	// Vertical tab.

		case 0x0c:	// Form feed.

		case 0x0d:	// Carriage return.

			return ETrue;

		default:

			return EFalse;

		}

	}

void CConsoleControl::HandleSpecialChar(TChar aChar)

	{

	switch(aChar)

		{

		case 0x00:	// Null.

			break;

		case 0x07:	// Bell.

			break;

		case 0x08:	// Backspace.

		case 0x7f:	// Delete.

			iCursor--;

			break;

		case 0x09:	// horizontal tab

			iCursor += KTabSize - (iCursor.Position().iPoint.iX % KTabSize);

			break;

		case 0x0a:	// line feed

			iCursor -= iCursor.Position().iPoint.iX;

			iCursor.Down();

			break;

		case 0x0b:	// Vertical tab.

			break;

		case 0x0c:  // Form feed

			ClearScreen();

			break;

		case 0x0d:	// carriage return

			iCursor -= iCursor.Position().iPoint.iX;

			break;

		default:

			User::Invariant();

		}

	}

void CConsoleControl::SendKey()

	{

	if (iReader && iKeyQueue.Count())

		{

		iCurrentKey = iKeyQueue[0];

		iKeyQueue.Remove(0);

		iReader->ReadComplete(KErrNone);

		iReader = NULL;

		}

	}

EXPORT_C void CConsoleControl::Read(MGuiConsoleReader& aReader)

	{

	if (iReader)

		{

		aReader.ReadComplete(KErrInUse);

		}

	else

		{

		iReader = &aReader;

		SendKey();

		}

	}

EXPORT_C void CConsoleControl::ReadCancel()

	{

	iReader = NULL;

	}

EXPORT_C void CConsoleControl::Write(const TDesC &aDes)

	{

	TRAP_IGNORE(WriteL(aDes));

	}

void CConsoleControl::WriteL(const TDesC &aDes)

	{

	TRect invalidRect;

	for (TInt i=0; i<aDes.Length(); ++i)

		{

		if (IsSpecialChar(aDes[i]))

			{

			if (!invalidRect.IsEmpty())

				{

				// Draw to the invalid rectangle before handling this special character because it may cause the

				// window to scroll, thereby invalidating the coordinates of invalidRect.

				DrawNow(invalidRect);

				invalidRect = TRect();

				}

			HandleSpecialChar(aDes[i]);

			}

		else

			{

			CConsoleLine* line = GetLine(iCursor.Position());

			line->SetL(iCursor.Position().iPoint.iX, aDes[i], iCurrentAttributes);

			TRect lineRect(LineRect(iCursor.Position()));

			Window().Invalidate(lineRect);

			if (invalidRect.IsEmpty())

				{

				invalidRect = lineRect;

				}

			else

				{

				invalidRect.BoundingRect(lineRect);