// Copyright (c) 1995-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\ewsrv\ws_win.cpp

// 

//

#include "ws_std.h"

#include <e32hal.h>

#include <hal.h>

#include <domainmanager.h>

#ifdef __VC32__

    #pragma setlocale("english")

#endif

//#define __CHARACTERPOINTER

GLREF_D CKeyTranslator *KeyTranslator;

GLREF_D CKeyRepeat *KeyRepeat;

const TInt KTabSize=4;

#if defined(_UNICODE)	// K.K

#define FONTWIDTH 8

TBool CWsWindow::IsHankaku(const TText aCode)

	{

	if (aCode >= 0xff61 && aCode <= 0xff9f) 

		return ETrue;   // HANKAKU KATAKANA code

	if (aCode >= 0x2550 && aCode <= 0x259f)

		return ETrue;	// HANKAKU Graphics code

	if (aCode < 0x100)

        return ETrue;	// Alphanumeric codes means HANKAKU

	return EFalse;

	}

TInt CWsWindow::FitInWidth(TText* aDest,TInt aWidth,TInt aAsciiCol,TText aCode)

	{

	TInt pixel=aAsciiCol*FONTWIDTH;

	TInt aJpnCol=0;

	TInt jw=0;

	TInt width;

	while (pixel>0)

		{

		TInt width=IsHankaku(aDest[aJpnCol++]) ? FONTWIDTH : FONTWIDTH*2;

		pixel-=width;

		jw+=width;

		}

	width=IsHankaku(aCode) ? FONTWIDTH : FONTWIDTH*2;

	TInt w=jw+width-aWidth*FONTWIDTH;

	while (w > 0)

		w-=IsHankaku(aDest[aJpnCol-- - 1]) ? FONTWIDTH : FONTWIDTH*2;

	aDest[aJpnCol]=aCode;

	return aJpnCol;

	}

TInt CWsWindow::OffsetHZa(const TText* aDest,const TPoint& aPosition,const TSize& aSize,TInt& aX)

	{

	TInt i=aPosition.iY*aSize.iWidth;

	TInt j=0;

	TInt x=aPosition.iX*FONTWIDTH;

	while (x>0)

		x-=IsHankaku(aDest[i+j++]) ? FONTWIDTH : FONTWIDTH * 2;

	if (x<0) --j;

	aX=j;

	return(i+j);

	}

TInt CWsWindow::OffsetHZwP(const TText* aDest,const TPoint& aPosition,const TSize& aSize,TPoint& aP)

	{

	aP=aPosition;

	TInt x;

	TInt offset=OffsetHZa(aDest,aPosition,aSize,x);

	aP.iX=x;

	return offset;

	}

TInt CWsWindow::OffsetHZ(const TText* aDest,const TPoint& aPosition,const TSize& aSize)

	{

	TInt x;

	return OffsetHZa(aDest, aPosition, aSize, x);

	}

TText CWsWindow::GetCharFromOffset(const TText* aDest,const TPoint& aPosition,const TSize& aSize)

	{

	return aDest[OffsetHZ(aDest, aPosition, aSize)];

	}

TText* CWsWindow::GetCpFromOffset(const TText* aDest,const TPoint& aPosition,const TSize& aSize)

	{

	return (TText * )(& aDest[OffsetHZ(aDest, aPosition, aSize)]);

	}

#endif

typedef CScreenDriver* (*TScreenDriverCreate)();

void CWsWindow::New()

//

// Acquire resources needed to run window system

