// Copyright (c) 2006-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 "screen.h"

#include <hal.h>

#include "server.h"

#include "wstop.h"

#include "rootwin.h"

#include "walkwindowtree.h"

#include "offscreenbitmap.h"

#include "EVENT.H"

#include "windowgroup.h"

#include "gc.h"

#include "inifile.h"

#include "pointer.h"

#include "debugbar.h"

#include "ScreenRedraw.h"

#include "wspluginmanager.h"

GLREF_D CDebugLogBase *wsDebugLog;

GLREF_D TDisplayMode ParseDisplayMode(const TDesC& aModeName);

LOCAL_D TBool FindNextValue(TLex& aLex, TInt& aValue) // assumes the list cannot contain *negative* integers

	{

	while (!aLex.Eos())

		{

		const TUint character=aLex.Peek();

		if (Rng(TUint('0'), character, TUint('9')) || (character=='-'))

			{

			break;

			}

		aLex.Inc();

		}

	return (aLex.Val(aValue)==KErrNone);

	}

CScreen::CFallbackMap * CScreen::CFallbackMap::NewL(CScreen* aScreen)

	{

	CFallbackMap * self = new (ELeave) CFallbackMap(aScreen);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CScreen::CFallbackMap::CFallbackMap(CScreen* aScreen) :

	iScreen(aScreen),

	iRegion(TRect(TPoint(0,0), TSize(1,1))),

	iCount(0)

	{

	}

CScreen::CFallbackMap::~CFallbackMap()

	{

	delete iMap;

	}

void CScreen::CFallbackMap::ConstructL()

	{

	iMapSize = 0;

	for (TInt num = 0; num < iScreen->NumScreenSizeModes(); ++num)

		{

		if (iScreen->IsValidScreenSizeMode(num))

			{

			const TSizeMode & mode = iScreen->ScreenSizeModeData(num);

			TInt width = mode.iScreenSize.iWidth / 32;

			if (mode.iScreenSize.iWidth & (32 - 1))

				++width;

			TInt size = width * mode.iScreenSize.iHeight;

			if (size > iMapSize)

				iMapSize = size;

			}

		}

	iMap = new (ELeave) TInt [iMapSize];

	}

void CScreen::CFallbackMap::Prepare()

	{

	const TSizeMode & mode = iScreen->ScreenSizeModeData();

	Mem::FillZ(iMap, iMapSize * sizeof(TInt));

	iCount = mode.iScreenSize.iHeight * mode.iScreenSize.iWidth;

	WS_ASSERT_DEBUG(iRegion.Count() == 1, EWsPanicScreenFallback);

	iRegion.Clear();

	iRegion.AddRect(TRect(mode.iOrigin, mode.iScreenSize));

	}

TBool CScreen::CFallbackMap::FillRegion(const TRegion& aRegion)

	{

	WS_ASSERT_DEBUG(!aRegion.CheckError(), EWsPanicScreenFallback);

	if (aRegion.Count() > 20 || aRegion.CheckError())

		return ETrue;

	TBool hit = EFalse;

	if (iCount > 0)

		{

		const TRect * rect = aRegion.RectangleList();

		for (TInt num = 0; num < aRegion.Count(); ++num)

			{

			hit = FillRect(*rect) || hit;

			if (iCount < 1)

				break;

			++rect;

			}

		}

	return hit;

	}

// x >> 5 is equivalent to x / 32

// 0x1F is the rounding error when dividing by 32

// 0x20 is 32.

// The compiler might do all the optimizations for us - not checked.

TBool CScreen::CFallbackMap::FillRect(const TRect& aRect)

	{

	TBool hit = EFalse;

	const TSizeMode & mode = iScreen->ScreenSizeModeData();

	TRect scrrect(mode.iOrigin, mode.iScreenSize);

	TRect rect = aRect;

	rect.Intersection(scrrect);

	TInt rowWidthInInts = mode.iScreenSize.iWidth;

	if (rowWidthInInts & 0x1F)

		rowWidthInInts += 0x20;

	rowWidthInInts >>= 5;

	TInt colStartInInts = rect.iTl.iX >> 5;

	TInt firstOffsetInBits = rect.iTl.iX & 0x1F;

	for(TInt row = rect.iTl.iY; row < rect.iBr.iY; ++row)

		{

		TInt * map = iMap + row * rowWidthInInts + colStartInInts;

		TInt offsetShift = 31 - firstOffsetInBits;

		for (TInt col = rect.iTl.iX; col < rect.iBr.iX; ++col)

			{

			WS_ASSERT_DEBUG(map - iMap < iMapSize, EWsPanicScreenFallback);

			if (!(*map & 1 << offsetShift))

				{

				--iCount;

				hit = ETrue;

				if (iCount < 1)

					break;

				(*map) |= (1 << offsetShift);

				}

			--offsetShift;

			if (offsetShift < 0)

				{

				offsetShift = 31;

				++map;

				}

			}

		}

	return hit;

	}

TInt CScreen::CFallbackMap::Count() const

	{

	return iCount;

	}

const TRect * CScreen::CFallbackMap::Rect() const

	{

	return iRegion.RectangleList();

	}

const RRegion * CScreen::CFallbackMap::Region() const

	{

	return &iRegion;

	}

//

// CScreen

//

CScreen::CScreen(): iDirects(_FOFF(CWsDirectScreenAccess,iLink)), iMaxContrast(-1), iMaxBrightness(-1)

	{

	}

CScreen::~CScreen()

	{

	delete iDebugBar;

	delete iOffScreenBitmap;

	delete iScreenGdi;

	TInt ii;

	if(iModes)

		{

		for(ii=iNumScreenSizeModes-1;ii>=0;--ii)

			{

			delete (*iModes)[ii];

			}

		iModes->Close();

		delete iModes;

		}

	delete iRootWindow;

	delete iScreenDevice;

	delete iFallbackMap;

	delete iSpriteManager;

	delete iRedraw;

	}

void CScreen::ConstructL(const TRect& aDigitiserArea, TInt aScreenNumber )

	{

	iScreenNumber = aScreenNumber ;

	if (wsDebugLog)

		{

		_LIT(KWSERVInitScreen,"Initialising for Screen %d");

		wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant, KWSERVInitScreen, aScreenNumber);

		}

	CreateScreenDeviceL();

	iScreenDevice->SetAutoUpdate(EFalse);

	iPhysicalScreenSize=iScreenDevice->SizeInPixels();

	LoadScreenSizesL(iPhysicalScreenSize);

	// mode 0 might not be available, get the first/lowest valid mode

	SetInitialScreenSizeMode();

	iFallbackMap = CFallbackMap::NewL(this);

//

	iScreenGdi=CFbsBitGc::NewL();

	iScreenGdi->Activate(iScreenDevice);

	LoadScreenSizeProperties();

	SetDigitiserAreas(iScreenDevice->SizeInPixels(),aDigitiserArea);

//

	iScreenGdi->SetOrientation(Orientation());

	const TSizeMode& sizeMode=ScreenSizeModeData(ScreenSizeMode());

	iScreenDevice->SetScalingFactor(sizeMode.iOrigin,sizeMode.iScreenScale.iWidth,sizeMode.iScreenScale.iHeight,1,1);

	iScreenDevice->ChangeScreenDevice(NULL);    //This is necessary to initialise the screen

//

	// Off Screen Bitmaps

	iOffScreenBitmap=CWsOffScreenBitmap::NewL(this);

	TSize osbSize(iOffScreenBitmap->Bitmap()->SizeInPixels());

	TSize osbTwips(sizeMode.iScreenTwipsSize);

	if (osbSize!=sizeMode.iScreenSize)

		{

		// The specified screen twips size is for the specified screen pixel size, however the OSB

		// is potentially larger as it needs to hold the maximum possible screen size, so we need

		// to scale the twips size up correspondingly.

		osbTwips.iWidth=sizeMode.iScreenTwipsSize.iWidth*osbSize.iWidth/sizeMode.iScreenSize.iWidth;

		osbTwips.iHeight=sizeMode.iScreenTwipsSize.iHeight*osbSize.iHeight/sizeMode.iScreenSize.iHeight;

		}

	iOffScreenBitmap->Bitmap()->SetSizeInTwips(osbTwips);		

	TInt autoClear = 1;

	_LIT(KWSERVIniFileVarAutoClear,"AUTOCLEAR");

	WsIniFile->FindVar(iScreenNumber,KWSERVIniFileVarAutoClear,autoClear);

	if (autoClear != 0)

		{

		iFlags|=EAutoClear;

		}

	_LIT(KBackLight,"BACKLIGHTCONTROL");

	iBackLightFlag=WsIniFile->FindVar( iScreenNumber, KBackLight);

	_LIT(KWSERVIniFileVarBlankScreen, "BLANKSCREENONROTATION");

	if (WsIniFile->FindVar(iScreenNumber, KWSERVIniFileVarBlankScreen))

		{

		iFlags|=EBlankScreenOnRotation;

		}

	SetShadowVector(TPoint(EDefaultShadowX,EDefaultShadowY));

	iRedraw = CScreenRedraw::NewL(*this);

	iRootWindow = new (ELeave) CWsRootWindow(NULL, this);

	iRootWindow->ConstructL();

	TInt refreshRate = 1000000;

	_LIT(KDebugBar, "DEBUGBAR");

	if (WsIniFile->FindVar(refreshRate, KDebugBar))

		{

		if (refreshRate < 100000)

			refreshRate = 50000;

		const TPoint origin = CurrentScreenModeOrigin();

		iDebugBar = CDebugBar::NewL(this, TRect(origin.iX,origin.iY,origin.iX+CurrentScreenSize().iWidth,origin.iY+16), refreshRate);

		}

	// Default fading parameters

	iBlackMap=128;

	iWhiteMap=255;

	iSpriteManager = CWsSpriteManager::NewL();

	//Look for fading plugins here.

	_LIT(KDefaultFaderPluginName, "wsfader");

  	_LIT(KFaderPluginIni,"FADER");

	CWsPluginManager* mgr = CWsTop::WindowServer()->PluginManager();

	if (mgr)

		{

	  	TPtrC faderName;

  		if (WsIniFile->FindVar(iScreenNumber, KFaderPluginIni, faderName))

      		iFader = mgr->FindNamedImplementation<MWsFader>(faderName);

    	else	

		  	iFader = mgr->FindNamedImplementation<MWsFader>(KDefaultFaderPluginName);

		}

	_LIT(KBltOffScreenBitmap,"BLTOFFSCREENBITMAP");

	if (WsIniFile->FindVar(iScreenNumber, KBltOffScreenBitmap))

		{

		iFlags|=EBltOffScreenBitmap;

		}	

	}

void CScreen::CreateScreenDeviceL()

	{

	_LIT(KScreenMode,"SCREENMODE");

	_LIT(KWindowMode,"WINDOWMODE");

	TPtrC screenModeName;

	TDisplayMode screenMode = ENone;

	if (WsIniFile->FindVar(iScreenNumber, KScreenMode, screenModeName))

		{

		screenMode = ParseDisplayMode(screenModeName);

		}

	else if (WsIniFile->FindVar(iScreenNumber, KWindowMode, screenModeName))

		{

		screenMode = ParseDisplayMode(screenModeName);

		}

	if (screenMode != ENone)

		{

		if(DoCreateScreenDevice(screenMode))

			return;

		}

	// No screen mode was specified, or we failed creating the specified screen

	// mode. Default to as high display mode as possible.

	// Check if the screen device supports 16M colors (it can only support one of

	// 16M, 16MU, 16MA, 16MAP, or none of them)

	screenMode = CFbsDevice::DisplayMode16M();

	if(screenMode != ENone)

		{

		if(DoCreateScreenDevice(screenMode))

			return;

		}

	// Try creating the screen device with all available display modes, going from best to worst

	__ASSERT_COMPILE(EColorLast == 14); // if any display mode is added to TDisplayMode we must update the list below

	// (the list below contains all enums in TDisplayMode except ENone, ERgb, EColorLast)

	if(DoCreateScreenDevice(EColor16MAP))

		return;

	if(DoCreateScreenDevice(EColor16MA))

		return;

	if(DoCreateScreenDevice(EColor16MU))

		return;

	if(DoCreateScreenDevice(EColor16M))

		return;

	if(DoCreateScreenDevice(EColor64K))

		return;

	if(DoCreateScreenDevice(EColor4K))

		return;

	if(DoCreateScreenDevice(EColor256))

		return;

	if(DoCreateScreenDevice(EColor16))

		return;

	if(DoCreateScreenDevice(EGray256))

		return;

	if(DoCreateScreenDevice(EGray16))

		return;

	if(DoCreateScreenDevice(EGray4))

		return;

	if(DoCreateScreenDevice(EGray2))

		return;

	User::Leave(KErrNotSupported);

	}

TBool CScreen::DoCreateScreenDevice(TDisplayMode aScreenMode)

	{

	TRAPD(err, iScreenDevice = CFbsScreenDevice::NewL(iScreenNumber, aScreenMode));

	return (err == KErrNone);

	}

void CScreen::AbortDSAs(RDirectScreenAccess::TTerminationReasons aReason,TSglQue<CWsDirectScreenAccess>& aDirects)

	{

	if (aDirects.IsEmpty())

		return;

	TInt nofDSAs = 0;

	TSglQueIter<CWsDirectScreenAccess> iter(aDirects);

	CWsDirectScreenAccess* direct;

	while (( direct=iter++)!=NULL )

		{

		nofDSAs++;

		direct->SignalAbort( aReason );

		}

	TRequestStatus timerStatus;

	RTimer& timer=CWsTop::Timer();

	timer.Cancel();

	TRequestStatus** cancelReqList = (TRequestStatus**) User::AllocZ( sizeof( TRequestStatus* ) * (nofDSAs + 1)  );  

	if ( NULL != cancelReqList  )

		{		

			TInt dsaNo = 1; 

			timer.After( timerStatus, KDSAAbortingImmediateRespAwaitFrameMicrosec );		

			iter.SetToFirst();

			while (( direct=iter++)!=NULL )

				{

					cancelReqList[ dsaNo ] =  &direct->AbortStatus();

					dsaNo++;

				}

			cancelReqList[ 0 ] = &timerStatus;

			User::WaitForNRequest( cancelReqList, nofDSAs + 1 );

			iter.SetToFirst();

			while (( direct=iter++)!=NULL )

				{

				if ( direct->AbortStatus() != KRequestPending )

					direct->CancelAbortObject(); // responded

				else

					direct->Abort();

				}

			if (timerStatus == KRequestPending)

				{

				timer.Cancel();

				User::WaitForRequest( timerStatus );

				}

			User::Free( cancelReqList );

		}

	else

		{

		iter.SetToFirst();

		while ((direct=iter++) != NULL)

			{

			TRequestStatus timerStatus;

			RTimer& timer=CWsTop::Timer();

			timer.Cancel();

			timer.After(timerStatus, KDSAAbortingImmediateRespAwaitFrameMicrosec);

			//wait for response or timeout

			User::WaitForRequest(direct->AbortStatus(), timerStatus);

			if (direct->AbortStatus() != KRequestPending)

				direct->CancelAbortObject(); //responded

			else

				direct->Abort(); //timed out

			if (timerStatus == KRequestPending)

				{

				timer.Cancel();

				User::WaitForRequest(timerStatus);

				}

			}

		}

	}

void CScreen::AbortAllDirectDrawing(RDirectScreenAccess::TTerminationReasons aReason)

	{

	AbortDSAs(aReason,iDirects);

	}

void CScreen::AddDirect(CWsDirectScreenAccess& aDirect)

	{

	TBool emptyBefore = iDirects.IsEmpty();

	iDirects.AddLast(aDirect);

	TBool emptyAfter = iDirects.IsEmpty();

	if (emptyBefore && ! emptyAfter)

		{

		TWsEvent wsevent;

		wsevent.SetType(EEventDirectScreenAccessBegin);

		*(wsevent.Int()) = iScreenNumber;

		TWindowServerEvent::PublishNotification(wsevent);

		}

	if (iDsaDrawState==EDsaDrawStateIdle && aDirect.IsVisible())

		{

		iDsaDrawState = EDsaDrawStateDrawing;

		TWindowServerEvent::NotifyDrawer(TWservCrEvent(TWservCrEvent::EDsaDrawingBegin, iScreenNumber));

		}

	}

void CScreen::RemoveDirect(CWsDirectScreenAccess& aDirect)

	{

	TBool emptyBefore = iDirects.IsEmpty();

	iDirects.Remove(aDirect);

	TBool emptyAfter = iDirects.IsEmpty();

	if (emptyAfter && ! emptyBefore)

		{

		TWsEvent wsevent;

		wsevent.SetType(EEventDirectScreenAccessEnd);

		*(wsevent.Int()) = iScreenNumber;

		TWindowServerEvent::PublishNotification(wsevent);

		}

	if (iDsaDrawState==EDsaDrawStateDrawing && aDirect.IsVisible() && !HasVisibleDirectOnQueue())

		{

		iDsaDrawState = EDsaDrawStateIdle;

		TWindowServerEvent::NotifyDrawer(TWservCrEvent(TWservCrEvent::EDsaDrawingEnd, iScreenNumber));

		}

	}

TBool CScreen::HasVisibleDirectOnQueue()

	{

	if (iDirects.IsEmpty())

		return EFalse;

	TSglQueIter<CWsDirectScreenAccess> iter(iDirects);

	CWsDirectScreenAccess* dsa;

	while ((dsa=iter++)!=NULL)

		{

		if (dsa->IsVisible())

			return ETrue;

		}

	return EFalse;

	}

#if defined(_DEBUG)

TBool CScreen::IsDirectOnQueue(const CWsDirectScreenAccess* aDirect)

	{

	TSglQueIter<CWsDirectScreenAccess> iter(iDirects);

	CWsDirectScreenAccess* direct;