// Copyright (c) 2006-2010 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 <graphics/wsscreendevice.h>

#include <graphics/wsscene.h>

#include <graphics/wselement.h>

#include "server.h"

#include "wstop.h"

#include "rootwin.h"

#include "walkwindowtree.h"

#include "EVENT.H"

#include "windowgroup.h"

#include "inifile.h"

#include "pointer.h"

#include "windowelementset.h"

#include "registeredsurfacemap.h"

#include "debugbar.h"

#include "ScreenRedraw.h"

#include "wspluginmanager.h"

#include "devicemap.h"

#include <graphics/wsdisplaymapping.h>

#if defined(__WINS__) && defined(_DEBUG)

#include "../../debuglog/osbwin.h"

#endif

#include <graphics/wsdisplaycontrol.h>

GLREF_D CDebugLogBase *wsDebugLog;

LOCAL_C inline MWsScene::TSceneRotation GcToScreen(CFbsBitGc::TGraphicsOrientation aGcOrientation)

	{

	MWsScene::TSceneRotation screenRotation = MWsScene::ESceneAntiClockwise0;

	switch (aGcOrientation)

		{

		case CFbsBitGc::EGraphicsOrientationRotated90:

			screenRotation = MWsScene::ESceneAntiClockwise90;

			break;

		case CFbsBitGc::EGraphicsOrientationRotated180:

			screenRotation = MWsScene::ESceneAntiClockwise180;

			break;

		case CFbsBitGc::EGraphicsOrientationRotated270:

			screenRotation = MWsScene::ESceneAntiClockwise270;

			break;

		}

	return screenRotation;

	}

LOCAL_C inline TDeviceOrientation GcToDevice(CFbsBitGc::TGraphicsOrientation aGcOrientation)

	{

	// Each device orientation is defined to be the value where just the bit

	// corresponding to the GDI orientation value is set.

	return (TDeviceOrientation)(1 << aGcOrientation);

	}

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;

	}

TInt CScreen::CFallbackMap::Resize(const TSize& aSize)

	{

	TInt err = KErrNone;

	TInt width = (aSize.iWidth+31) >> 5;	// divide by 32

	TInt invertedWidth = (aSize.iHeight+31) >> 5;	// divide by 32

	TInt maxSize = Max(width * aSize.iHeight,invertedWidth * aSize.iWidth);

	if (maxSize > iMapSize)

		{

		TInt* newMap=NULL;

		newMap = new  TInt [maxSize];

		if (newMap)

			{

			delete []iMap;

			iMap = newMap;

			iMapSize = maxSize;

			}

		else

			{

			err = KErrNoMemory;

			}

		}

	return err;

	}

//

// CScreen

//

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

, iDisplayChangeSpinner(0), iConfigChangeSpinner(0)

	{

	}

CScreen::~CScreen()

	{

	delete iDebugBar;

	TInt ii;

	if(iModes)

		{

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

			{

			delete (*iModes)[ii];

			}

		iModes->Close();

		delete iModes;

		}

	delete iRootWindow;

	iScreenDevice = NULL;

	delete iDsaDevice;

	delete iDeviceMap;

	delete iFallbackMap;

	delete iSpriteManager;

	delete iWindowElementSet;

	if (!iDsaSurface.IsNull())

	    {

	    TInt err = iScene->UnregisterSurface(iDsaSurface);

		WS_ASSERT_DEBUG(KErrNone == err, EWsPanicDirectScreenAccess);

	    }

	delete iSurfaceMap;

	delete iRedraw;

#if defined(__WINS__) && defined(_DEBUG)

	delete iDebugWin;

#endif

	if(iDisplayChangeNotifier)

		delete iDisplayChangeNotifier;

	if(iConfigChangeNotifier)

		delete iConfigChangeNotifier;

	iWsClientList.Close();

	}

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

	{

	iScreenNumber = aScreenNumber ;

	if (wsDebugLog)

		{

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

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

		}

	// create screen redraw with render stages

	iRedraw = CScreenRedraw::NewL(*this);

	iScreenDevice = iRedraw->ObjectInterface<MWsScreenDevice>();

	WS_ASSERT_ALWAYS(iScreenDevice, EWsPanicScreenDeviceMissing);

	iScene = iRedraw->ObjectInterface<MWsScene>();

	WS_ASSERT_ALWAYS(iScene, EWsPanicSceneMissing);

	iDeviceMap = CGraphicsDeviceMap::NewL(*iScreenDevice);

	iDisplayControl = MWsScreen::ObjectInterface<MWsDisplayControl>();

	iDisplayMapping = MWsScreen::ObjectInterface<MWsDisplayMapping>();

	iDisplayPolicy = MWsScreen::ObjectInterface<MWsDisplayPolicy>();

	// initialize screen size mode data

	LoadScreenSizesL(iScreenDevice->SizeInPixels());

	iFallbackMap = CFallbackMap::NewL(this);

	LoadScreenSizeProperties(iScreenDevice->DisplayMode());

	if (iDisplayPolicy)

		{

		iDisplayPolicy->NewAppModesAvailable();

		}

	iDigitiserArea = aDigitiserArea;

	SetInitialScreenSizeModeAndRotation(); //get the first/lowest valid mode.  Also calls SetDigitiserAreas

	ApplyRemainingWsiniSettingsL();

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

	iRootWindow->ConstructL();

	// Default fading parameters

	iBlackMap=128;

	iWhiteMap=255;

	iSpriteManager = CWsSpriteManager::NewL();

	InitializeSceneL();

	InitializeUiElementsL();

	iSurfaceMap = new (ELeave) CRegisteredSurfaceMap(*iScene);

	//if the interface for notification is available. start notification AO.

	if (iDisplayControl)

		{

		iDisplayChangeNotifier = CWsDisplayChangeNotifier::NewL(iDisplayControl, this);

		iDisplayChangeNotifier->IssueNotificationRequest();

		iConfigChangeNotifier = CWsConfigChangeNotifier::NewL(iDisplayControl, this);

		iConfigChangeNotifier->IssueNotificationRequest();

		}

	doSetScreenMode(iScreenSizeMode,ETrue);

	}

void CScreen::ApplyRemainingWsiniSettingsL()

	{

#if defined(__WINS__) && defined(_DEBUG)

	_LIT(KDebugOsb,"DEBUGOSB");

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

		{

		_LIT(KDebugWinTitleFormat, "Screen %d, DSA surface");

		TBuf<32> title;

		title.Format(KDebugWinTitleFormat, iScreenNumber);

		iDebugWin = CDebugOsbWin::NewL(title, iScreenDevice->SizeInPixels());

		}

#endif

   	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;

		}

	//Cache pointers to renderstage APIs required in CHANGETRACKING mode

	iWindowTreeObserver = iRedraw->ObjectInterface<MWsWindowTreeObserver>(); 

	iDrawAnnotationObserver = iRedraw->ObjectInterface<MWsDrawAnnotationObserver>();

	iWindowVisibilityNotifier = iRedraw->ObjectInterface<MWsWindowVisibilityNotifier>();

	if(iWindowVisibilityNotifier)

		{

		iWindowVisibilityNotifier->RegisterWindowVisibilityObserver(iRedraw);

		}

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

		{

		iFlags|=EChangeTracking;

		}

	//coverity[const]

	TInt refreshRate = 1000000;

	_LIT(KDebugBar, "DEBUGBAR");

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

		{

		if (refreshRate < 100000)

			// coverity [dead_error_line]

			refreshRate = 50000;

		iDebugBar = CDebugBar::NewL(this, refreshRate);

		}

	}

void CScreen::AcquireDsaScreenDeviceL()

	{

	//creates WSERV's DSA buffer handle

	//registers the DSA surface into the scene accordingly to the value of aRegisterSurface

	if(!iDsaDevice)

		{

		TDisplayMode screenMode = ENone;

		screenMode = iScreenDevice->DisplayMode();

		if(screenMode != ENone)

			{

			CreateDsaScreenDeviceIfSupportedL(screenMode);

			// initialize DSA

			iDsaDevice->SetAutoUpdate(EFalse);

			iDsaDevice->SetDeviceOrientation(GcToDevice(ScreenSizeModeData().iRotation));

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

			// register DSA Surface

			TInt err = InitializeDsaSurface();

			// create a graphics context to clear the DSA surface

			if (!err)

				err = iDsaDevice->CreateContext(iDsaGc);

			if (!err)

				iDsaGc->Activate(iDsaDevice);

			if (err != KErrNone)

				{

				//Creation of the DSA surface failed

				//Cleanup the DSA Surface ID

				iDsaSurface = TSurfaceId::CreateNullId();

				//and the iDsaDevice

				delete iDsaDevice;

				iDsaDevice = NULL;

				User::Leave(err);

				}

			}

		else

			{

			User::Leave(KErrNotSupported);

			}

		}

	iNumberDrawingDsa++;

	}

void CScreen::CreateDsaScreenDeviceIfSupportedL(TDisplayMode aScreenMode)

	{

	if(DoCreateDsaScreenDevice(aScreenMode))

		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(DoCreateDsaScreenDevice(EColor16MAP))

		return;

	if(DoCreateDsaScreenDevice(EColor16MA))

		return;

	if(DoCreateDsaScreenDevice(EColor16MU))

		return;

	if(DoCreateDsaScreenDevice(EColor16M))

		return;

	if(DoCreateDsaScreenDevice(EColor64K))

		return;

	if(DoCreateDsaScreenDevice(EColor4K))

		return;

	if(DoCreateDsaScreenDevice(EColor256))

		return;

	if(DoCreateDsaScreenDevice(EColor16))

		return;

	if(DoCreateDsaScreenDevice(EGray256))

		return;

	if(DoCreateDsaScreenDevice(EGray16))

		return;

	if(DoCreateDsaScreenDevice(EGray4))

		return;

	if(DoCreateDsaScreenDevice(EGray2))

		return;

	User::Leave(KErrNotSupported);

	}

TBool CScreen::DoCreateDsaScreenDevice(TDisplayMode aScreenMode)

	{

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

	if(err == KErrNone)

		{

		TUint supportedDsaRotationModes = iDsaDevice->DeviceOrientationsAvailable();

		MWsScene::TSceneRotation currenTSceneRotation = iScene->SceneRotation();

		TBool doesDsaSupportThisMode = EFalse;

		switch(currenTSceneRotation)

			{

			case MWsScene::ESceneAntiClockwise0:

				if(supportedDsaRotationModes & EDeviceOrientationNormal)

					{

					doesDsaSupportThisMode = ETrue;

					}

				break;

			case MWsScene::ESceneAntiClockwise90:

				if(supportedDsaRotationModes & EDeviceOrientation90CW)

					{

					doesDsaSupportThisMode = ETrue;

					}

				break;				

			case MWsScene::ESceneAntiClockwise180:

				if(supportedDsaRotationModes & EDeviceOrientation180)

					{

					doesDsaSupportThisMode = ETrue;

					}

				break;				

			case MWsScene::ESceneAntiClockwise270:

				if(supportedDsaRotationModes & EDeviceOrientation270CW)

					{

					doesDsaSupportThisMode = ETrue;

					}

				break;				

			default:

				RDebug::Print(_L("** CScreen::DoCreateDsaScreenDevice Panic, non existing rotation mode"));

				WS_PANIC_ALWAYS(EWsPanicInvalidOperation);

				break;

			}

		if(!doesDsaSupportThisMode)

			{

			delete iDsaDevice;

			iDsaDevice = NULL;

			RDebug::Print(_L("** Current Rotation Mode not supported by the DSA device"));

			err = KErrNotSupported;

			}

		}

	return (err == KErrNone);

	}

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

	{

	if (aDirects.IsEmpty())

		return;

	TInt nofDSAs = 0;

	CWsDirectScreenAccess* direct= NULL;

	TSglQueIter<CWsDirectScreenAccess> iter(aDirects);

	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)

			{

			WS_ASSERT_DEBUG((dsaNo<=(nofDSAs)),EWsPanicDirectScreenAccess);

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

			dsaNo++;

			}

		cancelReqList[ 0 ] = &timerStatus;

		//wait for response or timeout

		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;

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

		{

		if (direct==aDirect)

			return ETrue;

		}

	return EFalse;

	}

#endif

void CScreen::KillForegroundSession()

	{

	if (iCurrentFocus)

		{

		_LIT(KWSERVKillWinGp,"Killing Session owning Window Group with Id=%d");

		if (wsDebugLog)

			wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,KWSERVKillWinGp,iCurrentFocus->Identifier());

		iCurrentFocus->WsOwner()->SessionTerminate();

		}

	}

CWsWindowGroup* CScreen::FindNewFocus(CWsRootWindow* aRootWindow)

	{

	CWsWindowGroup* newFocus;

	for(newFocus=aRootWindow->Child();newFocus && newFocus->CanReceiveFocus()==EFalse;newFocus=newFocus->NextSibling()) {}

	return newFocus;

	}

void CScreen::ResetFocus(CWsWindowGroup* aClosingWindow)

	{

	CWsWindowGroup* oldFocus=iCurrentFocus;

	CWsWindowGroup* newFocus=NULL;

	CScreen* newFocusedScreen=NULL;

	iCurrentFocus=FindNewFocus(iRootWindow);

	TBool focusedScreen= EFalse;

	/*Focus policy is specified in the wsini.ini file using the keyword 'MULTIFOCUSPOLICY'.

	If the keyword is not specified, then the default policy is run.

	*/

	if(!CWsTop::MultiFocusPolicy())

		{

		focusedScreen=(this==CWsTop::CurrentFocusScreen()); //check if this screen is the focus screen

		if (!iCurrentFocus && focusedScreen)

			{

			/*If this screen is the focused screen but does not have a focusable window group, then search for the

			next screen that has a focusable window group and set that screen as the focused screen.

			*/

			CScreen* screen=NULL;

			TInt screenNo;

			for (screenNo=0; screenNo<CWsTop::NumberOfScreens() && !newFocus; ++screenNo)

				{

				if (screenNo!=iScreenNumber)

					{

					screen=CWsTop::Screen(screenNo);

					newFocus=FindNewFocus(screen->RootWindow());

					}

				}

			if (newFocus)

				newFocusedScreen=screen;

			}

		}

	/*Scenario A: multi-focus policy

			newFocusedScreen is NULL

			focusedScreen is EFalse

			CWsTop::MultiFocusPolicy() returns ETrue

			Check if the new focusable window group is not the same, send focus lost message to window group

			that has just lost focus and send focus gain message to window group that can receive focus.

	  Scenario B: single-focus policy (default)

			CWsTop::MultiFocusPolicy() returns EFalse

			Check if the new focusable window group is not the same or if there is a new focused screen, send focus lost

			message to window group that has just lost focus and send focus gain message to window group that can receive focus.

	*/

	if (iCurrentFocus!=oldFocus || newFocusedScreen)

		{

		if (oldFocus && (focusedScreen || CWsTop::MultiFocusPolicy()) && oldFocus!=aClosingWindow)

			{

			oldFocus->LostFocus();

			}

		if (newFocusedScreen)

			{

			CWsTop::SetCurrentFocusScreen(newFocusedScreen);

			newFocus->ReceivedFocus();

			}

		else if (iCurrentFocus && (focusedScreen || CWsTop::MultiFocusPolicy()))

			{

			iCurrentFocus->ReceivedFocus();

			}

		TWsPointer::UpdatePointerCursor();

		TWindowServerEvent::SendFocusChangedEvents();

		}

	TWindowServerEvent::SendGroupListChangedEvents();

	}

void CScreen::RemoveFromDefaultOwningList(CWsWindowGroup *aDestroyedGroup)

	{

	for (CWsWindowGroup **group=&iDefaultOwningWindow;*group;group=(*group)->NextDefaultOwningWindowPtr())

		{

		if (*group==aDestroyedGroup)

			{

			*group=*aDestroyedGroup->NextDefaultOwningWindowPtr();

			break;

			}

		}

	}

void CScreen::SetDefaultOwningWindow(CWsWindowGroup *aGroup)

	{

	RemoveFromDefaultOwningList(aGroup);

	aGroup->SetNextDefaultOwningWindow(iDefaultOwningWindow);

	iDefaultOwningWindow=aGroup;

	}

void CScreen::GetScanLine(const TWsSdCmdGetScanLine *aGetScanLine)

	{

	TRgb buf[EGetScanLineBufLen];

	TPtr8 des((TUint8 *)&buf[0],EGetScanLineBufLen*sizeof(TRgb));

	TPoint pos(aGetScanLine->pos);

	TInt read=0;

	TInt len=(des.MaxLength()*EGetScanLineBufLen)/CFbsBitmap::ScanLineLength(EGetScanLineBufLen,aGetScanLine->dispMode);

	if (aGetScanLine->len < 0 || (CFbsBitmap::ScanLineLength(aGetScanLine->len, aGetScanLine->dispMode) >

									CWsClient::CurrentClient()->ClientMessage().GetDesMaxLength(1)))

		{

		CWsClient::PanicCurrentClient(EWservPanicInvalidParameter);

		}

	FOREVER

		{

		if ((aGetScanLine->len-read)<len)

			len=aGetScanLine->len-read;

		iScreenDevice->GetScanLine(des,pos,len,aGetScanLine->dispMode);

		CWsClient::ReplyBuf(des);

		read+=len;

		if (read==aGetScanLine->len)

			break;

		pos.iX+=len;

		}

	}

void CScreen::MaxNumColors(TInt& aColors,TInt& aGrays)

	{

	aGrays=0;

	aColors=TDisplayModeUtils::NumDisplayModeColors(DisplayMode());

	if (!TDisplayModeUtils::IsDisplayModeColor(DisplayMode()))

		{

		aGrays=aColors;

		aColors=0;

		}

	}

#define MODE_TO_FLAG(x) 1<<(x-1)

#define ROTATION_TO_FLAG(x) 1<<x

const TUint allRotationsMask = ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationNormal)

						| ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationRotated90)

						| ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationRotated180)

						| ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationRotated270);

const TUint KRotation0_180Mask = ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationNormal)

						| ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationRotated180);

const TUint KRotation90_270Mask = ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationRotated90)

						| ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationRotated270);

TInt CScreen::ColorModesFlag()

	{

	return MODE_TO_FLAG(DisplayMode());

	}

void CScreen::UpdateDsa()

	{

	if(iDsaDevice)

		{

		#if defined(__WINS__) && defined(_DEBUG)

			if (iDebugWin)

				iDebugWin->Refresh(iDsaDevice->SizeInPixels(), iDsaDevice->DisplayMode(), iDsaDevice->Bits());

		#endif

		iDsaDevice->Update();

		}

	}

const CGraphicsDeviceMap& CScreen::DeviceMap() const

	{

	return *iDeviceMap;

	}

const MWsScreenDevice& CScreen::ScreenDevice() const

	{

	return *iScreenDevice; 

	}

void CScreen::SetPointerCursorArea(TInt aMode,const TRect& aRect)

	{

	(*iModes)[aMode]->iPointerCursorArea=aRect;

	(*iModes)[aMode]->iFlags |= EClientDefinedDigitiserArea;

	TWsPointer::SetPointerCursorPos(TWsPointer::PointerCursorPos());

	}

CFbsBitGc::TGraphicsOrientation CScreen::Orientation() const

	{

  	WS_ASSERT_DEBUG(IsValidScreenSizeMode(iScreenSizeMode),EWsPanicInvalidScreenSizeMode);

	return (*iModes)[iScreenSizeMode]->iRotation;

	}

TRect CScreen::DrawableArea() const

	{

	TRect drawRect=iScreenDevice->SizeInPixels();

	if (iDisplayMapping)

		{

		iDisplayMapping->MapCoordinates(EFullScreenSpace,drawRect,EApplicationSpace,drawRect);                   

		}

	return drawRect;

	}

TClientPanic CScreen::SetModeRotation(TInt aMode,CFbsBitGc::TGraphicsOrientation aRotation)

	{

	if (!IsValidScreenSizeMode(aMode))

		return EWservPanicScreenModeNumber;

	TSizeMode& mode=*(*iModes)[aMode];

	if (!(ROTATION_TO_FLAG(aRotation)&mode.iAlternativeRotations))

		return EWservPanicRotation;

	CFbsBitGc::TGraphicsOrientation oldRotation=mode.iRotation;

	mode.iRotation=aRotation;

	CWsWindowGroup::NewOrientation(aMode,aRotation, iRootWindow);

	if (aMode==ScreenSizeMode())

		{

		if(iDisplayPolicy && iDisplayControl && (mode.iAlternativeRotations == allRotationsMask))

			{

			//square mode supports all 4 rotations. We'd better do a complete Setconfiguration

			//all parameters are recalculated for 90 degree rotation

			//The most important one is the offset, since we need to re-center the appmode and it's a policy behaviour

			TDisplayConfiguration config;

			iDisplayControl->GetConfiguration(config);

			//update rotation

			config.SetRotation((TDisplayConfiguration::TRotation)aRotation);

			SetConfiguration(config);

			}

		else if (!UpdateOrientation())

			{

			// Roll back earlier change

			mode.iRotation=oldRotation;

			CWsWindowGroup::NewOrientation(aMode, oldRotation, iRootWindow);

			}

		}

	return EWservNoPanic;

	}

void CScreen::CycleDisplaySize()

	{

	TInt newMode = iScreenSizeMode;

	TSizeMode* sizeMode = NULL;

	do

		{

		newMode = (newMode+1)%iModes->Count();

		sizeMode = (*iModes)[newMode];

		}

	while (sizeMode==NULL);

	doSetScreenMode(newMode);

	}

void CScreen::doSetScreenMode(TInt aMode,TBool aInsideStartup)

	{

  	WS_ASSERT_DEBUG(IsValidScreenSizeMode(aMode),EWsPanicInvalidScreenSizeMode);

 	TWindowServerEvent::NotifyDrawer(TWservCrEvent(TWservCrEvent::EScreenSizeModeAboutToChange, aMode));

	if (iDisplayControl && iDisplayPolicy)

		{

		TDisplayConfiguration config;

		TRect sizeModePosition;

		TInt error;

		TSizeMode& mode=*(*iModes)[aMode];

		config.SetRotation((TDisplayConfiguration::TRotation)mode.iRotation);

		//This will return suitable config when display is connected

		//and UI size equal to smallest appmode when disconnected

		error = iDisplayPolicy->GetSizeModeConfiguration(aMode,config,sizeModePosition);

		//set appmode in policy

		if (iDisplayMapping)

			{

			iDisplayMapping->SetSizeModeExtent(sizeModePosition,MWsDisplayMapping::KOffsetAll);

			}

		MWsScene::TSceneRotation oldRotation;

		TSize newUiSize;

		config.GetResolution(newUiSize);

		if (error == KErrNone)

			{

			oldRotation = iScene->SceneRotation();

			//The config info will always be set in policy. If display is connected, policy will have

			//correct composition, Ui and app res. otherwise Ui and appmode will be both set to smallest

			//app mode, composition will be set to zero

			if (iFlags&EHasDynamicSizeModes)

				{

				error = iFallbackMap->Resize(newUiSize);

				}

			if (error == KErrNone)

				{

				error = iDisplayControl->SetConfiguration(config);

				}

			}

		if (error == KErrNone)

			{

			UpdateDynamicScreenModes();

			AbortAllDirectDrawing(RDirectScreenAccess::ETerminateScreenMode);

			if(iDsaDevice && iDsaDevice->GraphicsAccelerator())

				{

				iDsaDevice->ChangeScreenDevice(iDsaDevice); // orientation has changed, therefore we need to re-initialise the screen device's graphics accelerator

				}

			iScreenSizeMode=aMode;

			//This could fail (to set orientation on the context, or to register the rotated DSA).

			//Previously, the update rotation was deferred, leaving the size mode out of step with the actual rotation

			//It also returns false if the orientation is "intentionally" not modified.

			(void) UpdateOrientation(&oldRotation);	

			//SetDigitiserAreas needs revisiting if/when we support dynamic resolutions

            //on a screen with touch input.

            //SetDigitiserAreas(newUiSize);

			CWsWindowGroup::SetScreenDeviceValidStates(this);

			if (!aInsideStartup)

				{