//

	{

	// Load EDISP.DLL from Z:\SYSTEM\LIBS and invoke ordinal 1 to

	// create the screen driver. This is because EDISP.DLL is hardware dependent.

	RLibrary edisp;

	ScreenDriver=NULL;

	TInt r=edisp.Load(_L("EDISP.DLL"), KNullDesC);

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

		Fault(EWindowsInitialisation);

	TScreenDriverCreate f=(TScreenDriverCreate)edisp.Lookup(1);

	if (f)

		ScreenDriver=(*f)();

	__ASSERT_ALWAYS(ScreenDriver!=NULL,Fault(EWindowsInitialisation));

	ScreenDriver->Init(ScreenSize,FontSize);

	ScreenDriver->SetMode(EMono);

	// Set up data

	ScreenColor=IndexOf[ETextAttributeNormal+1];

	BorderColor=IndexOf[ETextAttributeNormal];

	WindowBgColor=IndexOf[ETextAttributeNormal+1];

	ScreenDriver->GetAttributeColors(IndexOf);

	CursorPeriodic=CPeriodic::New(ECursorPeriodicPriority);

	__ASSERT_ALWAYS(CursorPeriodic!=NULL,Fault(EWindowsInitialisation));

	CursorPeriodic->Start(500000,500000,TCallBack(CWsWindow::FlashCursor,NULL));

	Numbers=CBitMapAllocator::New(EMaxOpenWindows);

	__ASSERT_ALWAYS(Numbers!=NULL,Fault(EWindowsInitialisation));

	Numbers->AllocAt(EBackgroundNumber);

	VisibilityMap=(TInt8 *)User::Alloc(ScreenSize.iWidth*ScreenSize.iHeight);

	__ASSERT_ALWAYS(VisibilityMap!=NULL,Fault(EWindowsInitialisation));

	Mem::Fill(VisibilityMap,ScreenSize.iWidth*ScreenSize.iHeight,0);

	BlankLineText=(TText *)User::Alloc(sizeof(TText)*ScreenSize.iWidth);

	__ASSERT_ALWAYS(BlankLineText!=NULL,Fault(EWindowsInitialisation));

	BlankLineAttributes=(ColorInformation *)User::Alloc(ScreenSize.iWidth*sizeof(ColorInformation));

	__ASSERT_ALWAYS(BlankLineAttributes!=NULL,Fault(EWindowsInitialisation));

	TextFill(BlankLineText,ScreenSize.iWidth,_S(" "));

	Mem::Fill(BlankLineAttributes,ScreenSize.iWidth*sizeof(ColorInformation),ScreenColor);

	TInt err=MouseMutex.CreateLocal();

	__ASSERT_ALWAYS(err==KErrNone,Fault(EWindowsInitialisation));

	err=ServiceMutex.CreateLocal();

	__ASSERT_ALWAYS(err==KErrNone,Fault(EWindowsInitialisation));

	SetMode(EMono);

	}

void CWsWindow::Delete()

//

// Release resources needed to run window system

//

	{

	delete ScreenDriver;

	delete CursorPeriodic;

	delete Numbers;

	User::Free(VisibilityMap);

	User::Free(BlankLineText);

	User::Free(BlankLineAttributes);

	MouseMutex.Close();

	ServiceMutex.Close();

	}

void CWsWindow::TextFill(TText *aBuffer,TInt aLength,const TText *aValue)

//

// This helper function provided because no UNICODE compatible fill function exists in User::

//

	{

	TPtr(aBuffer,aLength).Fill(*aValue,aLength);

	}

TInt CWsWindow::Offset(const TPoint &aPosition,const TSize &aSize)

//

// Finds the offset of aPosition within an area of aSize dimensions

//

	{

	return(aPosition.iY*aSize.iWidth+aPosition.iX);

	}

TInt8 CWsWindow::NewNumberL()

//

// Issue a unique window id

//

	{

	TInt8 n=(TInt8)Numbers->Alloc();

	if (n<0)

		User::Leave(ETooManyWindowsOpen);

	return(n);

	}

void CWsWindow::ReleaseNumber(TInt8 aNumber)

//

// Return unique window id back to the pool for future issuing

//

	{

	Numbers->Free((TUint)aNumber);

	}

TInt CWsWindow::FlashCursor(TAny* /*aParameter*/)

//

// Flash the cursor if it is on

//

	{

	CWsWindow *pT=TopWindow();

	if (pT)

		{

		BeginUpdateScreen();

		if (pT->iCursorIsOn)

			{

			TPoint p=pT->iCursorPos-pT->iCurrentOffset;

			if (pT->IsInClippedTextArea(p) && p+pT->iViewOrigin!=MousePos)

				{

//#if defined(_UNICODE)	// K.K

//				TPoint sp;	// K.K

//				TInt offset=pT->OffsetHZwP(pT->iTextBuffer, pT->iCursorPos, pT->iCurrentSize, sp);	//K.K

//				const TText c = pT->iTextBuffer[offset];	// K.K

//				sp= sp - pT->iCurrentOffset;	// K.K

//				ScreenDriver->Blit(&c, 1, sp+pT->iViewOrigin);	// K.K

//#else	// K.K

				TInt i=Offset(pT->iCursorPos,pT->iCurrentSize);

				const TText c=pT->iTextBuffer[i];

				ScreenDriver->SetForegroundColor(pT->iAttributeBuffer[i].iFg);

				ScreenDriver->SetBackgroundColor(pT->iAttributeBuffer[i].iBg);

				ScreenDriver->Blit(&c,1,p+pT->iViewOrigin);

//#endif	// K.K

				}

			pT->iCursorIsOn=EFalse;

			}

		else

			{

			if (pT->iCursorRequired && pT->iReadIsValid)

				{

				TPoint p=pT->iCursorPos-pT->iCurrentOffset;

				if (pT->IsInClippedTextArea(p))

		    		{

					if (p+pT->iViewOrigin!=MousePos)

						{

						ScreenDriver->Blit(&(pT->iCursor),1,p+pT->iViewOrigin);

//#if defined(_UNICODE)	// K.K

//						TPoint sp;	// K.K

//						pT->OffsetHZwP(pT->iTextBuffer, pT->iCursorPos, pT->iCurrentSize, sp);	//K.K

//						sp= sp - pT->iCurrentOffset;	// K.K

//						ScreenDriver->Blit(&(pT->iCursor),1,sp+pT->iViewOrigin);	// K.K

//#else	// K.K

						ScreenDriver->SetForegroundColor(pT->iFgColor);

						ScreenDriver->SetBackgroundColor(WindowBgColor);

						ScreenDriver->Blit(&(pT->iCursor),1,p+pT->iViewOrigin);

//#endif	// K.K

						}

					pT->iCursorIsOn=ETrue;

					}

				}

			}

		EndUpdateScreen();

		}

	return(KErrNone);

	}

void CWsWindow::SetCursor()

//

// Place the text cursor for this window (if required)

//

    {

	BeginUpdateScreen();

	if (iCursorIsOn)

		{

		if (iCursorPos!=iLastCursorPos || !IsTop() || !iCursorRequired)

			{

			TPoint p=iLastCursorPos-iCurrentOffset;

			if (IsInClippedTextArea(p))

	    	    {

				TPoint q=p+iViewOrigin;

				if (q!=MousePos)

					{

					if(VisibilityMap[Offset(q,ScreenSize)]==iNumber)

						{

//#if defined(_UNICODE)	// K.K

//						TPoint sp;	// K.K

//						TInt offset = OffsetHZwP(iTextBuffer, iLastCursorPos, iCurrentSize, sp);	//K.K

//						sp= sp - iCurrentOffset;	// K.K

//						const TText c = iTextBuffer[offset];	// K.K

//						sp = sp + iViewOrigin;	// K.K

//						ScreenDriver->Blit(&c,1,sp);	// K.K

//#else	// K.K

						TInt i=Offset(iLastCursorPos,iCurrentSize);

						const TText c=iTextBuffer[i];

						ScreenDriver->SetForegroundColor(iAttributeBuffer[i].iFg);

						ScreenDriver->SetBackgroundColor(iAttributeBuffer[i].iBg);

						ScreenDriver->Blit(&c,1,q);

//#endif	// K.K

						}

					}

				iCursorIsOn=EFalse;

			    }

			}

		}

    if (IsTop() && iCursorRequired && iReadIsValid)

		{

		TPoint p=iCursorPos-iCurrentOffset;

		if (IsInClippedTextArea(p))

    	    {

			TPoint q=p+iViewOrigin;

			if (q!=MousePos)

				{

//#if defined(_UNICODE)	// K.K

//				TPoint sp;	// K.K

//				OffsetHZwP(iTextBuffer, iLastCursorPos, iCurrentSize, sp);	//K.K

//				sp= sp - iCurrentOffset;	// K.K

//				sp = sp + iViewOrigin;	// K.K

//				ScreenDriver->Blit(&iCursor,1,sp);	// K.K

//#else	// K.K

				ScreenDriver->SetForegroundColor(iFgColor);

				ScreenDriver->SetBackgroundColor(WindowBgColor);

				ScreenDriver->Blit(&iCursor,1,q);

//#endif	// K.K

				}

			iLastCursorPos=iCursorPos;

			iCursorIsOn=ETrue;

		    }

		}

	EndUpdateScreen();

	}

void CWsWindow::SetClip()

//

//	Set the clipped width and depth.

//

    {

	iClippedSize=ScreenSize-iViewOrigin;

	if (iClippedSize.iWidth>iViewSize.iWidth)

		iClippedSize.iWidth=iViewSize.iWidth;

	if (iClippedSize.iHeight>iViewSize.iHeight)

		iClippedSize.iHeight=iViewSize.iHeight;

    }

void CWsWindow::ResetVisibilityMap()

//

//	Recreate visibility map from window queue

//

	{

	TDblQueIter<CWsWindow> q(WQueue);

	CWsWindow *pW;

	Mem::Fill(VisibilityMap,ScreenSize.iWidth*ScreenSize.iHeight,0);

	q.SetToLast();

	while((pW=q--)!=NULL)

		{

		if (pW->iIsVisible)

			{

			TInt8 *pV=&VisibilityMap[Offset(pW->iViewOrigin,ScreenSize)];

			for(TInt i=0; i<pW->iClippedSize.iHeight; i++)

				{

				Mem::Fill(pV,pW->iClippedSize.iWidth,pW->iNumber);

				pV+=ScreenSize.iWidth;

				}

			}

		}

	}

void CWsWindow::BeginUpdateScreen()

//

// Prepare for a whole bunch of UpdateScreen() calls

//

	{

    MouseMutex.Wait();

	}

void CWsWindow::EndUpdateScreen()

//

// End of bunch of UpdateScreen() calls

//

	{

    MouseMutex.Signal();

	}

void CWsWindow::UpdateScreen(TPoint &aPosition,TInt aLength,TInt8 aNumber,TText *aTextBuffer,ColorInformation * anAttributeBuffer)

//

// This function purposefully made static,so that it can be used to update the background (aNumber=0) as well as

// window data. Line by line, it finds contiguous sections of visible window (using aNumber in the visibility map)

// and passes them to CScreenDriver::Blit().

//

	{

	TPoint q=aPosition;

	TInt8 *pV=&VisibilityMap[Offset(q,ScreenSize)];

	TInt w=aLength;

	while(w>0)

		{

		if (*pV==aNumber)

			{

			TPoint p=q;

			TInt l=0;

			TColorIndex fg=anAttributeBuffer[aLength-w].iFg;

			TColorIndex bg=anAttributeBuffer[aLength-w].iBg;

			while(w>=0)

				{

				if (*pV==aNumber && w!=0 && anAttributeBuffer[aLength-w].iFg==fg && anAttributeBuffer[aLength-w].iBg==bg)

					{

					l++;

					w--;

					q.iX++;

					pV++;

					}

				else

					{

					TText *pT=&aTextBuffer[p.iX-aPosition.iX];

					ScreenDriver->SetForegroundColor(fg);

					ScreenDriver->SetBackgroundColor(bg);

					ScreenDriver->Blit(pT,l,p);

					if (p.iY==MousePos.iY)

						{

						if (MousePos.iX>=p.iX && MousePos.iX<p.iX+l)

							TurnMouseOn();

						}

					break;

					}

				}

			}

		else

			{

			w--;

			q.iX++;

			pV++;

			}

		}

	}

TInt CWsWindow::SetMode(TVideoMode aMode)

	{

	TInt r=CWsWindow::ScreenDriver->SetMode(aMode);		

	if(r!=KErrNone)

		return(r);

	CWsWindow::ScreenDriver->GetAttributeColors(IndexOf);

	CWsWindow::ScreenColor=IndexOf[ETextAttributeNormal+1];

	CWsWindow::BorderColor=IndexOf[ETextAttributeNormal];

	CWsWindow::WindowBgColor=IndexOf[ETextAttributeNormal+1];

	CWsWindow::ChangeUIColors();

	CWsWindow* w;

	TDblQueIter<CWsWindow>q(WQueue);

	while((w=q++)!=NULL)

		{

		w->iFgColor=IndexOf[ETextAttributeNormal];

		w->iBgColor=IndexOf[ETextAttributeNormal+1];

		}

	Redraw();

	return KErrNone;

	}

void CWsWindow::Display()

//

//	Display a windows contents on the screen.

//

    {

    if (iIsVisible)

		{

		TPoint p=iViewOrigin;

		TSize s=iClippedSize;

		BeginUpdateScreen();

		TText *pT=&iTextBuffer[Offset(iCurrentOffset,iCurrentSize)];

		ColorInformation *pA=&iAttributeBuffer[Offset(iCurrentOffset,iCurrentSize)];

		while(s.iHeight>0)

			{

			UpdateScreen(p,s.iWidth,iNumber,pT,pA);

			s.iHeight--;

			p.iY++;

			pT=&pT[iCurrentSize.iWidth];

			pA=&pA[iCurrentSize.iWidth];

			}

		EndUpdateScreen();

		SetCursor();

		}

	}

void CWsWindow::Background()

//

//	Update wallpaper to physical screen

//

    {

	TPoint p(0,0);

	BeginUpdateScreen();

    while(p.iY<ScreenSize.iHeight)

    	{

    	UpdateScreen(p,ScreenSize.iWidth,0,BlankLineText,BlankLineAttributes);

		p.iY++;

		}

	EndUpdateScreen();

    }

void CWsWindow::Redraw()

//

// Redraw the whole screen including all the windows and the background

//

	{

	CWsWindow *pW=TopWindow();

	if (pW)

		pW->Refresh();

	else

		{

	    ResetVisibilityMap();

	    Background();

		}

	}

void CWsWindow::Refresh()

//

//	Refresh this window and those below it

//

	{

	CWsWindow* w;