// 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 <hal_data.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);

	}

/** Convert a TGraphicsOrientation value into a TDigitiserOrientation.

Note: The algorithm used makes use of the ordering of the values of the respective enums, 

thus this is checked for (at compile time) at the start of the function.

@param aGcOrientation A value from the TGraphicsOrientation enums.

@return The equivalent value from the TDigitiserOrientation enums.

*/

inline HALData::TDigitiserOrientation GcToDigitiser(CFbsBitGc::TGraphicsOrientation aGcOrientation)

	{

	__ASSERT_COMPILE(CFbsBitGc::EGraphicsOrientationNormal+1==CFbsBitGc::EGraphicsOrientationRotated90);

    __ASSERT_COMPILE(CFbsBitGc::EGraphicsOrientationNormal+2==CFbsBitGc::EGraphicsOrientationRotated180);

    __ASSERT_COMPILE(CFbsBitGc::EGraphicsOrientationNormal+3==CFbsBitGc::EGraphicsOrientationRotated270);

    __ASSERT_COMPILE(HALData::EDigitiserOrientation_000+1==HALData::EDigitiserOrientation_090);

    __ASSERT_COMPILE(HALData::EDigitiserOrientation_000+2==HALData::EDigitiserOrientation_180);

    __ASSERT_COMPILE(HALData::EDigitiserOrientation_000+3==HALData::EDigitiserOrientation_270);

    HALData::TDigitiserOrientation ret = static_cast<HALData::TDigitiserOrientation> 

            (HALData::EDigitiserOrientation_000 + (aGcOrientation - CFbsBitGc::EGraphicsOrientationNormal));

    return ret;

	}

LOCAL_C 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: