/*

* 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 <e32base.h>

#include <gdi.h>

#include <coecntrl.h>

#include <coemain.h>

#include <eikconso.h>	// #include's eiksbfrm.h

#include <eikenv.h>

#include <barsread.h>

#include <aknpriv.rsg>

void cutmax(TInt &x,TInt max);

///////////////////////////////////////////////////////////////////////////////////////////////////////

// UpdateScrollBarsL()

// ===================

// Updates the thumb positions etc. on the scrollbars.

// Should be called whenever the datasize, visiblesize or position on the scrollbars have changed.

// RETURNS ETrue IF ANY SCROLLBARS (DIS)APPEARED

///////////////////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TBool CEikConsoleControl::UpdateScrollbarsL(const TSize &aDataSize,const TSize& aVisibleSize,TPoint aPos)

	{

	// complete available area in characters

	TSize viewInChars( iSize.iWidth / iCharSize.iWidth, iSize.iHeight / iCharSize.iHeight );

	// remember for next time

	iLastThumbPos = aPos;

	TEikScrollBarModel vModel;

	TEikScrollBarModel hModel;

	if (iVBarVisibility!=CEikScrollBarFrame::EOff) 

		{

		// Vertical

		vModel.iScrollSpan=aDataSize.iHeight;

		if ( viewInChars.iHeight > aVisibleSize.iHeight )

			vModel.iThumbSpan=aVisibleSize.iHeight;

		else

			vModel.iThumbSpan=viewInChars.iHeight;

		vModel.iThumbPosition=aPos.iY;

		}

	if (iHBarVisibility!=CEikScrollBarFrame::EOff) 

		{

		// Horizontal

		hModel.iScrollSpan=aDataSize.iWidth;

		if ( viewInChars.iWidth > aVisibleSize.iWidth )

			hModel.iThumbSpan=aVisibleSize.iWidth;

		else

			hModel.iThumbSpan=viewInChars.iWidth;

		hModel.iThumbPosition=aPos.iX;

		}

	TRect fullRect(iSize);

	TRect clientRect(iViewInPixels);

	TEikScrollBarFrameLayout layout;

	CreateScrollBarFrameLayout(layout);

	if (iSBFrame->TileL(&hModel,&vModel,clientRect,fullRect,layout))

		{

		// something happened, so redetermine the available pixels...

		iViewInPixels=clientRect.Size();

		// the visible characters...

//	zoe

		iViewInChars = TSize( iViewInPixels.iWidth / iCharSize.iWidth, iViewInPixels.iHeight / iCharSize.iHeight );

		if (iConsole)

			{

			cutmax(iViewInChars.iWidth,iConsole->ScreenSize().iWidth);

			cutmax(iViewInChars.iHeight,iConsole->ScreenSize().iHeight);

			}

		// and clear what's outside the new scope...

		TPoint br(iViewInChars.iWidth*iCharSize.iWidth, iViewInChars.iHeight*iCharSize.iHeight);

		const TRgb background=iEikonEnv->ControlColor(EColorControlBackground,*this);

		ClearPixels(TRect(br.iX,0,iViewInPixels.iWidth,br.iY),background);

		ClearPixels(TRect(0,br.iY,iViewInPixels.iWidth,iViewInPixels.iHeight),background);

		// and inform caller that the area has changed...

		return ETrue;

		}

	return EFalse;

	}

void CEikConsoleControl::CreateScrollBarFrameLayout(TEikScrollBarFrameLayout& aLayout) const

	{

	// all margins default to 0

	aLayout.iTilingMode=TEikScrollBarFrameLayout::EInclusiveRectConstant;

	aLayout.iClientAreaGranularity=iCharSize;

	}

EXPORT_C void CEikConsoleControl::UpdateArea()

	{

	// determine how many characters will fit and how many pixels we thus ACTUALLY need

//zoe

	iViewInChars = TSize( iViewInPixels.iWidth / iCharSize.iWidth, iViewInPixels.iHeight / iCharSize.iHeight );

	if (iConsole)

		{

		cutmax(iViewInChars.iWidth,iConsole->ScreenSize().iWidth);

		cutmax(iViewInChars.iHeight,iConsole->ScreenSize().iHeight);

		}

	// clear the area and redraw

	const TRgb background=iEikonEnv->ControlColor(EColorControlBackground,*this);

	ClearPixels(iViewInPixels,background);

	if (iConsole)

		iConsole->Redraw(PixelsToChars(TRect(iViewInPixels)));

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////

// HandleScrollEventL()

// ====================

// Called when someone "touches the scrollbar".

// Note that it calls back the owner (a CEikConsoleScreen) to do any real action

// (specifically, it calls MoveTopLeft(), passing it the required move as a vector)

///////////////////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C void CEikConsoleControl::HandleScrollEventL(CEikScrollBar* aScrollBar,TEikScrollEvent aEventType)

	{

	TInt newThumbPos = aScrollBar->ThumbPosition();

	TInt pageSize = aScrollBar->Model()->iThumbSpan;

	const TInt horizontalNudgeFactor = 1;

	switch (aEventType & KEikScrollEventBarMask)

		{

		case KEikScrollEventFromHBar:

			switch (aEventType)

				{

				default:

					break;

				case EEikScrollLeft:

					newThumbPos -= horizontalNudgeFactor;

					break;

				case EEikScrollRight:

					newThumbPos += horizontalNudgeFactor;

					break;

				case EEikScrollPageLeft:

					newThumbPos -= pageSize;

					break;

				case EEikScrollPageRight:

					newThumbPos += pageSize;

					break;

				case EEikScrollThumbDragVert:

				case EEikScrollThumbReleaseVert:

					// in the case of drag events, the scrollbar automatically updates its thumb pos...

					break;

				}

			iConsole->MoveTopLeft(TPoint(newThumbPos - iLastThumbPos.iX,0));

			if (aEventType != EEikScrollThumbDragHoriz)

				aScrollBar->SetModelThumbPosition(newThumbPos);

			break;

		case KEikScrollEventFromVBar:

			switch (aEventType)

				{

				default:

					break;

				case EEikScrollUp:

					--newThumbPos;

					break;

				case EEikScrollDown:

					++newThumbPos;

					break;

				case EEikScrollPageUp:

					newThumbPos -= ((pageSize < 2)? 1 : pageSize - 1);

					break;

				case EEikScrollPageDown:

					newThumbPos += ((pageSize < 2)? 1 : pageSize - 1);

					break;

				case EEikScrollThumbDragVert:

				case EEikScrollThumbReleaseVert:

					// in the case of drag events, the scrollbar automatically updates its thumb pos...

					break;

				}

			iConsole->MoveTopLeft(TPoint(0,newThumbPos - iLastThumbPos.iY));

			if (aEventType != EEikScrollThumbDragVert)

				aScrollBar->SetModelThumbPosition(newThumbPos);

			break;

		}

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////

// SetScrollBarVisibility

// ======================

// Changes which scroll bars are visible. Returns EFalse if nothing changed.

///////////////////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TInt CEikConsoleControl::SetScrollBarVisibilityL(CEikScrollBarFrame::TScrollBarVisibility aHBarVisibility, CEikScrollBarFrame::TScrollBarVisibility aVBarVisibility)

	{

	if ((aHBarVisibility==iHBarVisibility)&&(aVBarVisibility==iVBarVisibility))

		return EFalse;

	iHBarVisibility=aHBarVisibility;

	iVBarVisibility=aVBarVisibility;

	iSBFrame->SetScrollBarVisibilityL(iHBarVisibility, iVBarVisibility);

	return ETrue;

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////

// SizeChanged

// ==========

///////////////////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C void CEikConsoleControl::SizeChanged()

	{

	iViewInPixels=Size(); // new area

	if (iConsole && iSBFrame)

		{

		iConsole->UpdateScrollBars();

		UpdateArea();

		}

	}

EXPORT_C void CEikConsoleControl::FocusChanged(TDrawNow aDrawNow)

	{

	if (aDrawNow==ENoDrawNow)

		return;

	if (IsFocused())

		iConsole->DrawCursor();

	else

		iConsole->HideCursor();

	}

EXPORT_C TInt CEikConsoleControl::CountComponentControls() const

	{

	return (iSBFrame) ? iSBFrame->CountComponentControls() : NULL;

	}

EXPORT_C CCoeControl* CEikConsoleControl::ComponentControl(TInt aIndex) const

	{

	return iSBFrame->ComponentControl(aIndex);

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////

// VisibleSize()

// =============

// Simply returns the visible size in characters

///////////////////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TSize CEikConsoleControl::VisibleSize() const

	{

	return iViewInChars;

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////

// ConstructL

// ==========

// Construct and activate a CEikConsoleControl (claiming the specified part of the physical screen)

///////////////////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C void CEikConsoleControl::ConstructL(TInt aFlags)

	{

	// Init screen. Use RBackedUpWindow instead of RWindow if aFlags & CEikConsoleScreen::EUseBackedUpWindow

	if (aFlags&CEikConsoleScreen::EUseBackedUpWindow)

		CreateBackedUpWindowL((RWindowTreeNode&)iCoeEnv->RootWin(), EGray4);

	else

		{

		CreateWindowL();

		Window().SetBackgroundColor(iEikonEnv->ControlColor(EColorControlBackground,*this));

		}

	SetExtentToWholeScreen();

	// Create scrollbars

	iSBFrame=new(ELeave) CEikScrollBarFrame(this, this);

	iSBFrame->SetScrollBarVisibilityL(iHBarVisibility,iVBarVisibility);

	InitFontSpecL();

	SetFontL(iFontSpec,NULL);

	// activate

	ActivateL();

	}

EXPORT_C void CEikConsoleControl::ConstructL(TPoint aTopLeft,const TSize &aSize,TInt aFlags,TEikConsWinUnits aUnit)

	{

	// Init screen. Use RBackedUpWindow instead of RWindow if aFlags & CEikConsoleScreen::EUseBackedUpWindow

	if (aFlags&CEikConsoleScreen::EUseBackedUpWindow)

		CreateBackedUpWindowL((RWindowTreeNode&)iCoeEnv->RootWin(), EGray4);

	else

		{

		CreateWindowL();

		Window().SetBackgroundColor(iEikonEnv->ControlColor(EColorControlBackground,*this));

		}

	// Create scrollbars

	iSBFrame=new(ELeave) CEikScrollBarFrame(this, this);

	iSBFrame->SetScrollBarVisibilityL(iHBarVisibility,iVBarVisibility);

	InitFontSpecL();

	if (aUnit==EEikConsWinInChars)

		{

		CFont *font;

		iEikonEnv->ScreenDevice()->GetNearestFontInTwips(font,iFontSpec);

		CFbsFont* fbsFont = (CFbsFont*)font;

		iCurrentFont=fbsFont;

		iCharSize.iWidth=fbsFont->MaxNormalCharWidthInPixels();

		iCharSize.iWidth=fbsFont->CharWidthInPixels('i');

		iCharSize.iWidth=fbsFont->CharWidthInPixels('M');

		iCharSize.iHeight=fbsFont->HeightInPixels();

		SetExtent(TPoint(aTopLeft.iX*iCharSize.iWidth,aTopLeft.iY*iCharSize.iHeight),

			TSize(aSize.iWidth*iCharSize.iWidth,aSize.iHeight*iCharSize.iHeight));

		SetFontL(iFontSpec,fbsFont);

		}

	else

		{

		SetExtent(aTopLeft,aSize);

		SetFontL(iFontSpec,NULL);

		}

	// activate

	ActivateL();

	}

void CEikConsoleControl::InitFontSpecL()

    {

    HBufC16* typeface = iCoeEnv->AllocReadResourceAsDes16LC(R_AKNPRIV_DEFAULT_CONSOLE_FONTSPEC_TYPEFACE);

    iFontSpec.iTypeface.iName= *typeface;

    CleanupStack::PopAndDestroy(typeface);

    TResourceReader reader;

    iCoeEnv->CreateResourceReaderLC(reader,R_AKNPRIV_DEFAULT_CONSOLE_FONTSPEC_HEIGHT);

    iFontSpec.iHeight=reader.ReadInt16();

    CleanupStack::PopAndDestroy(); // reader

#if defined(_UNICODE)

    iFontSpec.iTypeface.SetIsProportional(EFalse);

#endif

    iFontUnderline=EUnderlineOff;

    iFontSpec.iFontStyle.SetPosture(EPostureUpright);

    iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////////

// SetRedrawer

// ===========

// Define aConsoleScreen as the object responsible for redrawing

///////////////////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C void CEikConsoleControl::SetRedrawer(CEikConsoleScreen *aConsoleScreen)

	{

	iConsole=aConsoleScreen;

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////

// Constructor and Destructor

///////////////////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C CEikConsoleControl::CEikConsoleControl()

	{

	// *** init color

	iBackGray16=iEikonEnv->Color(EColorControlBackground);

	iPenGray16=iEikonEnv->Color(EColorControlText);

	// *** init scrollbar settings and font (however, 0-values are free in construction)

	// iHBarPresent=FALSE;

	// iVBarPresent=FALSE;

	// iLastThumbPos = TPoint(0,0);

	// iCurrentFont=NULL;

	// *** init cursor

	iCursorHeightPercentage=20;

	iTextCursor.iType	= TTextCursor::ETypeRectangle;

	iTextCursor.iFlags	= 0;

	iTextCursor.iColor=iEikonEnv->Color(EColorControlBackground);

	iLastAtt=iLastFontFlags=(ATT_MAXVALUE+1);

	}

EXPORT_C CEikConsoleControl::~CEikConsoleControl()

	{

	iEikonEnv->ReleaseScreenFont(CONST_CAST(CFont*,iCurrentFont));

	delete(iSBFrame);

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////

// NextFontL

// =========

// Utility function: unload current font (if any) and load new font (specified elsewhere in iFontSpec)

///////////////////////////////////////////////////////////////////////////////////////////////////////

void CEikConsoleControl::NextFontL()

	{

	CFont* font;

	User::LeaveIfError(iEikonEnv->ScreenDevice()->GetNearestFontInTwips(font, iFontSpec));

	CFbsFont* fbsFont = (CFbsFont*)font;

	iEikonEnv->ReleaseScreenFont(CONST_CAST(CFont*,iCurrentFont)); // note that this only happens if the previous line succeeds!

	iCurrentFont=fbsFont;

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////

// SetFontL

// ========

// Change the font

///////////////////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C void CEikConsoleControl::SetFontL(const TFontSpec& aFontSpec,const CFbsFont *aFont)

	{

	iFontSpec=aFontSpec;

	iFontHeight=(TUint16)iFontSpec.iHeight;

	if (aFont==NULL)

		NextFontL();

	iCharSize = TSize( iCurrentFont->CharWidthInPixels('M'),iCurrentFont->FontMaxHeight() );

	SetCursorHeight(iCursorHeightPercentage);

	// Determine font flags for new font

	iFontIsProportional=iCurrentFont->FontSpecInTwips().iTypeface.IsProportional();

	iLastFontFlags = 0;

	if (iFontUnderline!=EUnderlineOff)

		iLastFontFlags|=ATT_UNDERLINE;

	if (iFontSpec.iFontStyle.Posture()!=EPostureUpright)

		iLastFontFlags|=ATT_ITALIC;

	if (iFontSpec.iFontStyle.StrokeWeight()!=EStrokeWeightNormal)

		iLastFontFlags|=ATT_BOLD;

	UpdateArea();

	}

////////////////////////////////////////////////////////////////////////////////////////

//

//  Utility functions: convert between character coordinates to pixel coordinates

//

////////////////////////////////////////////////////////////////////////////////////////

TPoint CEikConsoleControl::CharsToPixels(TPoint aPos)

	{

	return TPoint( iCharSize.iWidth * aPos.iX, iCharSize.iHeight * aPos.iY );

	}

TRect CEikConsoleControl::CharsToPixels(const TRect &aRect)

	{

	return TRect(CharsToPixels(aRect.iTl),CharsToPixels(aRect.iBr));

	}

TRect CEikConsoleControl::PixelsToChars(const TRect &aRect) 

	{

	TRect r = aRect;

	r.Normalize();

	r.iTl.iX /= iCharSize.iWidth;

	r.iBr.iX /= iCharSize.iWidth;

	r.iBr.iX ++;

	r.iTl.iY /= iCharSize.iHeight;

	r.iBr.iY /= iCharSize.iHeight;

	r.iBr.iY ++;

	return r;

	}

////////////////////////////////////////////////////////////////////////////////////////

//

//  Cursor stuff

//

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C void CEikConsoleControl::DrawCursor(TPoint aPosition)

// Show cursor at character position

	{

	//iEikonEnv->RootWin().SetTextCursor(*DrawableWindow(),CharsToPixels(aPosition),iTextCursor);

	iEikonEnv->DrawCursor(this, CharsToPixels(aPosition), iTextCursor.iWidth, iTextCursor.iAscent, iTextCursor.iHeight);

	}

EXPORT_C void CEikConsoleControl::HideCursor()

// Hide cursor 

	{

	//iEikonEnv->RootWin().CancelTextCursor();

	iEikonEnv->HideCursor(this);

	}

EXPORT_C void CEikConsoleControl::SetCursorHeight(TUint aPercentage)

// Set new cursor height (specified as percentage of font height)

// Should also be called whenever iCharSize changes!

// Change will not take effect until the next call to DrawCursor!

	{

	iCursorHeightPercentage = aPercentage % 101;

	iTextCursor.iHeight = ( 99 + (iCharSize.iHeight * iCursorHeightPercentage) ) / 100;

	iTextCursor.iAscent = iTextCursor.iHeight-iCharSize.iHeight;

	iTextCursor.iWidth  = iCharSize.iWidth;

	}

////////////////////////////////////////////////////////////////////////////////////////

//

//  Draw - defers the real work to the owner (a CEikConsoleScreen)

//

////////////////////////////////////////////////////////////////////////////////////////

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

	{

	if (iConsole) // if there's no owner, we do nothing

		{

		M().iRedrawing=1;

		TPoint br(iViewInChars.iWidth*iCharSize.iWidth,iViewInChars.iHeight*iCharSize.iHeight);

		const TRgb background=iEikonEnv->ControlColor(EColorControlBackground,*this);

		ClearPixels(TRect(br.iX,0,iViewInPixels.iWidth,br.iY),background);

		ClearPixels(TRect(0,br.iY,iViewInPixels.iWidth,iViewInPixels.iHeight),background);

		iConsole->Redraw(M().PixelsToChars(aRect)); // Redraw all chars in the rectangle

		M().iRedrawing=0;

		}

	}

////////////////////////////////////////////////////////////////////////////////////////

//

//  Set up GC based for given attribute

//

////////////////////////////////////////////////////////////////////////////////////////

void CEikConsoleControl::InterpretColorBits(TUint aCharacterAttributes)

// Set iPenGrey16 and iBackGrey16 based on character attribute aCharacterAttributes

	{

	if (aCharacterAttributes & ATT_COLORMASK) // is color

		{

		const TInt pen16=(aCharacterAttributes&0x0F);

		iPenGray16=TRgb::Color16(pen16);

		TInt back16=((aCharacterAttributes&0x70)>>4)*2+1;

		if (back16==1)

			back16=0;

		iBackGray16=TRgb::Color16(back16);

		}

	else if ( aCharacterAttributes & ATT_INVERSE )

		{

		iBackGray16=iEikonEnv->ControlColor(EColorControlHighlightBackground,*this);

		iPenGray16=iEikonEnv->ControlColor(EColorControlHighlightText,*this);

		}

	else

		{

		iBackGray16=iEikonEnv->ControlColor(EColorControlBackground,*this);

		iPenGray16=iEikonEnv->ControlColor(EColorControlText,*this);