sl@0: // Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include "screen.h"
sl@0: 
sl@0: #include <hal.h>
sl@0: #include <graphics/wsscreendevice.h>
sl@0: #include <graphics/wsscene.h>
sl@0: #include <graphics/wselement.h>
sl@0: #include "server.h"
sl@0: #include "wstop.h"
sl@0: #include "rootwin.h"
sl@0: #include "walkwindowtree.h"
sl@0: #include "EVENT.H"
sl@0: #include "windowgroup.h"
sl@0: #include "inifile.h"
sl@0: #include "pointer.h"
sl@0: #include "windowelementset.h"
sl@0: #include "registeredsurfacemap.h"
sl@0: #include "debugbar.h"
sl@0: #include "ScreenRedraw.h"
sl@0: #include "wspluginmanager.h"
sl@0: #include "devicemap.h"
sl@0: #include <graphics/wsdisplaymapping.h>
sl@0: #if defined(__WINS__) && defined(_DEBUG)
sl@0: #include "../../debuglog/osbwin.h"
sl@0: #endif
sl@0: #include <graphics/wsdisplaycontrol.h>
sl@0: 
sl@0: GLREF_D CDebugLogBase *wsDebugLog;
sl@0: 
sl@0: LOCAL_C inline MWsScene::TSceneRotation GcToScreen(CFbsBitGc::TGraphicsOrientation aGcOrientation)
sl@0: 	{
sl@0: 	MWsScene::TSceneRotation screenRotation = MWsScene::ESceneAntiClockwise0;
sl@0: 
sl@0: 	switch (aGcOrientation)
sl@0: 		{
sl@0: 		case CFbsBitGc::EGraphicsOrientationRotated90:
sl@0: 			screenRotation = MWsScene::ESceneAntiClockwise90;
sl@0: 			break;
sl@0: 		case CFbsBitGc::EGraphicsOrientationRotated180:
sl@0: 			screenRotation = MWsScene::ESceneAntiClockwise180;
sl@0: 			break;
sl@0: 		case CFbsBitGc::EGraphicsOrientationRotated270:
sl@0: 			screenRotation = MWsScene::ESceneAntiClockwise270;
sl@0: 			break;
sl@0: 		}
sl@0: 
sl@0: 	return screenRotation;
sl@0: 	}
sl@0: 
sl@0: LOCAL_C inline TDeviceOrientation GcToDevice(CFbsBitGc::TGraphicsOrientation aGcOrientation)
sl@0: 	{
sl@0: 	// Each device orientation is defined to be the value where just the bit
sl@0: 	// corresponding to the GDI orientation value is set.
sl@0: 	return (TDeviceOrientation)(1 << aGcOrientation);
sl@0: 	}
sl@0: 
sl@0: LOCAL_D TBool FindNextValue(TLex& aLex, TInt& aValue) // assumes the list cannot contain *negative* integers
sl@0: 	{
sl@0: 	while (!aLex.Eos())
sl@0: 		{
sl@0: 		const TUint character=aLex.Peek();
sl@0: 		if (Rng(TUint('0'), character, TUint('9')) || (character=='-'))
sl@0: 			{
sl@0: 			break;
sl@0: 			}
sl@0: 		aLex.Inc();
sl@0: 		}
sl@0: 
sl@0: 	return (aLex.Val(aValue)==KErrNone);
sl@0: 	}
sl@0: 
sl@0: CScreen::CFallbackMap * CScreen::CFallbackMap::NewL(CScreen* aScreen)
sl@0: 	{
sl@0: 	CFallbackMap * self = new (ELeave) CFallbackMap(aScreen);
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL();
sl@0: 	CleanupStack::Pop(self);
sl@0: 	return self;
sl@0: 	}
sl@0: 	
sl@0: CScreen::CFallbackMap::CFallbackMap(CScreen* aScreen) :
sl@0: 	iScreen(aScreen),
sl@0: 	iRegion(TRect(TPoint(0,0), TSize(1,1))),
sl@0: 	iCount(0)
sl@0: 	{
sl@0: 	}
sl@0: 	
sl@0: CScreen::CFallbackMap::~CFallbackMap()
sl@0: 	{
sl@0: 	delete []iMap;
sl@0: 	}
sl@0: 	
sl@0: void CScreen::CFallbackMap::ConstructL()
sl@0: 	{
sl@0: 	iMapSize = 0;
sl@0: 	
sl@0: 	for (TInt num = 0; num < iScreen->NumScreenSizeModes(); ++num)
sl@0: 		{
sl@0: 		if (iScreen->IsValidScreenSizeMode(num))
sl@0: 			{
sl@0: 			const TSizeMode & mode = iScreen->ScreenSizeModeData(num);
sl@0: 			TInt width = mode.iScreenSize.iWidth / 32;
sl@0: 			if (mode.iScreenSize.iWidth & (32 - 1))
sl@0: 				++width;
sl@0: 			TInt size = width * mode.iScreenSize.iHeight;
sl@0: 			if (size > iMapSize)
sl@0: 				iMapSize = size;
sl@0: 			}
sl@0: 		}
sl@0: 		
sl@0: 	iMap = new (ELeave) TInt [iMapSize];
sl@0: 	}
sl@0: 
sl@0: void CScreen::CFallbackMap::Prepare()
sl@0: 	{
sl@0: 	const TSizeMode & mode = iScreen->ScreenSizeModeData();
sl@0: 	Mem::FillZ(iMap, iMapSize * sizeof(TInt));
sl@0: 	iCount = mode.iScreenSize.iHeight * mode.iScreenSize.iWidth;
sl@0: 	WS_ASSERT_DEBUG(iRegion.Count() == 1, EWsPanicScreenFallback);
sl@0: 	iRegion.Clear();
sl@0: 	iRegion.AddRect(TRect(mode.iOrigin, mode.iScreenSize));
sl@0: 	}
sl@0: 
sl@0: TBool CScreen::CFallbackMap::FillRegion(const TRegion& aRegion)
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(!aRegion.CheckError(), EWsPanicScreenFallback);
sl@0: 	if (aRegion.Count() > 20 || aRegion.CheckError())
sl@0: 		return ETrue;
sl@0: 	TBool hit = EFalse;
sl@0: 	if (iCount > 0)
sl@0: 		{
sl@0: 		const TRect * rect = aRegion.RectangleList();
sl@0: 		for (TInt num = 0; num < aRegion.Count(); ++num)
sl@0: 			{
sl@0: 			hit = FillRect(*rect) || hit;
sl@0: 			if (iCount < 1)
sl@0: 				break;
sl@0: 			++rect;
sl@0: 			}
sl@0: 		}
sl@0: 	return hit;
sl@0: 	}
sl@0: 	
sl@0: // x >> 5 is equivalent to x / 32
sl@0: // 0x1F is the rounding error when dividing by 32
sl@0: // 0x20 is 32.
sl@0: // The compiler might do all the optimizations for us - not checked.
sl@0: TBool CScreen::CFallbackMap::FillRect(const TRect& aRect)
sl@0: 	{
sl@0: 	TBool hit = EFalse;
sl@0: 	const TSizeMode & mode = iScreen->ScreenSizeModeData();
sl@0: 	TRect scrrect(mode.iOrigin, mode.iScreenSize);
sl@0: 	TRect rect = aRect;
sl@0: 	rect.Intersection(scrrect);
sl@0: 	TInt rowWidthInInts = mode.iScreenSize.iWidth;
sl@0: 	if (rowWidthInInts & 0x1F)
sl@0: 		rowWidthInInts += 0x20;
sl@0: 	rowWidthInInts >>= 5;
sl@0: 
sl@0: 	TInt colStartInInts = rect.iTl.iX >> 5;
sl@0: 	TInt firstOffsetInBits = rect.iTl.iX & 0x1F;
sl@0: 
sl@0: 	for(TInt row = rect.iTl.iY; row < rect.iBr.iY; ++row)
sl@0: 		{
sl@0: 		TInt * map = iMap + row * rowWidthInInts + colStartInInts;
sl@0: 		TInt offsetShift = 31 - firstOffsetInBits;
sl@0: 		for (TInt col = rect.iTl.iX; col < rect.iBr.iX; ++col)
sl@0: 			{
sl@0: 			WS_ASSERT_DEBUG(map - iMap < iMapSize, EWsPanicScreenFallback);
sl@0: 			if (!(*map & 1 << offsetShift))
sl@0: 				{
sl@0: 				--iCount;
sl@0: 				hit = ETrue;
sl@0: 				if (iCount < 1)
sl@0: 					break;
sl@0: 				(*map) |= (1 << offsetShift);
sl@0: 				}
sl@0: 			--offsetShift;
sl@0: 			if (offsetShift < 0)
sl@0: 				{
sl@0: 				offsetShift = 31;
sl@0: 				++map;
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	return hit;
sl@0: 	}
sl@0: 
sl@0: TInt CScreen::CFallbackMap::Count() const
sl@0: 	{
sl@0: 	return iCount;
sl@0: 	}
sl@0: 
sl@0: const TRect * CScreen::CFallbackMap::Rect() const
sl@0: 	{
sl@0: 	return iRegion.RectangleList();
sl@0: 	}
sl@0: 	
sl@0: const RRegion * CScreen::CFallbackMap::Region() const
sl@0: 	{
sl@0: 	return &iRegion;
sl@0: 	}
sl@0: 
sl@0: TInt CScreen::CFallbackMap::Resize(const TSize& aSize)
sl@0: 	{
sl@0: 	TInt err = KErrNone;
sl@0: 	TInt width = (aSize.iWidth+31) >> 5;	// divide by 32
sl@0: 	TInt invertedWidth = (aSize.iHeight+31) >> 5;	// divide by 32
sl@0: 		
sl@0: 	TInt maxSize = Max(width * aSize.iHeight,invertedWidth * aSize.iWidth);
sl@0: 	if (maxSize > iMapSize)
sl@0: 		{
sl@0: 		TInt* newMap=NULL;
sl@0: 		newMap = new  TInt [maxSize];
sl@0: 		if (newMap)
sl@0: 			{
sl@0: 			delete []iMap;
sl@0: 			iMap = newMap;
sl@0: 			iMapSize = maxSize;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			err = KErrNoMemory;
sl@0: 			}
sl@0: 		}
sl@0: 	return err;
sl@0: 	}
sl@0: 	
sl@0: //
sl@0: // CScreen
sl@0: //
sl@0: CScreen::CScreen(): iDirects(_FOFF(CWsDirectScreenAccess,iLink)), iMaxContrast(-1), iMaxBrightness(-1)
sl@0: , iDisplayChangeSpinner(0), iConfigChangeSpinner(0)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: CScreen::~CScreen()
sl@0: 	{
sl@0: 	delete iDebugBar;
sl@0: 	TInt ii;
sl@0: 	if(iModes)
sl@0: 		{
sl@0: 		for(ii=iNumScreenSizeModes-1;ii>=0;--ii)
sl@0: 			{
sl@0: 			delete (*iModes)[ii];
sl@0: 			}
sl@0: 		iModes->Close();
sl@0: 		delete iModes;
sl@0: 		}
sl@0: 	delete iRootWindow;
sl@0: 	iScreenDevice = NULL;
sl@0: 	delete iDsaDevice;
sl@0: 	delete iDeviceMap;
sl@0: 	delete iFallbackMap;
sl@0: 	delete iSpriteManager;
sl@0: 	delete iWindowElementSet;
sl@0: 	if (!iDsaSurface.IsNull())
sl@0: 	    {
sl@0: 	    TInt err = iScene->UnregisterSurface(iDsaSurface);
sl@0: 		WS_ASSERT_DEBUG(KErrNone == err, EWsPanicDirectScreenAccess);
sl@0: 	    }
sl@0: 
sl@0: 	delete iSurfaceMap;
sl@0: 	delete iRedraw;
sl@0: #if defined(__WINS__) && defined(_DEBUG)
sl@0: 	delete iDebugWin;
sl@0: #endif
sl@0: 	
sl@0: 	if(iDisplayChangeNotifier)
sl@0: 		delete iDisplayChangeNotifier;
sl@0: 	if(iConfigChangeNotifier)
sl@0: 		delete iConfigChangeNotifier;
sl@0: 	iWsClientList.Close();
sl@0: 	}
sl@0: 
sl@0: void CScreen::ConstructL(const TRect& aDigitiserArea, TInt aScreenNumber)
sl@0: 	{
sl@0: 	iScreenNumber = aScreenNumber ;
sl@0: 
sl@0: 	if (wsDebugLog)
sl@0: 		{
sl@0: 		_LIT(KWSERVInitScreen,"Initialising for Screen %d");
sl@0: 		wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant, KWSERVInitScreen, aScreenNumber);
sl@0: 		}
sl@0: 
sl@0: 	// create screen redraw with render stages
sl@0: 	iRedraw = CScreenRedraw::NewL(*this);
sl@0: 	iScreenDevice = iRedraw->ObjectInterface<MWsScreenDevice>();
sl@0: 	WS_ASSERT_ALWAYS(iScreenDevice, EWsPanicScreenDeviceMissing);
sl@0: 	iScene = iRedraw->ObjectInterface<MWsScene>();
sl@0: 	WS_ASSERT_ALWAYS(iScene, EWsPanicSceneMissing);
sl@0: 	
sl@0: 	iDeviceMap = CGraphicsDeviceMap::NewL(*iScreenDevice);
sl@0: 
sl@0: 	iDisplayControl = MWsScreen::ObjectInterface<MWsDisplayControl>();
sl@0: 	iDisplayMapping = MWsScreen::ObjectInterface<MWsDisplayMapping>();
sl@0: 	iDisplayPolicy = MWsScreen::ObjectInterface<MWsDisplayPolicy>();
sl@0: 
sl@0: 
sl@0: 	// initialize screen size mode data
sl@0: 	LoadScreenSizesL(iScreenDevice->SizeInPixels());
sl@0: 	iFallbackMap = CFallbackMap::NewL(this);
sl@0: 
sl@0: 	LoadScreenSizeProperties(iScreenDevice->DisplayMode());
sl@0: 
sl@0: 	if (iDisplayPolicy)
sl@0: 		{
sl@0: 		iDisplayPolicy->NewAppModesAvailable();
sl@0: 		}
sl@0: 	
sl@0: 	iDigitiserArea = aDigitiserArea;
sl@0: 	SetInitialScreenSizeModeAndRotation(); //get the first/lowest valid mode.  Also calls SetDigitiserAreas
sl@0: 	
sl@0: 	ApplyRemainingWsiniSettingsL();
sl@0: 	
sl@0: 	iRootWindow = new (ELeave) CWsRootWindow(NULL, this);
sl@0: 	iRootWindow->ConstructL();
sl@0: 	
sl@0: 	// Default fading parameters
sl@0: 	iBlackMap=128;
sl@0: 	iWhiteMap=255;
sl@0: 	
sl@0: 	iSpriteManager = CWsSpriteManager::NewL();
sl@0: 
sl@0: 	InitializeSceneL();
sl@0: 	InitializeUiElementsL();
sl@0: 	iSurfaceMap = new (ELeave) CRegisteredSurfaceMap(*iScene);
sl@0: 	
sl@0: 	//if the interface for notification is available. start notification AO.
sl@0: 	if (iDisplayControl)
sl@0: 		{
sl@0: 		iDisplayChangeNotifier = CWsDisplayChangeNotifier::NewL(iDisplayControl, this);
sl@0: 		iDisplayChangeNotifier->IssueNotificationRequest();
sl@0: 		iConfigChangeNotifier = CWsConfigChangeNotifier::NewL(iDisplayControl, this);
sl@0: 		iConfigChangeNotifier->IssueNotificationRequest();
sl@0: 		}
sl@0: 	doSetScreenMode(iScreenSizeMode,ETrue);
sl@0: 	}
sl@0: 
sl@0: void CScreen::ApplyRemainingWsiniSettingsL()
sl@0: 	{
sl@0: #if defined(__WINS__) && defined(_DEBUG)
sl@0: 	_LIT(KDebugOsb,"DEBUGOSB");
sl@0: 	if(WsIniFile->FindVar(iScreenNumber, KDebugOsb))
sl@0: 		{
sl@0: 		_LIT(KDebugWinTitleFormat, "Screen %d, DSA surface");
sl@0: 		TBuf<32> title;
sl@0: 		title.Format(KDebugWinTitleFormat, iScreenNumber);
sl@0: 		iDebugWin = CDebugOsbWin::NewL(title, iScreenDevice->SizeInPixels());
sl@0: 		}
sl@0: #endif
sl@0: 	
sl@0:    	TInt autoClear = 1;
sl@0:    	_LIT(KWSERVIniFileVarAutoClear,"AUTOCLEAR");
sl@0:    	WsIniFile->FindVar(iScreenNumber,KWSERVIniFileVarAutoClear,autoClear);
sl@0:    	if (autoClear != 0)
sl@0:    		{
sl@0:    		iFlags|=EAutoClear;
sl@0:    		}
sl@0: 		
sl@0: 	_LIT(KBackLight,"BACKLIGHTCONTROL");
sl@0: 	iBackLightFlag=WsIniFile->FindVar( iScreenNumber, KBackLight);
sl@0: 
sl@0: 	_LIT(KWSERVIniFileVarBlankScreen, "BLANKSCREENONROTATION");
sl@0: 	if (WsIniFile->FindVar(iScreenNumber, KWSERVIniFileVarBlankScreen))
sl@0: 		{
sl@0: 		iFlags|=EBlankScreenOnRotation;
sl@0: 		}
sl@0: 
sl@0: 	//Cache pointers to renderstage APIs required in CHANGETRACKING mode
sl@0: 	iWindowTreeObserver = iRedraw->ObjectInterface<MWsWindowTreeObserver>(); 
sl@0: 	iDrawAnnotationObserver = iRedraw->ObjectInterface<MWsDrawAnnotationObserver>();
sl@0: 	iWindowVisibilityNotifier = iRedraw->ObjectInterface<MWsWindowVisibilityNotifier>();
sl@0: 	if(iWindowVisibilityNotifier)
sl@0: 		{
sl@0: 		iWindowVisibilityNotifier->RegisterWindowVisibilityObserver(iRedraw);
sl@0: 		}
sl@0: 	if (WsIniFile->FindVar(iScreenNumber, KWSERVIniFileVarChangeTracking))
sl@0: 		{
sl@0: 		iFlags|=EChangeTracking;
sl@0: 		}
sl@0: 
sl@0: 	//coverity[const]
sl@0: 	TInt refreshRate = 1000000;
sl@0: 	_LIT(KDebugBar, "DEBUGBAR");
sl@0: 	if (WsIniFile->FindVar(KDebugBar, refreshRate))
sl@0: 		{
sl@0: 		if (refreshRate < 100000)
sl@0: 			// coverity [dead_error_line]
sl@0: 			refreshRate = 50000;
sl@0: 		iDebugBar = CDebugBar::NewL(this, refreshRate);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CScreen::AcquireDsaScreenDeviceL()
sl@0: 	{
sl@0: 	//creates WSERV's DSA buffer handle
sl@0: 	//registers the DSA surface into the scene accordingly to the value of aRegisterSurface
sl@0: 	if(!iDsaDevice)
sl@0: 		{
sl@0: 		TDisplayMode screenMode = ENone;
sl@0: 		screenMode = iScreenDevice->DisplayMode();
sl@0: 		if(screenMode != ENone)
sl@0: 			{
sl@0: 			CreateDsaScreenDeviceIfSupportedL(screenMode);
sl@0: 			// initialize DSA
sl@0: 			iDsaDevice->SetAutoUpdate(EFalse);
sl@0: 			iDsaDevice->SetDeviceOrientation(GcToDevice(ScreenSizeModeData().iRotation));
sl@0: 			iDsaDevice->ChangeScreenDevice(NULL);    //This is necessary to initialise the screen
sl@0: 			// register DSA Surface
sl@0: 			TInt err = InitializeDsaSurface();
sl@0: 			// create a graphics context to clear the DSA surface
sl@0: 			if (!err)
sl@0: 				err = iDsaDevice->CreateContext(iDsaGc);
sl@0: 			if (!err)
sl@0: 				iDsaGc->Activate(iDsaDevice);
sl@0: 			if (err != KErrNone)
sl@0: 				{
sl@0: 				//Creation of the DSA surface failed
sl@0: 				//Cleanup the DSA Surface ID
sl@0: 				iDsaSurface = TSurfaceId::CreateNullId();
sl@0: 				//and the iDsaDevice
sl@0: 				delete iDsaDevice;
sl@0: 				iDsaDevice = NULL;
sl@0: 				User::Leave(err);
sl@0: 				}
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			User::Leave(KErrNotSupported);
sl@0: 			}
sl@0: 		}
sl@0: 	iNumberDrawingDsa++;
sl@0: 	}
sl@0: 
sl@0: void CScreen::CreateDsaScreenDeviceIfSupportedL(TDisplayMode aScreenMode)
sl@0: 	{
sl@0: 	if(DoCreateDsaScreenDevice(aScreenMode))
sl@0: 		return;
sl@0: 	// Try creating the screen device with all available display modes, going from best to worst
sl@0: 	__ASSERT_COMPILE(EColorLast == 14); // if any display mode is added to TDisplayMode we must update the list below
sl@0: 	// (the list below contains all enums in TDisplayMode except ENone, ERgb, EColorLast)
sl@0: 	if(DoCreateDsaScreenDevice(EColor16MAP))
sl@0: 		return;
sl@0: 	if(DoCreateDsaScreenDevice(EColor16MA))
sl@0: 		return;
sl@0: 	if(DoCreateDsaScreenDevice(EColor16MU))
sl@0: 		return;
sl@0: 	if(DoCreateDsaScreenDevice(EColor16M))
sl@0: 		return;
sl@0: 	if(DoCreateDsaScreenDevice(EColor64K))
sl@0: 		return;
sl@0: 	if(DoCreateDsaScreenDevice(EColor4K))
sl@0: 		return;
sl@0: 	if(DoCreateDsaScreenDevice(EColor256))
sl@0: 		return;
sl@0: 	if(DoCreateDsaScreenDevice(EColor16))
sl@0: 		return;
sl@0: 	if(DoCreateDsaScreenDevice(EGray256))
sl@0: 		return;
sl@0: 	if(DoCreateDsaScreenDevice(EGray16))
sl@0: 		return;
sl@0: 	if(DoCreateDsaScreenDevice(EGray4))
sl@0: 		return;
sl@0: 	if(DoCreateDsaScreenDevice(EGray2))
sl@0: 		return;
sl@0: 	User::Leave(KErrNotSupported);
sl@0: 	}
sl@0: 
sl@0: TBool CScreen::DoCreateDsaScreenDevice(TDisplayMode aScreenMode)
sl@0: 	{
sl@0: 	TRAPD(err, iDsaDevice = CFbsScreenDevice::NewL(iScreenNumber, aScreenMode));
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		TUint supportedDsaRotationModes = iDsaDevice->DeviceOrientationsAvailable();
sl@0: 		MWsScene::TSceneRotation currenTSceneRotation = iScene->SceneRotation();
sl@0: 		TBool doesDsaSupportThisMode = EFalse;
sl@0: 		switch(currenTSceneRotation)
sl@0: 			{
sl@0: 			case MWsScene::ESceneAntiClockwise0:
sl@0: 				if(supportedDsaRotationModes & EDeviceOrientationNormal)
sl@0: 					{
sl@0: 					doesDsaSupportThisMode = ETrue;
sl@0: 					}
sl@0: 				break;
sl@0: 			case MWsScene::ESceneAntiClockwise90:
sl@0: 				if(supportedDsaRotationModes & EDeviceOrientation90CW)
sl@0: 					{
sl@0: 					doesDsaSupportThisMode = ETrue;
sl@0: 					}
sl@0: 				break;				
sl@0: 			case MWsScene::ESceneAntiClockwise180:
sl@0: 				if(supportedDsaRotationModes & EDeviceOrientation180)
sl@0: 					{
sl@0: 					doesDsaSupportThisMode = ETrue;
sl@0: 					}
sl@0: 				break;				
sl@0: 			case MWsScene::ESceneAntiClockwise270:
sl@0: 				if(supportedDsaRotationModes & EDeviceOrientation270CW)
sl@0: 					{
sl@0: 					doesDsaSupportThisMode = ETrue;
sl@0: 					}
sl@0: 				break;				
sl@0: 			default:
sl@0: 				RDebug::Print(_L("** CScreen::DoCreateDsaScreenDevice Panic, non existing rotation mode"));
sl@0: 				WS_PANIC_ALWAYS(EWsPanicInvalidOperation);
sl@0: 				break;
sl@0: 			}
sl@0: 		if(!doesDsaSupportThisMode)
sl@0: 			{
sl@0: 			delete iDsaDevice;
sl@0: 			iDsaDevice = NULL;
sl@0: 			RDebug::Print(_L("** Current Rotation Mode not supported by the DSA device"));
sl@0: 			err = KErrNotSupported;
sl@0: 			}
sl@0: 		}
sl@0: 	return (err == KErrNone);
sl@0: 	}
sl@0: 
sl@0: void CScreen::AbortDSAs(RDirectScreenAccess::TTerminationReasons aReason, TSglQue<CWsDirectScreenAccess>& aDirects)
sl@0: 	{
sl@0: 	if (aDirects.IsEmpty())
sl@0: 		return;
sl@0: 
sl@0: 	TInt nofDSAs = 0;
sl@0: 	CWsDirectScreenAccess* direct= NULL;
sl@0: 	TSglQueIter<CWsDirectScreenAccess> iter(aDirects);
sl@0: 	while ((direct=iter++)!=NULL)
sl@0: 		{
sl@0: 		nofDSAs++;
sl@0: 		direct->SignalAbort(aReason);
sl@0: 		}
sl@0: 
sl@0: 	TRequestStatus timerStatus;
sl@0: 	RTimer& timer=CWsTop::Timer();
sl@0: 	timer.Cancel();
sl@0: 
sl@0: 	TRequestStatus** cancelReqList = (TRequestStatus**) User::AllocZ(sizeof(TRequestStatus*) * (nofDSAs + 1));
sl@0: 	if (NULL != cancelReqList)
sl@0: 		{
sl@0: 		TInt dsaNo = 1;
sl@0: 		timer.After(timerStatus, KDSAAbortingImmediateRespAwaitFrameMicrosec);
sl@0: 		iter.SetToFirst();
sl@0: 		while ((direct=iter++)!=NULL)
sl@0: 			{
sl@0: 			WS_ASSERT_DEBUG((dsaNo<=(nofDSAs)),EWsPanicDirectScreenAccess);
sl@0: 			cancelReqList[ dsaNo ] = &direct->AbortStatus();
sl@0: 			dsaNo++;
sl@0: 			}
sl@0: 		cancelReqList[ 0 ] = &timerStatus;
sl@0: 
sl@0: 		//wait for response or timeout
sl@0: 		User::WaitForNRequest(cancelReqList, nofDSAs + 1);
sl@0: 
sl@0: 		iter.SetToFirst();
sl@0: 		while ((direct=iter++)!=NULL)
sl@0: 			{
sl@0: 			if (direct->AbortStatus() != KRequestPending)
sl@0: 				direct->CancelAbortObject(); // responded
sl@0: 			else
sl@0: 				direct->Abort();
sl@0: 			}
sl@0: 
sl@0: 		if (timerStatus == KRequestPending)
sl@0: 			{
sl@0: 			timer.Cancel();
sl@0: 			User::WaitForRequest(timerStatus);
sl@0: 			}
sl@0: 
sl@0: 		User::Free(cancelReqList);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iter.SetToFirst();
sl@0: 		while ((direct=iter++) != NULL)
sl@0: 			{
sl@0: 			TRequestStatus timerStatus;
sl@0: 			RTimer& timer=CWsTop::Timer();
sl@0: 			timer.Cancel();
sl@0: 			timer.After(timerStatus, KDSAAbortingImmediateRespAwaitFrameMicrosec);
sl@0: 			
sl@0: 			//wait for response or timeout
sl@0: 			User::WaitForRequest(direct->AbortStatus(), timerStatus);
sl@0: 			
sl@0: 			if (direct->AbortStatus() != KRequestPending)
sl@0: 				direct->CancelAbortObject(); //responded
sl@0: 			else
sl@0: 				direct->Abort(); //timed out
sl@0: 
sl@0: 			if (timerStatus == KRequestPending)
sl@0: 				{
sl@0: 				timer.Cancel();
sl@0: 				User::WaitForRequest(timerStatus);
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CScreen::AbortAllDirectDrawing(RDirectScreenAccess::TTerminationReasons aReason)
sl@0: 	{
sl@0: 	AbortDSAs(aReason,iDirects);
sl@0: 	}
sl@0: 
sl@0: void CScreen::AddDirect(CWsDirectScreenAccess& aDirect)
sl@0: 	{
sl@0: 	TBool emptyBefore = iDirects.IsEmpty();
sl@0: 	iDirects.AddLast(aDirect);
sl@0: 	TBool emptyAfter = iDirects.IsEmpty();
sl@0: 	if (emptyBefore && ! emptyAfter)
sl@0: 		{
sl@0: 		TWsEvent wsevent;
sl@0: 		wsevent.SetType(EEventDirectScreenAccessBegin);
sl@0: 		*(wsevent.Int()) = iScreenNumber;
sl@0: 		TWindowServerEvent::PublishNotification(wsevent);
sl@0: 		}
sl@0: 
sl@0: 	if (iDsaDrawState==EDsaDrawStateIdle && aDirect.IsVisible())
sl@0: 		{
sl@0: 		iDsaDrawState = EDsaDrawStateDrawing;
sl@0: 		TWindowServerEvent::NotifyDrawer(TWservCrEvent(TWservCrEvent::EDsaDrawingBegin, iScreenNumber));
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CScreen::RemoveDirect(CWsDirectScreenAccess& aDirect)
sl@0: 	{
sl@0: 	TBool emptyBefore = iDirects.IsEmpty();
sl@0: 	iDirects.Remove(aDirect);
sl@0: 	TBool emptyAfter = iDirects.IsEmpty();
sl@0: 	if (emptyAfter && ! emptyBefore)
sl@0: 		{
sl@0: 		TWsEvent wsevent;
sl@0: 		wsevent.SetType(EEventDirectScreenAccessEnd);
sl@0: 		*(wsevent.Int()) = iScreenNumber;
sl@0: 		TWindowServerEvent::PublishNotification(wsevent);
sl@0: 		}
sl@0: 
sl@0: 	if (iDsaDrawState==EDsaDrawStateDrawing && aDirect.IsVisible() && !HasVisibleDirectOnQueue())
sl@0: 		{
sl@0: 		iDsaDrawState = EDsaDrawStateIdle;
sl@0: 		TWindowServerEvent::NotifyDrawer(TWservCrEvent(TWservCrEvent::EDsaDrawingEnd, iScreenNumber));
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TBool CScreen::HasVisibleDirectOnQueue()
sl@0: 	{
sl@0: 	if (iDirects.IsEmpty())
sl@0: 		return EFalse;
sl@0: 
sl@0: 	TSglQueIter<CWsDirectScreenAccess> iter(iDirects);
sl@0: 	CWsDirectScreenAccess* dsa;
sl@0: 	while ((dsa=iter++)!=NULL)
sl@0: 		{
sl@0: 		if (dsa->IsVisible())
sl@0: 			return ETrue;
sl@0: 		}
sl@0: 
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 
sl@0: #if defined(_DEBUG)
sl@0: TBool CScreen::IsDirectOnQueue(const CWsDirectScreenAccess* aDirect)
sl@0: 	{
sl@0: 	TSglQueIter<CWsDirectScreenAccess> iter(iDirects);
sl@0: 	CWsDirectScreenAccess* direct;
sl@0: 	while ((direct=iter++)!=NULL)
sl@0: 		{
sl@0: 		if (direct==aDirect)
sl@0: 			return ETrue;
sl@0: 		}
sl@0: 	return EFalse;
sl@0: 	}
sl@0: #endif
sl@0: 
sl@0: void CScreen::KillForegroundSession()
sl@0: 	{
sl@0: 	if (iCurrentFocus)
sl@0: 		{
sl@0: 		_LIT(KWSERVKillWinGp,"Killing Session owning Window Group with Id=%d");
sl@0: 		if (wsDebugLog)
sl@0: 			wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,KWSERVKillWinGp,iCurrentFocus->Identifier());
sl@0: 		iCurrentFocus->WsOwner()->SessionTerminate();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: CWsWindowGroup* CScreen::FindNewFocus(CWsRootWindow* aRootWindow)
sl@0: 	{
sl@0: 	CWsWindowGroup* newFocus;
sl@0: 	for(newFocus=aRootWindow->Child();newFocus && newFocus->CanReceiveFocus()==EFalse;newFocus=newFocus->NextSibling()) {}
sl@0: 
sl@0: 	return newFocus;
sl@0: 	}
sl@0: 
sl@0: void CScreen::ResetFocus(CWsWindowGroup* aClosingWindow)
sl@0: 	{
sl@0: 	CWsWindowGroup* oldFocus=iCurrentFocus;
sl@0: 	CWsWindowGroup* newFocus=NULL;
sl@0: 	CScreen* newFocusedScreen=NULL;
sl@0: 	iCurrentFocus=FindNewFocus(iRootWindow);
sl@0: 	TBool focusedScreen= EFalse;
sl@0: 	/*Focus policy is specified in the wsini.ini file using the keyword 'MULTIFOCUSPOLICY'.
sl@0: 	If the keyword is not specified, then the default policy is run.
sl@0: 	*/
sl@0: 	if(!CWsTop::MultiFocusPolicy())
sl@0: 		{
sl@0: 		focusedScreen=(this==CWsTop::CurrentFocusScreen()); //check if this screen is the focus screen
sl@0: 		if (!iCurrentFocus && focusedScreen)
sl@0: 			{
sl@0: 			/*If this screen is the focused screen but does not have a focusable window group, then search for the
sl@0: 			next screen that has a focusable window group and set that screen as the focused screen.
sl@0: 			*/
sl@0: 			CScreen* screen=NULL;
sl@0: 			TInt screenNo;
sl@0: 			for (screenNo=0; screenNo<CWsTop::NumberOfScreens() && !newFocus; ++screenNo)
sl@0: 				{
sl@0: 				if (screenNo!=iScreenNumber)
sl@0: 					{
sl@0: 					screen=CWsTop::Screen(screenNo);
sl@0: 					newFocus=FindNewFocus(screen->RootWindow());
sl@0: 					}
sl@0: 				}
sl@0: 			if (newFocus)
sl@0: 				newFocusedScreen=screen;
sl@0: 			}
sl@0: 		}
sl@0: 	/*Scenario A: multi-focus policy
sl@0: 			newFocusedScreen is NULL
sl@0: 			focusedScreen is EFalse
sl@0: 			CWsTop::MultiFocusPolicy() returns ETrue
sl@0: 			Check if the new focusable window group is not the same, send focus lost message to window group
sl@0: 			that has just lost focus and send focus gain message to window group that can receive focus.
sl@0: 	  Scenario B: single-focus policy (default)
sl@0: 			CWsTop::MultiFocusPolicy() returns EFalse
sl@0: 			Check if the new focusable window group is not the same or if there is a new focused screen, send focus lost
sl@0: 			message to window group that has just lost focus and send focus gain message to window group that can receive focus.
sl@0: 	*/
sl@0: 	if (iCurrentFocus!=oldFocus || newFocusedScreen)
sl@0: 		{
sl@0: 		if (oldFocus && (focusedScreen || CWsTop::MultiFocusPolicy()) && oldFocus!=aClosingWindow)
sl@0: 			{
sl@0: 			oldFocus->LostFocus();
sl@0: 			}
sl@0: 		if (newFocusedScreen)
sl@0: 			{
sl@0: 			CWsTop::SetCurrentFocusScreen(newFocusedScreen);
sl@0: 			newFocus->ReceivedFocus();
sl@0: 			}
sl@0: 		else if (iCurrentFocus && (focusedScreen || CWsTop::MultiFocusPolicy()))
sl@0: 			{
sl@0: 			iCurrentFocus->ReceivedFocus();
sl@0: 			}
sl@0: 		TWsPointer::UpdatePointerCursor();
sl@0: 		TWindowServerEvent::SendFocusChangedEvents();
sl@0: 		}
sl@0: 	TWindowServerEvent::SendGroupListChangedEvents();
sl@0: 	}
sl@0: 
sl@0: void CScreen::RemoveFromDefaultOwningList(CWsWindowGroup *aDestroyedGroup)
sl@0: 	{
sl@0: 	for (CWsWindowGroup **group=&iDefaultOwningWindow;*group;group=(*group)->NextDefaultOwningWindowPtr())
sl@0: 		{
sl@0: 		if (*group==aDestroyedGroup)
sl@0: 			{
sl@0: 			*group=*aDestroyedGroup->NextDefaultOwningWindowPtr();
sl@0: 			break;
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CScreen::SetDefaultOwningWindow(CWsWindowGroup *aGroup)
sl@0: 	{
sl@0: 	RemoveFromDefaultOwningList(aGroup);
sl@0: 	aGroup->SetNextDefaultOwningWindow(iDefaultOwningWindow);
sl@0: 	iDefaultOwningWindow=aGroup;
sl@0: 	}
sl@0: 
sl@0: void CScreen::GetScanLine(const TWsSdCmdGetScanLine *aGetScanLine)
sl@0: 	{
sl@0: 	TRgb buf[EGetScanLineBufLen];
sl@0: 	TPtr8 des((TUint8 *)&buf[0],EGetScanLineBufLen*sizeof(TRgb));
sl@0: 	TPoint pos(aGetScanLine->pos);
sl@0: 	TInt read=0;
sl@0: 	TInt len=(des.MaxLength()*EGetScanLineBufLen)/CFbsBitmap::ScanLineLength(EGetScanLineBufLen,aGetScanLine->dispMode);
sl@0: 	if (aGetScanLine->len < 0 || (CFbsBitmap::ScanLineLength(aGetScanLine->len, aGetScanLine->dispMode) >
sl@0: 									CWsClient::CurrentClient()->ClientMessage().GetDesMaxLength(1)))
sl@0: 		{
sl@0: 		CWsClient::PanicCurrentClient(EWservPanicInvalidParameter);
sl@0: 		}
sl@0: 	FOREVER
sl@0: 		{
sl@0: 		if ((aGetScanLine->len-read)<len)
sl@0: 			len=aGetScanLine->len-read;
sl@0: 		iScreenDevice->GetScanLine(des,pos,len,aGetScanLine->dispMode);
sl@0: 		CWsClient::ReplyBuf(des);
sl@0: 		read+=len;
sl@0: 		if (read==aGetScanLine->len)
sl@0: 			break;
sl@0: 		pos.iX+=len;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CScreen::MaxNumColors(TInt& aColors,TInt& aGrays)
sl@0: 	{
sl@0: 	aGrays=0;
sl@0: 	aColors=TDisplayModeUtils::NumDisplayModeColors(DisplayMode());
sl@0: 	if (!TDisplayModeUtils::IsDisplayModeColor(DisplayMode()))
sl@0: 		{
sl@0: 		aGrays=aColors;
sl@0: 		aColors=0;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: #define MODE_TO_FLAG(x) 1<<(x-1)
sl@0: #define ROTATION_TO_FLAG(x) 1<<x
sl@0: const TUint allRotationsMask = ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationNormal)
sl@0: 						| ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationRotated90)
sl@0: 						| ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationRotated180)
sl@0: 						| ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationRotated270);
sl@0: const TUint KRotation0_180Mask = ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationNormal)
sl@0: 						| ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationRotated180);
sl@0: const TUint KRotation90_270Mask = ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationRotated90)
sl@0: 						| ROTATION_TO_FLAG(CFbsBitGc::EGraphicsOrientationRotated270);
sl@0: TInt CScreen::ColorModesFlag()
sl@0: 	{
sl@0: 	return MODE_TO_FLAG(DisplayMode());
sl@0: 	}
sl@0: 
sl@0: void CScreen::UpdateDsa()
sl@0: 	{
sl@0: 	if(iDsaDevice)
sl@0: 		{
sl@0: 		#if defined(__WINS__) && defined(_DEBUG)
sl@0: 			if (iDebugWin)
sl@0: 				iDebugWin->Refresh(iDsaDevice->SizeInPixels(), iDsaDevice->DisplayMode(), iDsaDevice->Bits());
sl@0: 		#endif
sl@0: 		
sl@0: 		iDsaDevice->Update();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: const CGraphicsDeviceMap& CScreen::DeviceMap() const
sl@0: 	{
sl@0: 	return *iDeviceMap;
sl@0: 	}
sl@0: 
sl@0: const MWsScreenDevice& CScreen::ScreenDevice() const
sl@0: 	{
sl@0: 	return *iScreenDevice; 
sl@0: 	}
sl@0: 
sl@0: void CScreen::SetPointerCursorArea(TInt aMode,const TRect& aRect)
sl@0: 	{
sl@0: 	(*iModes)[aMode]->iPointerCursorArea=aRect;
sl@0: 	(*iModes)[aMode]->iFlags |= EClientDefinedDigitiserArea;
sl@0: 	TWsPointer::SetPointerCursorPos(TWsPointer::PointerCursorPos());
sl@0: 	}
sl@0: 
sl@0: CFbsBitGc::TGraphicsOrientation CScreen::Orientation() const
sl@0: 	{
sl@0:   	WS_ASSERT_DEBUG(IsValidScreenSizeMode(iScreenSizeMode),EWsPanicInvalidScreenSizeMode);
sl@0: 	return (*iModes)[iScreenSizeMode]->iRotation;
sl@0: 	}
sl@0: 
sl@0: TRect CScreen::DrawableArea() const
sl@0: 	{
sl@0: 	TRect drawRect=iScreenDevice->SizeInPixels();
sl@0: 	if (iDisplayMapping)
sl@0: 		{
sl@0: 		iDisplayMapping->MapCoordinates(EFullScreenSpace,drawRect,EApplicationSpace,drawRect);                   
sl@0: 		}
sl@0: 	return drawRect;
sl@0: 	}
sl@0: 
sl@0: TClientPanic CScreen::SetModeRotation(TInt aMode,CFbsBitGc::TGraphicsOrientation aRotation)
sl@0: 	{
sl@0: 	if (!IsValidScreenSizeMode(aMode))
sl@0: 		return EWservPanicScreenModeNumber;
sl@0: 	TSizeMode& mode=*(*iModes)[aMode];
sl@0: 	if (!(ROTATION_TO_FLAG(aRotation)&mode.iAlternativeRotations))
sl@0: 		return EWservPanicRotation;
sl@0: 	CFbsBitGc::TGraphicsOrientation oldRotation=mode.iRotation;
sl@0: 	mode.iRotation=aRotation;
sl@0: 	CWsWindowGroup::NewOrientation(aMode,aRotation, iRootWindow);
sl@0: 	if (aMode==ScreenSizeMode())
sl@0: 		{
sl@0: 		if(iDisplayPolicy && iDisplayControl && (mode.iAlternativeRotations == allRotationsMask))
sl@0: 			{
sl@0: 			//square mode supports all 4 rotations. We'd better do a complete Setconfiguration
sl@0: 			//all parameters are recalculated for 90 degree rotation
sl@0: 			//The most important one is the offset, since we need to re-center the appmode and it's a policy behaviour
sl@0: 			TDisplayConfiguration config;
sl@0: 			iDisplayControl->GetConfiguration(config);
sl@0: 			//update rotation
sl@0: 			config.SetRotation((TDisplayConfiguration::TRotation)aRotation);
sl@0: 			SetConfiguration(config);
sl@0: 			}
sl@0: 		else if (!UpdateOrientation())
sl@0: 			{
sl@0: 			// Roll back earlier change
sl@0: 			mode.iRotation=oldRotation;
sl@0: 			CWsWindowGroup::NewOrientation(aMode, oldRotation, iRootWindow);
sl@0: 			}
sl@0: 		}
sl@0: 	return EWservNoPanic;
sl@0: 	}
sl@0: 
sl@0: void CScreen::CycleDisplaySize()
sl@0: 	{
sl@0: 	TInt newMode = iScreenSizeMode;
sl@0: 	TSizeMode* sizeMode = NULL;
sl@0: 	do
sl@0: 		{
sl@0: 		newMode = (newMode+1)%iModes->Count();
sl@0: 		sizeMode = (*iModes)[newMode];
sl@0: 		}
sl@0: 	while (sizeMode==NULL);
sl@0: 	doSetScreenMode(newMode);
sl@0: 	}
sl@0: 
sl@0: void CScreen::doSetScreenMode(TInt aMode,TBool aInsideStartup)
sl@0: 	{
sl@0:   	WS_ASSERT_DEBUG(IsValidScreenSizeMode(aMode),EWsPanicInvalidScreenSizeMode);
sl@0:  	TWindowServerEvent::NotifyDrawer(TWservCrEvent(TWservCrEvent::EScreenSizeModeAboutToChange, aMode));
sl@0: 	
sl@0: 	if (iDisplayControl && iDisplayPolicy)
sl@0: 		{
sl@0: 		TDisplayConfiguration config;
sl@0: 		TRect sizeModePosition;
sl@0: 		TInt error;
sl@0: 		TSizeMode& mode=*(*iModes)[aMode];
sl@0: 		config.SetRotation((TDisplayConfiguration::TRotation)mode.iRotation);
sl@0: 		//This will return suitable config when display is connected
sl@0: 		//and UI size equal to smallest appmode when disconnected
sl@0: 		error = iDisplayPolicy->GetSizeModeConfiguration(aMode,config,sizeModePosition);
sl@0: 		//set appmode in policy
sl@0: 		if (iDisplayMapping)
sl@0: 			{
sl@0: 			iDisplayMapping->SetSizeModeExtent(sizeModePosition,MWsDisplayMapping::KOffsetAll);
sl@0: 			}
sl@0: 		MWsScene::TSceneRotation oldRotation;
sl@0: 		TSize newUiSize;
sl@0: 		config.GetResolution(newUiSize);
sl@0: 		if (error == KErrNone)
sl@0: 			{
sl@0: 			oldRotation = iScene->SceneRotation();
sl@0: 			//The config info will always be set in policy. If display is connected, policy will have
sl@0: 			//correct composition, Ui and app res. otherwise Ui and appmode will be both set to smallest
sl@0: 			//app mode, composition will be set to zero
sl@0: 			if (iFlags&EHasDynamicSizeModes)
sl@0: 				{
sl@0: 				error = iFallbackMap->Resize(newUiSize);
sl@0: 				}
sl@0: 			if (error == KErrNone)
sl@0: 				{
sl@0: 				error = iDisplayControl->SetConfiguration(config);
sl@0: 				}
sl@0: 			}
sl@0: 		if (error == KErrNone)
sl@0: 			{
sl@0: 			UpdateDynamicScreenModes();
sl@0: 			AbortAllDirectDrawing(RDirectScreenAccess::ETerminateScreenMode);
sl@0: 
sl@0: 			if(iDsaDevice && iDsaDevice->GraphicsAccelerator())
sl@0: 				{
sl@0: 				iDsaDevice->ChangeScreenDevice(iDsaDevice); // orientation has changed, therefore we need to re-initialise the screen device's graphics accelerator
sl@0: 				}
sl@0: 
sl@0: 			iScreenSizeMode=aMode;
sl@0: 			//This could fail (to set orientation on the context, or to register the rotated DSA).
sl@0: 			//Previously, the update rotation was deferred, leaving the size mode out of step with the actual rotation
sl@0: 			//It also returns false if the orientation is "intentionally" not modified.
sl@0: 			(void) UpdateOrientation(&oldRotation);	
sl@0: 			
sl@0: 			//SetDigitiserAreas needs revisiting if/when we support dynamic resolutions
sl@0:             //on a screen with touch input.
sl@0:             //SetDigitiserAreas(newUiSize);
sl@0: 			
sl@0: 			CWsWindowGroup::SetScreenDeviceValidStates(this);
sl@0: 			
sl@0: 			if (!aInsideStartup)
sl@0: 				{
sl@0: 				iWindowElementSet->ResubmitAllElementExtents();
sl@0: 				//TODO jonas: we'd like to not have to clear at all... make the actual change to compositor etc lazily!
sl@0: 				if(BlankScreenOnRotation())
sl@0: 					{
sl@0: 					iRootWindow->ClearDisplay();
sl@0: 					}
sl@0: 	
sl@0: 				CWsTop::ClearAllRedrawStores();
sl@0: 				DiscardAllSchedules();
sl@0: 				iRootWindow->InvalidateWholeScreen();
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		if (iDisplayMapping)
sl@0: 			{
sl@0: 			TRect sizeModePosition;
sl@0: 			TRAPD(err,sizeModePosition=TRect(OriginL(aMode),ScreenModeSizeInPixelsL(aMode)));
sl@0: 			if (err==KErrNone)
sl@0: 				{
sl@0: 				iDisplayMapping->SetSizeModeExtent(sizeModePosition,MWsDisplayMapping::KOffsetAll);
sl@0: 				}
sl@0: 			}
sl@0: 		if (!aInsideStartup && (*iModes)[aMode]->iOrigin != (*iModes)[iScreenSizeMode]->iOrigin)
sl@0: 			{
sl@0: 			iWindowElementSet->ResubmitAllElementExtents();
sl@0: 			if ((*iModes)[aMode]->iRotation == (*iModes)[iScreenSizeMode]->iRotation)
sl@0: 				{
sl@0: 				//TODO jonas: we'd like to not have to clear at all... make the actual change to compositor etc lazily!
sl@0: 				if(BlankScreenOnRotation())
sl@0: 					{
sl@0: 					iRootWindow->ClearDisplay();
sl@0: 					}
sl@0: 	
sl@0: 				CWsTop::ClearAllRedrawStores();
sl@0: 				DiscardAllSchedules();
sl@0: 				iRootWindow->InvalidateWholeScreen();
sl@0: 				}
sl@0: 			}
sl@0: 		iScreenSizeMode=aMode;
sl@0: 		//This could fail (to set orientation on the context, or to register the rotated DSA).
sl@0: 		//Previously, the update rotation was deferred, leaving the size mode out of step with the actual rotation
sl@0: 		//It also returns false if the orientation is not modified.
sl@0: 		(void)UpdateOrientation();
sl@0: 		CWsWindowGroup::SetScreenDeviceValidStates(this);
sl@0: 		}
sl@0: 	TWindowServerEvent::SendScreenDeviceChangedEvents(this);
sl@0: 	ResetFocus(NULL);
sl@0: 	}
sl@0: 
sl@0: void CScreen::CycleOrientation()
sl@0: 	{
sl@0:   	WS_ASSERT_DEBUG(IsValidScreenSizeMode(iScreenSizeMode),EWsPanicInvalidScreenSizeMode);
sl@0: 	TSizeMode& currentSizeMode=*(*iModes)[iScreenSizeMode];
sl@0: 	TUint rotations=currentSizeMode.iAlternativeRotations;
sl@0: 	TInt currentRotation=currentSizeMode.iRotation;
sl@0: 	TInt rotation=currentRotation+1;
sl@0: 	while (rotation!=currentRotation)
sl@0: 		{
sl@0: 		if (rotation>CFbsBitGc::EGraphicsOrientationRotated270)
sl@0: 			rotation=CFbsBitGc::EGraphicsOrientationNormal;
sl@0: 		if (ROTATION_TO_FLAG(rotation)&rotations)
sl@0: 			break;
sl@0: 		++rotation;
sl@0: 		}
sl@0: 	if (rotation==currentRotation)
sl@0: 		{
sl@0: 		if (rotation>CFbsBitGc::EGraphicsOrientationRotated90)
sl@0: 			rotation-=2;
sl@0: 		else
sl@0: 			rotation+=2;
sl@0: 		}
sl@0: 	currentSizeMode.iRotation=REINTERPRET_CAST(CFbsBitGc::TGraphicsOrientation&,rotation);
sl@0: 	CWsWindowGroup::NewOrientation(iScreenSizeMode,currentSizeMode.iRotation, iRootWindow);
sl@0: 
sl@0: 	if (!UpdateOrientation())
sl@0: 		{
sl@0: 		// Roll back earlier changes
sl@0: 		currentSizeMode.iRotation=REINTERPRET_CAST(CFbsBitGc::TGraphicsOrientation&,currentRotation);
sl@0: 		CWsWindowGroup::NewOrientation(iScreenSizeMode, currentSizeMode.iRotation, iRootWindow);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  * This method is called either when switching screen size mode, or when the 
sl@0:  * orientation of the currently active screen size mode is changed.
sl@0:  */
sl@0: TBool CScreen::UpdateOrientation(MWsScene::TSceneRotation* aOldRotation)
sl@0: 	{
sl@0: 	CFbsBitGc::TGraphicsOrientation gcOrientation = Orientation();
sl@0: 
sl@0: 	MWsScene::TSceneRotation oldRotation = aOldRotation? (*aOldRotation):(iScene->SceneRotation());
sl@0: 	MWsScene::TSceneRotation newRotation = GcToScreen(gcOrientation);
sl@0: 	TDeviceOrientation newDeviceOrientation = GcToDevice(gcOrientation);
sl@0: 
sl@0: 	// We have to disable the text cursor here while we are still in the
sl@0: 	// same orientation or offset as we drew it.
sl@0: 	RWsTextCursor* cursor = CWsTop::CurrentTextCursor();
sl@0: 	if (cursor)
sl@0: 		{
sl@0: 		cursor->Disable();
sl@0: 		}
sl@0: 	
sl@0: // Some of this method has to be done when changing mode even if not changing rotation
sl@0: 	TBool rotating=(oldRotation != newRotation);
sl@0: 	if (rotating)
sl@0: 		{
sl@0: 	
sl@0: 		// Set the new screen rotation and update the UI element extent
sl@0: 		if (iScene->SetSceneRotation(newRotation) != KErrNone)
sl@0: 			return EFalse;
sl@0: 		// Set the new orientation for the DSA device and update the DSA surface
sl@0: 		if(iDsaDevice)
sl@0: 			{
sl@0: 			iDsaDevice->SetDeviceOrientation(newDeviceOrientation);
sl@0: 	
sl@0: 			TSurfaceId newSurface;
sl@0: 			iDsaDevice->GetSurface(newSurface);
sl@0: 			TInt errRegister = iScene->RegisterSurface(newSurface);
sl@0: 			WS_ASSERT_DEBUG(KErrNone == errRegister, EWsPanicDirectScreenAccess);
sl@0: 			// This will remove all the DSA elements from the scene
sl@0:             AbortAllDirectDrawing(RDirectScreenAccess::ETerminateRotation);
sl@0: 	
sl@0: 			TInt errUnregister = iScene->UnregisterSurface(iDsaSurface);
sl@0: 			WS_ASSERT_DEBUG(KErrNone == errUnregister, EWsPanicDirectScreenAccess);
sl@0: 			iDsaSurface = newSurface;
sl@0: 			}
sl@0: 		
sl@0: 		//updaterotation should not fail after this point (no cleanup)
sl@0: 			
sl@0:         //update the last set config with the new rotation change so we don't incorrectly
sl@0:         //change the layer extents
sl@0:         if (iDisplayControl)
sl@0:             {
sl@0:             TDisplayConfiguration config;
sl@0:             config.SetRotation(static_cast<TDisplayConfiguration::TRotation>(newRotation));           
sl@0:             iConfigChangeNotifier->UpdateLastSetConfiguration(config);
sl@0:             }		
sl@0: 		
sl@0: 		TWservCrEvent crEvent(TWservCrEvent::EDeviceOrientationChanged,iScreenNumber,&gcOrientation);
sl@0: 		TWindowServerEvent::NotifyDrawer(crEvent);
sl@0: 		
sl@0: 		if(iDsaDevice && iDsaDevice->GraphicsAccelerator())
sl@0: 			{
sl@0: 			iDsaDevice->ChangeScreenDevice(iDsaDevice); // orientation has changed, therefore we need to re-initialise the screen device's graphics accelerator
sl@0: 			}
sl@0: 		
sl@0: 		}
sl@0: 	
sl@0: 	iRootWindow->AdjustCoordsDueToRotation();
sl@0: 	if (rotating)
sl@0: 		{
sl@0: 		if(BlankScreenOnRotation())
sl@0: 			{
sl@0: 			iRootWindow->ClearDisplay();
sl@0: 			}
sl@0: 		
sl@0: 		CWsTop::ClearAllRedrawStores();	
sl@0: 		DiscardAllSchedules();
sl@0: 		iRootWindow->InvalidateWholeScreen();
sl@0: 		}
sl@0: 	return ETrue;
sl@0: 	}
sl@0: 
sl@0: TPoint CScreen::PhysicalToLogical(TPoint aPhysicalPt)
sl@0: 	{
sl@0: 	const TSizeMode& mode=ScreenSizeModeData();
sl@0: 	TPoint logicalPt;
sl@0: 	if(!iDisplayMapping)
sl@0: 		{
sl@0: 		//old behaviour
sl@0: 		logicalPt=aPhysicalPt-mode.iOrigin;
sl@0: 		if (mode.iScreenScale.iWidth!=1)
sl@0: 			logicalPt.iX=(logicalPt.iX>=0 ? logicalPt.iX/mode.iScreenScale.iWidth : (logicalPt.iX-(mode.iScreenScale.iWidth-1))/mode.iScreenScale.iWidth);
sl@0: 		if (mode.iScreenScale.iHeight!=1)
sl@0: 			logicalPt.iY=(logicalPt.iY>=0 ? logicalPt.iY/mode.iScreenScale.iHeight : (logicalPt.iY-(mode.iScreenScale.iHeight-1))/mode.iScreenScale.iHeight);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		//rect with dummy size for coordinates mapping purpose
sl@0: 		TRect rectInComp(aPhysicalPt, TSize(1,1));
sl@0: 		TRect rectInApp;
sl@0: 		iDisplayMapping->MapCoordinates(ECompositionSpace, rectInComp, EApplicationSpace,rectInApp);
sl@0: 		logicalPt = rectInApp.iTl;
sl@0: 		}
sl@0: 	
sl@0: 	return logicalPt;
sl@0: 	}
sl@0: 
sl@0: void CScreen::LoadScreenSizesL(TSize aScreenSize)
sl@0: 	{
sl@0: 	_LIT(KWSERVNumScrSizeMode, "NUMSCREENMODES");
sl@0: 	TBool allowScrGap=WsIniFile->FindVar(iScreenNumber, KWSERVNumScrSizeMode, iNumScreenSizeModes);
sl@0: 	iModes=new(ELeave) RPointerArray<TInternalSizeMode>(1);
sl@0: 	WS_ASSERT_DEBUG(!allowScrGap || (allowScrGap && iNumScreenSizeModes>0), EWsPanicInvalidScreenSizeMode);
sl@0: 	TInt screenNum=0;
sl@0: 	FOREVER
sl@0: 		{
sl@0: 		++screenNum;
sl@0: 		TBuf<32> varNameWidth;
sl@0: 		TBuf<32> varNameHeight;
sl@0: 		_LIT(KWSERVScreenWidthPattern,"SCR_WIDTH%d");
sl@0: 		varNameWidth.Format(KWSERVScreenWidthPattern,screenNum);
sl@0: 		_LIT(KWSERVScreenHeightPattern,"SCR_HEIGHT%d");
sl@0: 		varNameHeight.Format(KWSERVScreenHeightPattern,screenNum);
sl@0: 		TSize screenSize;
sl@0: 		if (!WsIniFile->FindVar(iScreenNumber, varNameWidth, screenSize.iWidth) ||
sl@0: 			!WsIniFile->FindVar(iScreenNumber, varNameHeight, screenSize.iHeight))
sl@0: 			{
sl@0: 			if (allowScrGap && screenNum<=iNumScreenSizeModes)
sl@0: 				{
sl@0: 				iModes->AppendL(NULL);
sl@0: 				continue;
sl@0: 				}
sl@0: 			else
sl@0: 				break;
sl@0: 			}
sl@0: 		TInt flags=0;
sl@0: 		if (screenSize.iWidth==0 && screenSize.iHeight==0)
sl@0: 			{
sl@0: 			screenSize=aScreenSize;
sl@0: 			flags|=EHalDefault;
sl@0: 			}
sl@0: 		if (screenSize.iWidth==-1 && screenSize.iHeight==-1)
sl@0: 			{
sl@0: 			screenSize=aScreenSize;
sl@0: 			flags|=EDynamic;
sl@0: 			iFlags|=EHasDynamicSizeModes;
sl@0: 			}
sl@0: 		TInternalSizeMode* newSizeMode=new(ELeave) TInternalSizeMode(screenSize);
sl@0: 		newSizeMode->iFlags|=flags;
sl@0: 		CleanupStack::PushL(newSizeMode);
sl@0: 		iModes->AppendL(newSizeMode);
sl@0: 		CleanupStack::Pop(newSizeMode);
sl@0: 		++iNumSupportedScreenSizeModes;
sl@0: 		}
sl@0: 	// If sparse index is enabled and no screen size mode defined, all iModes entries will be NULL
sl@0: 	// Otherwise iModes will be empty
sl@0: 	if (iModes->Count()==0 || iNumSupportedScreenSizeModes==0)
sl@0: 		{
sl@0: 		TInternalSizeMode* defaultSizeMode=new(ELeave) TInternalSizeMode(aScreenSize);
sl@0: 		defaultSizeMode->iFlags|=EHalDefault;
sl@0: 		if (iModes->Count()>0)
sl@0: 			(*iModes)[0]=defaultSizeMode;
sl@0: 		else
sl@0: 			{
sl@0: 			CleanupStack::PushL(defaultSizeMode);
sl@0: 			iModes->AppendL(defaultSizeMode);
sl@0: 			CleanupStack::Pop(defaultSizeMode);
sl@0: 			}
sl@0: 		++iNumSupportedScreenSizeModes;
sl@0: 		}
sl@0: 	if (!allowScrGap)
sl@0: 		iNumScreenSizeModes=iNumSupportedScreenSizeModes;
sl@0: 	}
sl@0: 
sl@0: void CScreen::LoadScreenRotationProperties(TInternalSizeMode& aMode, const TInt aModeIndex)
sl@0: 	{
sl@0: 	TBuf<32> varRotation;
sl@0: 	_LIT(KWSERVScreenRotationPattern,"SCR_ROTATION%d");
sl@0: 	varRotation.Format(KWSERVScreenRotationPattern,aModeIndex+1);		
sl@0: 	TInt rotation=CFbsBitGc::EGraphicsOrientationNormal;
sl@0: 	TUint allRotations=0;
sl@0: 	TPtrC rotList(NULL,0);
sl@0: 	if (WsIniFile->FindVar( iScreenNumber, varRotation,rotList))
sl@0: 		{
sl@0: 		TLex lex(rotList);
sl@0: 		TBool foundOne=EFalse;
sl@0: 		TInt rot;
sl@0: 
sl@0: 		while (!lex.Eos())
sl@0: 			{
sl@0: 			if (!FindNextValue(lex, rot))
sl@0: 				{
sl@0: 				break;
sl@0: 				}
sl@0: 			if (rot<0 || rot>360)
sl@0: 				{
sl@0: 				continue;
sl@0: 				}
sl@0: 			if (rot>4)
sl@0: 				{
sl@0: 				rot/=90;
sl@0: 				}
sl@0: 			if (!foundOne)
sl@0: 				{
sl@0: 				rotation=rot;
sl@0: 				foundOne=ETrue;
sl@0: 				}
sl@0: 			if (rot<=CFbsBitGc::EGraphicsOrientationRotated270)
sl@0: 				{
sl@0: 				allRotations|=ROTATION_TO_FLAG(rot);
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	if (allRotations==0)
sl@0: 		allRotations=ROTATION_TO_FLAG(rotation);
sl@0: 	const TInt KAllRotationsMask = 0xF;	//Used to keep the old behaviour
sl@0: 	WS_ASSERT_ALWAYS((ROTATION_TO_FLAG(rotation)&KAllRotationsMask)>0, EWsPanicFailedToInitialise);
sl@0: 	aMode.iRotation=reinterpret_cast<CFbsBitGc::TGraphicsOrientation&>(rotation);
sl@0: 	aMode.iAlternativeRotations=allRotations&KAllRotationsMask;
sl@0: 	}
sl@0: 
sl@0: void CScreen::LoadScreenTwipsProperties(TInternalSizeMode& aMode, const TInt aModeIndex)
sl@0: 	{
sl@0: 	TBuf<32> varNameWidth;
sl@0: 	_LIT(KWSERVScreenTwipWidthPattern,"SCR_TWIP_WIDTH%d");
sl@0: 	varNameWidth.Format(KWSERVScreenTwipWidthPattern,aModeIndex+1);
sl@0: 	TBuf<32> varNameHeight;
sl@0: 	_LIT(KWSERVScreenTwipHeightPattern,"SCR_TWIP_HEIGHT%d");
sl@0: 	varNameHeight.Format(KWSERVScreenTwipHeightPattern,aModeIndex+1);
sl@0: 
sl@0: 	TSize twipsSize;
sl@0: 	TBool widthFound = WsIniFile->FindVar(iScreenNumber,varNameWidth,twipsSize.iWidth);
sl@0: 	TBool heightFound = WsIniFile->FindVar(iScreenNumber,varNameHeight,twipsSize.iHeight);	
sl@0: 	
sl@0: 	// if either of the width or height wsini reads has failed we need to generate default values
sl@0: 	switch(aMode.iRotation)
sl@0: 		{
sl@0: 		// CFbsBitGc::TGraphicsOrientation
sl@0: 		case CFbsBitGc::EGraphicsOrientationRotated90:	// deliberate drop-through
sl@0: 		case CFbsBitGc::EGraphicsOrientationRotated270:
sl@0: 			{
sl@0: 			// CFbsScreenDevice knows nothing about rotation, so we can't use it's PixelsTo Twips methods
sl@0: 			// So swap the axis here to use the correct twips per pixel ratio
sl@0: 			if (!widthFound)
sl@0: 				twipsSize.iWidth = DeviceMap().VerticalPixelsToTwips(aMode.iScreenSize.iWidth);
sl@0: 			if (!heightFound)
sl@0: 				twipsSize.iHeight = DeviceMap().HorizontalPixelsToTwips(aMode.iScreenSize.iHeight);	
sl@0: 			break;
sl@0: 			}
sl@0: 		case CFbsBitGc::EGraphicsOrientationNormal:		// deliberate drop-through
sl@0: 		case CFbsBitGc::EGraphicsOrientationRotated180:
sl@0: 			if (!widthFound)
sl@0: 				twipsSize.iWidth = DeviceMap().HorizontalPixelsToTwips(aMode.iScreenSize.iWidth);
sl@0: 			if (!heightFound)
sl@0: 				twipsSize.iHeight = DeviceMap().VerticalPixelsToTwips(aMode.iScreenSize.iHeight);
sl@0: 			break;
sl@0: 		default:
sl@0: 			RDebug::Print(_L("** CScreen::LoadScreenTwipsProperties Panic"));
sl@0: 			WS_PANIC_ALWAYS(EWsPanicFailedToInitialise);
sl@0: 			break;			
sl@0: 		}
sl@0: 	if (widthFound&&heightFound)
sl@0: 		{
sl@0: 		aMode.iFlags|=this->ETwipsSpecified;
sl@0: 		}
sl@0: 	aMode.iScreenTwipsSize=twipsSize;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: void CScreen::LoadScreenSizeProperties(TDisplayMode aDefaultDisplayMode)
sl@0: 	{
sl@0: 	for(TInt sizeLoop=0;sizeLoop<iModes->Count();sizeLoop++)
sl@0: 		{
sl@0: 		TInternalSizeMode* modePtr=(*iModes)[sizeLoop];
sl@0: 		if (!modePtr)
sl@0: 			continue;
sl@0: 		TInternalSizeMode& mode=*modePtr;
sl@0: 		TBuf<32> varDisplayMode;
sl@0: 		_LIT(KWSERVScreenDisplayModePattern,"SCR_WINDOWMODE%d");
sl@0: 		
sl@0: 		varDisplayMode.Format(KWSERVScreenDisplayModePattern,sizeLoop+1);
sl@0: 		mode.iScreenScale.iWidth=1;
sl@0: 		mode.iScreenScale.iHeight=1;
sl@0: 
sl@0: 		TBuf<32> varLeft;
sl@0: 		TBuf<32> varTop;
sl@0: 		_LIT(KWSERVScreenLeftPattern,"SCR_LEFT%d");
sl@0: 		_LIT(KWSERVScreenTopPattern,"SCR_TOP%d");
sl@0: 		varLeft.Format(KWSERVScreenLeftPattern,sizeLoop+1);
sl@0: 		varTop.Format(KWSERVScreenTopPattern,sizeLoop+1);
sl@0: 		if (!WsIniFile->FindVar( iScreenNumber, varLeft,mode.iOrigin.iX))
sl@0: 			mode.iOrigin.iX=0;
sl@0: 		if (!WsIniFile->FindVar( iScreenNumber, varTop,mode.iOrigin.iY))
sl@0: 			mode.iOrigin.iY=0;
sl@0: 			
sl@0: 		TPtrC displayModeName(NULL,0);
sl@0: 		mode.iDefaultDisplayMode = aDefaultDisplayMode;
sl@0: 		// must know rotation before parsing twips
sl@0: 		LoadScreenRotationProperties(mode, sizeLoop);
sl@0: 		LoadScreenTwipsProperties(mode, sizeLoop);
sl@0: 		
sl@0: 		
sl@0: 		if(mode.iScreenSize.iWidth == mode.iScreenSize.iHeight && mode.iAlternativeRotations == allRotationsMask)
sl@0: 			{
sl@0: 			//square appmode with all four rotations allowed must have square twipsize
sl@0: 			if((mode.iFlags&ETwipsSpecified) && mode.iScreenTwipsSize.iWidth != mode.iScreenTwipsSize.iHeight)
sl@0: 				{
sl@0: 				RDebug::Print(_L("**Panic: Square appmode with all four rotations must have square twip size"));
sl@0: 				WS_PANIC_ALWAYS(EWsPanicFailedToInitialise);
sl@0: 				}
sl@0: 			//square appmode with all four rotations allowed must have square offset
sl@0: 			if(mode.iOrigin.iX != mode.iOrigin.iY)
sl@0: 				{
sl@0: 				RDebug::Print(_L("**Panic: Square appmode with all four rotations must have square offset"));
sl@0: 				WS_PANIC_ALWAYS(EWsPanicFailedToInitialise);
sl@0: 				}
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			//Everything else is treated as rectangle appmode. Square appmode not supporting all 4 rotations is considered
sl@0: 			//as rectangle appmode as well. Rectangle appmode suports 2 rotations at most (0 and 180, or 90 and 270)
sl@0: 			//first rotation of the appmode is taken to apply the corresponding rotation mask
sl@0: 			if(!((mode.iAlternativeRotations&KRotation0_180Mask) == mode.iAlternativeRotations
sl@0: 					|| (mode.iAlternativeRotations&KRotation90_270Mask) == mode.iAlternativeRotations))
sl@0: 				{
sl@0: 				RDebug::Print(_L("**Panic_DEBUG: non square appmode can only define (0,180) or (90,270) rotations"));
sl@0: 				WS_PANIC_DEBUG(EWsPanicFailedToInitialise);
sl@0: 				//in relase build, no panic, just correct the rotations set
sl@0: 
sl@0: 				}
sl@0: 			//correct the rotations set
sl@0: 			mode.iAlternativeRotations &= ((ROTATION_TO_FLAG(mode.iRotation) & KRotation0_180Mask)? KRotation0_180Mask:
sl@0: 												KRotation90_270Mask);
sl@0: 			}
sl@0: 			
sl@0: 		}
sl@0: //
sl@0: 	TInt intForFindVar=0;
sl@0: 	_LIT(KWSERVIniFileVarSizeMode,"SIZE_MODE");
sl@0: 	WsIniFile->FindVar( iScreenNumber, KWSERVIniFileVarSizeMode,intForFindVar);
sl@0: 	iSizeEnforcementMode=(TScreenModeEnforcement)intForFindVar;
sl@0: 	}
sl@0: 
sl@0: void CScreen::SetDigitiserAreas(const TSize& aUiSize)
sl@0: 	{  //aUiSize should be the unrotated current ui size
sl@0: 	//SetDigitiserAreas needs revisiting if/when we support dynamic resolutions on a screen 
sl@0:     //with touch input. It is not known how digitiser coordinates will be represented if the 
sl@0:     //physical display resolution changes. Currently digitisers are only supported on screen 0, 
sl@0:     //and dynamic resolution only applies to higher screen numbers on real hardware.
sl@0: 	for(TInt sizeLoop=0;sizeLoop<iModes->Count();sizeLoop++)
sl@0: 		{
sl@0: 		TInternalSizeMode* modePtr=(*iModes)[sizeLoop];
sl@0: 		if (!modePtr)
sl@0: 			continue;
sl@0: 		TInternalSizeMode& mode=*modePtr;
sl@0: 		if(mode.iFlags & EClientDefinedDigitiserArea)
sl@0: 			{
sl@0: 			//if it's client set, keep it unchanged.
sl@0: 			continue;
sl@0: 			}
sl@0: 		switch (mode.iRotation)
sl@0: 			{
sl@0: 			case CFbsBitGc::EGraphicsOrientationNormal:
sl@0: 				mode.iPointerCursorArea=iDigitiserArea;
sl@0: 				continue;
sl@0: 			case CFbsBitGc::EGraphicsOrientationRotated90:
sl@0: 				mode.iPointerCursorArea.SetRect(iDigitiserArea.iTl.iY,aUiSize.iWidth-iDigitiserArea.iBr.iX,
sl@0: 																iDigitiserArea.iBr.iY,aUiSize.iWidth-iDigitiserArea.iTl.iX);
sl@0: 				break;
sl@0: 			case CFbsBitGc::EGraphicsOrientationRotated180:
sl@0: 				mode.iPointerCursorArea.SetRect(-(iDigitiserArea.iBr-aUiSize),-(iDigitiserArea.iTl-aUiSize));
sl@0: 				break;
sl@0: 			case CFbsBitGc::EGraphicsOrientationRotated270:
sl@0: 				mode.iPointerCursorArea.SetRect(aUiSize.iHeight-iDigitiserArea.iBr.iY,iDigitiserArea.iTl.iX,
sl@0: 				        aUiSize.iHeight-iDigitiserArea.iTl.iY,iDigitiserArea.iBr.iX);
sl@0: 				break;
sl@0: 			default:
sl@0: 			    WS_PANIC_ALWAYS(EWsPanicInvalidRotation);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CScreen::GetScreenSizeAndRotation(TPixelsTwipsAndRotation &aSar, TInt aScreenMode)
sl@0: 	{
sl@0: 	TSizeMode& mode=*(*iModes)[aScreenMode];
sl@0: 	aSar.iRotation=mode.iRotation;
sl@0: 	aSar.iPixelSize=mode.iScreenSize;
sl@0: 	aSar.iTwipsSize=mode.iScreenTwipsSize;
sl@0: 	if (aSar.iTwipsSize.iWidth==0)
sl@0: 		{
sl@0: 		aSar.iTwipsSize.iWidth  = iDeviceMap->HorizontalPixelsToTwips(aSar.iPixelSize.iWidth);
sl@0: 		aSar.iTwipsSize.iHeight = iDeviceMap->VerticalPixelsToTwips(aSar.iPixelSize.iHeight);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CScreen::GetScreenSizeAndRotation(TPixelsAndRotation &aSar, TInt aScreenMode)
sl@0: 	{
sl@0: 	TSizeMode& mode=*(*iModes)[aScreenMode];
sl@0: 	aSar.iRotation=mode.iRotation;
sl@0: 	aSar.iPixelSize=mode.iScreenSize;
sl@0: 	}
sl@0: 
sl@0: TBool CScreen::SetScreenModeEnforcement(TInt aMode)
sl@0: 	{
sl@0: 	if (aMode<0 || aMode>ESizeEnforcementPixelsTwipsAndRotation)
sl@0: 		return EFalse;
sl@0: 	TScreenModeEnforcement newMode=(TScreenModeEnforcement)aMode;
sl@0: 	if (newMode!=iSizeEnforcementMode)
sl@0: 		{
sl@0: 		iSizeEnforcementMode=newMode;
sl@0: 		CWsWindowGroup::SetScreenDeviceValidStates(this);
sl@0: 		ResetFocus(NULL);
sl@0: 		}
sl@0: 	return ETrue;
sl@0: 	}
sl@0: 
sl@0: void CScreen::IncContrast()
sl@0: 	{
sl@0: 	TInt contrast;
sl@0: 	if (iMaxContrast<0)			//If failed to get it sofar get it again
sl@0: 		TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::EContrast, HAL::Get(iScreenNumber,HALData::EDisplayContrastMax,iMaxContrast));
sl@0: 	if (TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::EContrast, HAL::Get(iScreenNumber,HALData::EDisplayContrast,contrast)))
sl@0: 		return;
sl@0: 	if (contrast==iMaxContrast)
sl@0: 		contrast=-1;
sl@0: 	TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::EContrast, HAL::Set(iScreenNumber,HALData::EDisplayContrast,++contrast));
sl@0: 	}
sl@0: 
sl@0: void CScreen::DecContrast()
sl@0: 	{
sl@0: 	TInt contrast;
sl@0: 	if (TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::EContrast, HAL::Get(iScreenNumber,HALData::EDisplayContrast,contrast)))
sl@0: 		return;
sl@0: 	if (contrast==0)
sl@0: 		{
sl@0: 		if (iMaxContrast<0 && TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::EContrast,
sl@0: 															HAL::Get(iScreenNumber,HALData::EDisplayContrastMax,iMaxContrast)))
sl@0: 			return;
sl@0: 		contrast=iMaxContrast+1;
sl@0: 		}
sl@0: 	TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::EContrast, HAL::Set(iScreenNumber,HALData::EDisplayContrast,--contrast));
sl@0: 	}
sl@0: 
sl@0: void CScreen::IncBrightness()
sl@0: 	{
sl@0: 	TInt brightness;
sl@0: 	if (iMaxBrightness<0)			//If failed to get it sofar get it again
sl@0: 		TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::EBackLight, HAL::Get(iScreenNumber,HALData::EDisplayBrightnessMax,iMaxBrightness));
sl@0: 	if (TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::EBackLight, HAL::Get(iScreenNumber,HALData::EDisplayBrightness,brightness)))
sl@0: 		return;
sl@0: 	if (brightness==iMaxBrightness)
sl@0: 		brightness=-1;
sl@0: 	TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::EBackLight, HAL::Set(iScreenNumber,HALData::EDisplayBrightness,++brightness));
sl@0: 	}
sl@0: 
sl@0: void CScreen::DecBrightness()
sl@0: 	{
sl@0: 	TInt brightness;
sl@0: 	if (TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::EBackLight, HAL::Get(iScreenNumber,HALData::EDisplayBrightness,brightness)))
sl@0: 		return;
sl@0: 	if (brightness==0)
sl@0: 		{
sl@0: 		if (iMaxBrightness<0 && TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::EBackLight,
sl@0: 													HAL::Get(iScreenNumber,HALData::EDisplayBrightnessMax,iMaxBrightness)))
sl@0: 			return;
sl@0: 		brightness=iMaxBrightness+1;
sl@0: 		}
sl@0: 	TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::EBackLight, HAL::Set(iScreenNumber,HALData::EDisplayBrightness,--brightness));
sl@0: 	}
sl@0: TInt CScreen::GetScreenSizeModeList(RArray<TInt>& aList) const
sl@0: 	{
sl@0: 	aList.Reset();
sl@0: 	TInt numModes=iNumScreenSizeModes;
sl@0: 	TInt err=aList.Reserve(numModes);
sl@0: 	if (err!=KErrNone)
sl@0: 		return err;
sl@0: 	TInt index;
sl@0: 	for (index=0; index<numModes; ++index)
sl@0: 		{
sl@0: 		TSizeMode* modePtr=(*iModes)[index];
sl@0: 		if (modePtr)
sl@0: 			aList.Append(index);	//Can't fail due to reserve
sl@0: 		}
sl@0: 	TInt count=aList.Count();
sl@0: 	return count;
sl@0: 	}
sl@0: 
sl@0: TInt CScreen::GetScreenSizeModeListL()
sl@0: 	{
sl@0: 	RArray<TInt> list;
sl@0: 	CleanupClosePushL(list);
sl@0: 	TInt count=GetScreenSizeModeList(list);
sl@0: 		User::LeaveIfError(count);
sl@0: 	CWsClient::ReplyBuf(&list[0], count*sizeof(TInt));
sl@0: 	CleanupStack::PopAndDestroy(&list);
sl@0: 	return count;
sl@0: 	}
sl@0: 
sl@0: void CScreen::SetInitialScreenSizeModeAndRotation()
sl@0: 	{	//Set first app mode that supports current supported rotations if available
sl@0: 	TInt index;
sl@0: 	TInt firstMode = -1;
sl@0: 	TInt bestMode = -1;
sl@0: 	// Since all screen rotation modes are supported.
sl@0: 	TBitFlags32 rotationFlags = CFbsBitGc::EGraphicsOrientationNormal|CFbsBitGc::EGraphicsOrientationRotated90|CFbsBitGc::EGraphicsOrientationRotated180|CFbsBitGc::EGraphicsOrientationRotated270;
sl@0: 	for (index=0; index<iModes->Count(); ++index)
sl@0: 		{
sl@0: 		TSizeMode* modePtr=(*iModes)[index];
sl@0: 		if (modePtr)
sl@0: 			{
sl@0: 			if (firstMode == -1)
sl@0: 				{
sl@0: 				firstMode = index;
sl@0: 				}
sl@0: 			if (rotationFlags.IsSet((TInt)modePtr->iRotation))
sl@0: 				{
sl@0: 				bestMode = index;
sl@0: 				break;
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	if (bestMode != -1)	//found a mode that supports current supported rotations
sl@0: 		{
sl@0: 		iScreenSizeMode = bestMode;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		if (firstMode != -1)	//could only find a mode that doesnt support current supported rotations
sl@0: 			{
sl@0: 			iScreenSizeMode = firstMode;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			return;	//couldn't find a mode at all
sl@0: 			}
sl@0: 		}
sl@0: 	if(iDisplayPolicy)
sl@0: 		{
sl@0: 		iDisplayPolicy->SetLastAppMode(iScreenSizeMode);
sl@0: 		}
sl@0: 
sl@0:     SetDigitiserAreas(iScreenDevice->SizeInPixels()); //unrotated size in pixels
sl@0:     
sl@0:     // Here we are mixing CFbsBitGc::TGraphicsOrientation with MWsScene::TSceneRotation
sl@0:     // As they both have same values it is fine for now
sl@0:     iScene->SetSceneRotation(GcToScreen(ScreenSizeModeData().iRotation)); //set rotation
sl@0: 	}
sl@0: 
sl@0: 
sl@0: TDisplayMode CScreen::FirstDefaultDisplayMode() const
sl@0: 	{
sl@0: 	TInt mode=-1;
sl@0: 	while ((*iModes)[++mode]==NULL)
sl@0: 		{
sl@0: 		WS_ASSERT_DEBUG(mode<iModes->Count()-1,EWsPanicInvalidScreenSizeMode);
sl@0: 		}
sl@0: 	return((*iModes)[mode]->iDefaultDisplayMode);
sl@0: 	}
sl@0: 
sl@0: void CScreen::AddRedrawRegion(const TRegion& aRegion, TBool aSchedule, TRedrawDepth aDepth)
sl@0: 	{
sl@0: 	iRedraw->AddRedrawRegion(aRegion, aSchedule, aDepth);
sl@0: 	}
sl@0: 
sl@0: void CScreen::ScheduleRender(const TTimeIntervalMicroSeconds& aFromNow)
sl@0: 	{
sl@0: 	iRedraw->ScheduleRender(aFromNow);
sl@0: 	}
sl@0: 
sl@0: void CScreen::DoRedrawNow()
sl@0: 	{
sl@0: 	iRedraw->DoRedrawNow();
sl@0: 	}
sl@0: 
sl@0: // See CScreenRedraw::IsUpdatePending() for important notes on usage.
sl@0: void CScreen::RedrawNowIfPending()
sl@0: 	{
sl@0: 	if(iRedraw->IsUpdatePending())
sl@0: 		DoRedrawNow();
sl@0: 	}
sl@0: 
sl@0: TBool CScreen::IsQuickFadeScheduled( CWsWindow* aWin ) const
sl@0: 	{
sl@0: 	return iRedraw->IsQuickFadeScheduled( aWin );
sl@0: 	}
sl@0: 
sl@0: void CScreen::RemoveFromQuickFadeList( CWsWindow* aWin )
sl@0: 	{
sl@0: 	iRedraw->RemoveFromQuickFadeList( aWin );
sl@0: 	}
sl@0: 
sl@0: void CScreen::AcceptFadeRequest( CWsWindow* aWin, TBool aIsFaded )
sl@0: 	{
sl@0: 	iRedraw->AcceptFadeRequest( aWin, aIsFaded );
sl@0: 	}
sl@0: 
sl@0: // implementing MWsScreen
sl@0: 
sl@0: const TTime& CScreen::Now() const
sl@0: 	{
sl@0: 	return iRedraw->Now();
sl@0: 	}
sl@0: 
sl@0: void CScreen::ScheduleAnimation(TAnimType aType, const TRect& aRect,const TTimeIntervalMicroSeconds& aFromNow,const TTimeIntervalMicroSeconds& aFreq,const TTimeIntervalMicroSeconds& aStop, CWsWindow* aWindow)
sl@0: 	{
sl@0: 	iRedraw->ScheduleAnimation(aType, aRect,aFromNow,aFreq,aStop, aWindow);
sl@0: 	}
sl@0: 
sl@0: TBool CScreen::IsScheduled(TAnimType aType, const TRect& aRect, CWsWindow* aWindow) const
sl@0: 	{
sl@0: 	return iRedraw->IsScheduled(aType, aRect, aWindow);
sl@0: 	}
sl@0: 
sl@0: void CScreen::OnAnimation(TRequestStatus* aFinished)
sl@0: 	{
sl@0: 	iRedraw->OnAnimation(aFinished);
sl@0: 	}
sl@0: 	
sl@0: void CScreen::Redraw()
sl@0: 	{
sl@0: 	STACK_REGION bounds;
sl@0: 	bounds.AddRect(DrawableArea());
sl@0: 	AddRedrawRegion(bounds);
sl@0: 	bounds.Close();
sl@0: 	}
sl@0: 
sl@0: TBool CScreen::RedrawInvalid(const TArray<TGraphicDrawerId>& aInvalid)
sl@0: 	{
sl@0: 	TBool wasDirty = EFalse;
sl@0: 	STACK_REGION bounds;
sl@0: 	bounds.AddRect(DrawableArea());
sl@0: 	STACK_REGION dirty;
sl@0: 	TWalkWindowTreeCalcInvalidGraphics calc(&bounds,dirty,aInvalid);
sl@0: 	if(calc.CreateSubRegion())
sl@0: 		{
sl@0: 		calc.CalcInvalid(*this);
sl@0: 		if(dirty.CheckError() || dirty.Count())
sl@0: 			{
sl@0: 			Redraw();
sl@0: 			wasDirty = ETrue;
sl@0: 			}
sl@0: 		calc.DestroyRegions();
sl@0: 		}
sl@0: 	dirty.Close();
sl@0: 	bounds.Close();
sl@0: 	return wasDirty;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Overidding MWsObjectProvider
sl@0: */
sl@0: TAny* CScreen::ResolveObjectInterface(TUint aTypeId)
sl@0: 	{
sl@0: 	TAny* interface = NULL;
sl@0: 
sl@0: 	switch (aTypeId)
sl@0: 		{
sl@0: 		case MWsWindow::EWsObjectInterfaceId:
sl@0: 			interface = static_cast<MWsWindow*>(RootWindow());
sl@0: 			break;
sl@0: 		case MWsScreenConfigList::EWsObjectInterfaceId:
sl@0: 			interface = static_cast<MWsScreenConfigList*>(this);
sl@0: 			break;
sl@0: 		case MWsScreenConfig::EWsObjectInterfaceId:
sl@0: 			interface = static_cast<MWsScreenConfig*>(this);
sl@0: 			break;
sl@0: 		case MWsWindowTree::EWsObjectInterfaceId:
sl@0: 			interface = static_cast<MWsWindowTree*>(this);
sl@0: 		}
sl@0: 
sl@0: 	if (!interface)
sl@0: 		interface = iRedraw->ResolveObjectInterface(aTypeId);
sl@0: 
sl@0: 	return interface;
sl@0: 	}
sl@0: 
sl@0: void CScreen::SendTree() const
sl@0: 	{
sl@0: 	if(!iWindowTreeObserver)
sl@0: 		return;
sl@0: 	
sl@0: 	TWalkWindowTreeSendState wtw(*iWindowTreeObserver);
sl@0: 	RootWindow()->WalkWindowTreeBackToFront(wtw, EVisitParentNodesFirst);
sl@0: 
sl@0: 	//Standard text cursors
sl@0: 	RWsTextCursor* cursor = CWsTop::CurrentTextCursor();
sl@0: 	if(cursor)
sl@0: 		cursor->SendState(*iWindowTreeObserver);
sl@0: 	
sl@0: 	//Floating Sprites	
sl@0: 	SpriteManager()->SendState(*iWindowTreeObserver);
sl@0: 	
sl@0: 	//Window Group Chains
sl@0: 	for(CWsWindowGroup *group=RootWindow()->Child(); group!=NULL; group=group->NextSibling())
sl@0: 		{
sl@0: 		group->SendStateWindowGroupChain(*iWindowTreeObserver);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TDisplayMode CScreen::DisplayMode() const
sl@0: 	{
sl@0: 	return iScreenDevice->DisplayMode();
sl@0: 	}
sl@0: 
sl@0: TSize CScreen::SizeInPixels() const
sl@0: 	{
sl@0: 	return iScreenDevice->SizeInPixels();
sl@0: 	}
sl@0: 
sl@0: TSize CScreen::SizeInTwips() const
sl@0: 	{
sl@0: 	return iScreenDevice->SizeInTwips();
sl@0: 	}
sl@0: 
sl@0: void CScreen::DiscardAllSchedules()
sl@0: 	{
sl@0: 	iRedraw->DiscardAllSchedules();
sl@0: 	}
sl@0: 
sl@0: void CScreen::ScheduleRegionUpdate(const TRegion* aDefinitelyDirty)
sl@0: 	{
sl@0: 	iRedraw->ScheduleRegionUpdate(aDefinitelyDirty);
sl@0: 	}
sl@0: 
sl@0: TBool CScreen::IsDSAClientWindow( const CWsClientWindow* aWin ) const
sl@0: 	{
sl@0: 	TBool res = EFalse; 
sl@0: 	if ( ! iDirects.IsEmpty() )
sl@0: 		{
sl@0: 		TSglQueIter<CWsDirectScreenAccess> iter( (TSglQueBase&)iDirects );
sl@0: 		iter.SetToFirst();
sl@0: 		CWsDirectScreenAccess* dsa;
sl@0: 		while ( (dsa = iter++) != NULL && !res )
sl@0: 			{
sl@0: 			res =  (dsa->ClientWindow() == aWin) && (dsa->IsVisible());
sl@0: 			}
sl@0: 		}
sl@0: 	return res;	
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Update the UI element composition method based on whether
sl@0: there are any externals surfaces present and the current display mode. 
sl@0: If the method changes, recomposition is triggered.
sl@0: */
sl@0: void CScreen::UpdateCompositionMode()
sl@0: 	{
sl@0: 	// do nothing
sl@0: 	}
sl@0: 
sl@0: void CScreen::ElementAdded()
sl@0: 	{
sl@0: 	UpdateCompositionMode();
sl@0: 	}
sl@0: 
sl@0: void CScreen::ElementRemoved()
sl@0: 	{
sl@0: 	UpdateCompositionMode();
sl@0: 	}
sl@0: 
sl@0: CRegisteredSurfaceMap* CScreen::SurfaceMap()
sl@0: 	{
sl@0: 	return iSurfaceMap;
sl@0: 	}
sl@0: 
sl@0: void CScreen::InitializeSceneL()
sl@0: 	{
sl@0: 	// Ensure the surface is not valid to start with.
sl@0: 	iDsaSurface = TSurfaceId::CreateNullId();
sl@0: 	iWindowElementSet = CWindowElementSet::NewL(*iScene);
sl@0: 	}
sl@0: 
sl@0: MWsElement* CScreen::CreateUiElementL(const TRect& aExtent)
sl@0: 	{
sl@0: 	MWsElement* pElement = iScene->CreateSceneElementL();
sl@0: 	
sl@0: 	TUint32 flags = 0;
sl@0: 	pElement->GetRenderStageFlags(flags);
sl@0: 	flags |= MWsElement::EElementIsIndirectlyRenderedUserInterface;
sl@0: 	pElement->SetRenderStageFlags(flags);
sl@0: 	    
sl@0:     iScene->InsertSceneElement(pElement, NULL);
sl@0: 
sl@0: 	pElement->SetDestinationRectangle(aExtent);
sl@0: 	pElement->SetSourceRectangle(aExtent);	//initial guess... updated by PositionUiElements
sl@0: 
sl@0: 	return pElement;
sl@0: 	}
sl@0: 
sl@0: void CScreen::InitializeUiElementsL()
sl@0: 	{
sl@0: 	const TRect screenRect(iScreenDevice->SizeInPixels());
sl@0: 	MWsElement* pElement = CreateUiElementL(screenRect);
sl@0: 	
sl@0: 	if(HasAlpha())
sl@0: 		{
sl@0: 		TUint32 flags = 0;
sl@0: 		pElement->GetTargetRendererFlags(flags);
sl@0: 		flags |= MWsElement::EElementTransparencySource;
sl@0: 		pElement->SetTargetRendererFlags(flags);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TInt CScreen::InitializeDsaSurface()
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(iDsaSurface.IsNull(),EWsPanicInvalidOperation);
sl@0: 	iDsaDevice->GetSurface(iDsaSurface);
sl@0: 	// Currently Surface Manager does not recognise DSA surface IDs originating
sl@0: 	// from the Screen Driver.  This causes it to fail to register such
sl@0: 	// surfaces.  OpenWF should be amended to properly register DSA surfaces.
sl@0: 	iScene->RegisterSurface(iDsaSurface);
sl@0: 
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: TSize CScreen::DSASizeInPixels() const
sl@0: 	{
sl@0: 	if(iDsaDevice)
sl@0: 		{
sl@0: 		return iDsaDevice->SizeInPixels();
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		return TSize(0,0);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: MWsTextCursor* CScreen::RenderStageTextCursor() const
sl@0: 	{
sl@0: 	return iRedraw->RenderStageTextCursor();
sl@0: 	}
sl@0: 
sl@0: void CScreen::ClearDsaSurface(const TRect& area, const TRgb& color)
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(iDsaGc, EWsPanicInvalidOperation);
sl@0: 	iDsaGc->SetBrushStyle(CFbsBitGc::ESolidBrush);
sl@0: 	iDsaGc->SetPenStyle(CFbsBitGc::ENullPen);
sl@0: 	iDsaGc->SetBrushColor(color);
sl@0: 	iDsaGc->DrawRect(area);
sl@0: 	iDsaDevice->Update();
sl@0: 	}
sl@0: 
sl@0: void CScreen::ReleaseDsaScreenDevice()
sl@0: 	{
sl@0: 	//This function checks if any of the DSA currently active on the screen is actually used to draw
sl@0: 	//If not it unregister the DSA surface and destroys the iDsaDevice.
sl@0: 	//This function should be called only by a drawing DSA so a surface should be in place.
sl@0: 	iNumberDrawingDsa--;
sl@0: 	if(iNumberDrawingDsa == 0)
sl@0: 		{
sl@0: 		WS_ASSERT_DEBUG(!iDsaSurface.IsNull(),EWsPanicInvalidOperation);
sl@0: 		delete iDsaGc;
sl@0: 		iDsaGc = NULL;
sl@0: 		// Currently Surface Manager does not recognise DSA surface IDs originating
sl@0: 		// from the Screen Driver.  This causes it to fail to unregister such
sl@0: 		// surfaces.  OpenWF should be amended to properly register DSA surfaces.
sl@0: 		iScene->UnregisterSurface(iDsaSurface);
sl@0: 
sl@0: 		delete iDsaDevice;
sl@0: 		iDsaDevice = NULL;
sl@0: 		//the old surface Id is now meaningless
sl@0: 		iDsaSurface = TSurfaceId::CreateNullId();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TInt CScreen::SetConfiguration(const TDisplayConfiguration& aConfigInput)
sl@0: 	{
sl@0: 	TInt reply = KErrNone;
sl@0: 	if(iDisplayControl)
sl@0: 		{
sl@0: 		TDisplayConfiguration config(aConfigInput);
sl@0: 		TRect sizeModePosition;
sl@0: 		if (iDisplayPolicy)
sl@0: 			{	//validate config and update to a valid hardware config
sl@0: 			reply = iDisplayPolicy->GetSizeModeConfiguration(iScreenSizeMode,config,sizeModePosition);
sl@0: 			if (reply >= KErrNone)
sl@0: 				{//set appmode in policy
sl@0: 				if (iDisplayMapping)
sl@0: 					{
sl@0: 					iDisplayMapping->SetSizeModeExtent(sizeModePosition,MWsDisplayMapping::KOffsetAll);
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		else
sl@0: 			{	//exessive strategy: limit rotation agains curr app mode.
sl@0: 				//really we want the system to accept the rotation change regardless of the app mode.
sl@0: 			TDisplayConfiguration::TRotation newRot;
sl@0: 			if (aConfigInput.GetRotation(newRot))
sl@0: 				{	//This should cast between rotation enumertaions "properly"
sl@0: 				if (!(iModes[0][iScreenSizeMode]->iAlternativeRotations&(1<<newRot)))
sl@0: 					{
sl@0: 					reply=KErrArgument;
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		if (reply < KErrNone)
sl@0: 			{
sl@0: 			return reply;
sl@0: 			}
sl@0: 		MWsScene::TSceneRotation oldRotation;
sl@0: 		oldRotation = iScene->SceneRotation();
sl@0: 		TSize newUiSize;
sl@0: 		config.GetResolution(newUiSize);
sl@0: 		TDisplayConfiguration oldConfig;
sl@0: 		iDisplayControl->GetConfiguration(oldConfig);
sl@0: 		if(iFlags&EHasDynamicSizeModes)
sl@0: 			{
sl@0: 			reply = iFallbackMap->Resize(newUiSize);
sl@0: 			}
sl@0: 		if (reply >= KErrNone)
sl@0: 			{
sl@0: 			reply=iDisplayControl->SetConfiguration(config);
sl@0: 			}	
sl@0: 		if (reply==KErrNone)
sl@0: 			{
sl@0: 			TSize oldConfigRes;
sl@0: 			oldConfig.GetResolution(oldConfigRes);
sl@0:             TDisplayConfiguration newConfig;
sl@0: 			if (oldConfigRes.iWidth == 0 || oldConfigRes.iHeight == 0)
sl@0: 				{
sl@0: 				iDisplayControl->GetConfiguration(newConfig);
sl@0: 				RecalculateModeTwips(&newConfig);	//needs res and twips information
sl@0: 				}
sl@0: 			UpdateDynamicScreenModes();
sl@0: 			
sl@0: 			//update the last set config in the config change notifier to 
sl@0: 			//prevent SetConfiguration() from being called again!
sl@0: 			newConfig.ClearAll();
sl@0: 			iDisplayControl->GetConfiguration(newConfig);
sl@0: 			iConfigChangeNotifier->UpdateLastSetConfiguration(newConfig); 			
sl@0: 			
sl@0: 			TWindowServerEvent::NotifyDrawer(TWservCrEvent(TWservCrEvent::EScreenSizeModeAboutToChange, iScreenSizeMode));
sl@0: 			// This will remove all the DSA elements from the scene
sl@0: 			AbortAllDirectDrawing(RDirectScreenAccess::ETerminateRotation);
sl@0: 			
sl@0: 			//SetDigitiserAreas needs revisiting if/when we support dynamic resolutions
sl@0: 			//on a screen with touch input.
sl@0: 			//SetDigitiserAreas(newUiSize);
sl@0: 			
sl@0: 			//failure here should only be because of DSA orientation change failure, which shouldn't happen, either.
sl@0: 			//Or there may be no change to do.
sl@0: 			(void)UpdateOrientation(&oldRotation);
sl@0: 			
sl@0: 			iWindowElementSet->ResubmitAllElementExtents();
sl@0: 			if(iDsaDevice && iDsaDevice->GraphicsAccelerator())
sl@0: 				{
sl@0: 				iDsaDevice->ChangeScreenDevice(iDsaDevice); // orientation has changed, therefore we need to re-initialise the screen device's graphics accelerator
sl@0: 				}
sl@0: 			
sl@0: 			iRootWindow->AdjustCoordsDueToRotation();
sl@0: 
sl@0: 			//TODO jonas: we'd like to not have to clear at all... make the actual change to compositor etc lazily!
sl@0: 			if(BlankScreenOnRotation())
sl@0: 				{
sl@0: 				iRootWindow->ClearDisplay();
sl@0: 				}
sl@0: 
sl@0: 			CWsTop::ClearAllRedrawStores();
sl@0: 			DiscardAllSchedules();
sl@0: 			iRootWindow->InvalidateWholeScreen();
sl@0: 			CWsWindowGroup::SetScreenDeviceValidStates(this);
sl@0: 			TWindowServerEvent::SendScreenDeviceChangedEvents(this);
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			return reply;
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		reply = KErrNotSupported;
sl@0: 		}
sl@0: 	return reply;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  * Updates the screen device display properties. This is to ensure the screen device is 
sl@0:  * consistent with any configuration changes not made using CScreen::SetConfiguration.
sl@0:  * 
sl@0:  * @param aConfigInput a fully populated display configuration
sl@0:  **/
sl@0: TInt CScreen::UpdateConfiguration(const TDisplayConfiguration& aConfigInput)
sl@0:     {
sl@0:     TInt reply = KErrNone;
sl@0:     if(iDisplayControl)
sl@0:         {
sl@0:         TDisplayConfiguration config(aConfigInput);
sl@0:         TRect sizeModePosition;
sl@0:         if (iDisplayPolicy)
sl@0:             {   //validate config and update to a valid hardware config
sl@0:             reply = iDisplayPolicy->GetSizeModeConfiguration(iScreenSizeMode,config,sizeModePosition);
sl@0:             if (reply >= KErrNone)
sl@0:                 {//set appmode in policy
sl@0:                 if (iDisplayMapping)
sl@0:                     {
sl@0:                     iDisplayMapping->SetSizeModeExtent(sizeModePosition,MWsDisplayMapping::KOffsetAll);
sl@0:                     }
sl@0:                 }
sl@0:             }
sl@0:         else
sl@0:             {   //exessive strategy: limit rotation agains curr app mode.
sl@0:                 //really we want the system to accept the rotation change regardless of the app mode.
sl@0:             TDisplayConfiguration::TRotation newRot;
sl@0:             if (aConfigInput.GetRotation(newRot))
sl@0:                 {   //This should cast between rotation enumertaions "properly"
sl@0:                 if (!(iModes[0][iScreenSizeMode]->iAlternativeRotations&(1<<newRot)))
sl@0:                     {
sl@0:                     reply=KErrArgument;
sl@0:                     }
sl@0:                 }
sl@0:             }
sl@0: 
sl@0:         MWsScene::TSceneRotation oldRotation;
sl@0:         oldRotation = iScene->SceneRotation();
sl@0:         TSize newUiSize;
sl@0:         config.GetResolution(newUiSize);
sl@0:         if(iFlags&EHasDynamicSizeModes)
sl@0:             {
sl@0:             reply = iFallbackMap->Resize(newUiSize);
sl@0:             }
sl@0: 
sl@0:         RecalculateModeTwips(&config);   //needs res and twips information
sl@0:         UpdateDynamicScreenModes();        
sl@0:         
sl@0:         TWindowServerEvent::NotifyDrawer(TWservCrEvent(TWservCrEvent::EScreenSizeModeAboutToChange, iScreenSizeMode));
sl@0:         // This will remove all the DSA elements from the scene
sl@0:         AbortAllDirectDrawing(RDirectScreenAccess::ETerminateRotation);
sl@0:         
sl@0:         //SetDigitiserAreas needs revisiting if/when we support dynamic resolutions
sl@0:         //on a screen with touch input.
sl@0:         //SetDigitiserAreas(newUiSize);
sl@0:         
sl@0:         //failure here should only be because of DSA orientation change failure, which shouldn't happen, either.
sl@0:         //Or there may be no change to do.
sl@0:         (void)UpdateOrientation(&oldRotation);
sl@0:         
sl@0:         iWindowElementSet->ResubmitAllElementExtents();
sl@0:         if(iDsaDevice && iDsaDevice->GraphicsAccelerator())
sl@0:             {
sl@0:             iDsaDevice->ChangeScreenDevice(iDsaDevice); // orientation has changed, therefore we need to re-initialise the screen device's graphics accelerator
sl@0:             }
sl@0:         
sl@0:         iRootWindow->AdjustCoordsDueToRotation();
sl@0: 
sl@0:         //TODO jonas: we'd like to not have to clear at all... make the actual change to compositor etc lazily!
sl@0:         if(BlankScreenOnRotation())
sl@0:             {
sl@0:             iRootWindow->ClearDisplay();
sl@0:             }
sl@0: 
sl@0:         CWsTop::ClearAllRedrawStores();
sl@0:         DiscardAllSchedules();
sl@0:         iRootWindow->InvalidateWholeScreen();
sl@0:         CWsWindowGroup::SetScreenDeviceValidStates(this);
sl@0:         TWindowServerEvent::SendScreenDeviceChangedEvents(this);
sl@0:         }
sl@0:     else
sl@0:         {
sl@0:         reply = KErrNotSupported;
sl@0:         }
sl@0:     return reply;  
sl@0:     }
sl@0: 
sl@0: void CScreen::UpdateDynamicScreenModes()
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(iDisplayControl,EWsPanicNoDisplayControl);
sl@0: 	TDisplayConfiguration newConfig;
sl@0: 	iDisplayControl->GetConfiguration(newConfig);
sl@0: 	TSize res;
sl@0: 	TSize twips;
sl@0: 	newConfig.GetResolution(res);
sl@0: 	newConfig.GetResolutionTwips(twips);
sl@0: 	for (TInt i=0; i<iModes->Count(); i++)
sl@0: 		{
sl@0: 		if ((*iModes)[i] && ((*iModes)[i]->iFlags & EDynamic))
sl@0: 			{
sl@0: 			(*iModes)[i]->iScreenSize = res;
sl@0: 			(*iModes)[i]->iScreenTwipsSize = twips;
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CScreen::RecalculateModeTwips(const TDisplayConfiguration* aConfig)
sl@0: 	{
sl@0: 	TDisplayConfiguration config;
sl@0: 	iDisplayControl->GetConfiguration(config);
sl@0: 	TSize res;
sl@0: 	TSize twips;
sl@0: 	if (aConfig)	//called from SetConfiguration
sl@0: 		{
sl@0: 		aConfig->GetResolution(res);
sl@0: 		if (res.iWidth == 0 || res.iHeight == 0)
sl@0: 			{
sl@0: 			return;
sl@0: 			}
sl@0: 		aConfig->GetResolutionTwips(twips);
sl@0: 		}
sl@0: 	else	//called from DisplayChangeNotifier during attach
sl@0: 		{
sl@0: 		config.GetResolution(res);
sl@0: 		if ((res.iWidth == 0 || res.iHeight == 0) && !iDisplayPolicy)
sl@0: 			{
sl@0: 			return;
sl@0: 			}
sl@0: 		config.GetResolutionTwips(twips);
sl@0: 		}
sl@0: 	TInt err=KErrNone;
sl@0: 	TInt flags=0;
sl@0: 	for (TInt ii=0; ii<iModes->Count(); ii++)
sl@0: 		{	//for every mode
sl@0: 		TRAP(err, flags = ModePtrL(ii)->iFlags);
sl@0: 		if (err != KErrNone || flags&(ETwipsSpecified|EDynamic))
sl@0: 			{	//continue if mode doesnt exist,twips specified or dynamic mode specified
sl@0: 			continue;
sl@0: 			}
sl@0: 
sl@0: 		if (iDisplayPolicy)
sl@0: 			{	//get ideal config for app mode from policy
sl@0: 			TRect modePosition;
sl@0: 			config.ClearAll();
sl@0: 			TInt err = iDisplayPolicy->GetSizeModeConfiguration(ii,config,modePosition);
sl@0: 			if (err != KErrNone)
sl@0: 				{	//nothing we can do, the twips will not be calculated correctly
sl@0: 				continue;
sl@0: 				}
sl@0: 			config.GetResolution(res);
sl@0: 			config.GetResolutionTwips(twips);
sl@0: 			}
sl@0: 		TSizeMode* modePtr=(*iModes)[ii];
sl@0: 		modePtr->iScreenTwipsSize.iWidth = (twips.iWidth * modePtr->iScreenSize.iWidth)/
sl@0: 				res.iWidth;
sl@0: 		modePtr->iScreenTwipsSize.iHeight = (twips.iHeight * modePtr->iScreenSize.iHeight)/
sl@0: 				res.iHeight;
sl@0: 		}
sl@0: 	
sl@0: 	}
sl@0: 
sl@0: TInt CScreen::AddNotificationClient(CWsClient *aClient)
sl@0: 	{
sl@0: 	TInt err = iWsClientList.InsertInAddressOrder(aClient);
sl@0: 	if(!(err == KErrNone || err == KErrAlreadyExists))
sl@0: 		{
sl@0: 		return err;
sl@0: 		}
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: void CScreen::RemoveNotificationClient(CWsClient *aClient)
sl@0: 	{
sl@0: 	TInt index = iWsClientList.FindInAddressOrder(aClient);
sl@0: 	if(index != KErrNotFound)
sl@0: 		{
sl@0: 		iWsClientList.Remove(index);
sl@0: 		}
sl@0: 	}
sl@0: TInt CScreen::GetNotificationClients(RPointerArray<CWsClient>& aClientsArray)
sl@0: 	{
sl@0: 	TInt err = aClientsArray.Reserve(iWsClientList.Count());
sl@0: 	if(err != KErrNone)
sl@0: 		return err;
sl@0: 	
sl@0: 	for(TInt i = 0; i < iWsClientList.Count(); i++)
sl@0: 		{
sl@0: 		aClientsArray.Append(iWsClientList[i]);
sl@0: 		}
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: TInt CScreen::FindNotificationClient (CWsClient *aClient)
sl@0: 	{
sl@0: 	return iWsClientList.FindInAddressOrder(aClient);
sl@0: 	}
sl@0: 
sl@0: // implementing MWsScreenConfig... this might be better as RS interface
sl@0: TSize CScreen::ScreenModeSizeInPixels() const
sl@0: 	{
sl@0: 	return (*iModes)[iScreenSizeMode]->iScreenSize;
sl@0: 	}
sl@0: TInt CScreen::Stride() const
sl@0: 	{
sl@0: 	return 0;
sl@0: 	}
sl@0: TInt CScreen::SizeMode() const
sl@0: 	{
sl@0: 	return iScreenSizeMode;
sl@0: 
sl@0: 	}
sl@0: TSize CScreen::ScalingFactor() const
sl@0: 	{
sl@0: 	return (*iModes)[iScreenSizeMode]->iScreenScale;
sl@0: 	}
sl@0: TPoint CScreen::Origin() const
sl@0: 	{
sl@0: 	return (*iModes)[iScreenSizeMode]->iOrigin;
sl@0: 	}
sl@0: TPoint CScreen::ScaledOrigin() const
sl@0: 	{
sl@0: 	return (*iModes)[iScreenSizeMode]->ScaledOrigin();
sl@0: 	}
sl@0: 
sl@0: const CScreen::TInternalSizeMode* CScreen::ModePtrL(TInt aIndex) const
sl@0: 	{
sl@0: 	if (aIndex>=iModes->Count() || aIndex<0)
sl@0: 		{
sl@0: 		User::Leave(KErrArgument);
sl@0: 		}
sl@0: 	if (iModes==NULL)
sl@0: 		{
sl@0: 		User::Leave(KErrNotReady);
sl@0: 		}
sl@0: 	TInternalSizeMode* modePtr=(*iModes)[aIndex];
sl@0: 	if (modePtr==NULL)
sl@0: 		{
sl@0: 		User::Leave(KErrArgument);
sl@0: 		}
sl@0: 	return modePtr;
sl@0: 	}
sl@0: 
sl@0: TDisplayMode CScreen::DisplayModeL(TInt aIndex) const
sl@0: 	{
sl@0: 	return ModePtrL(aIndex)->iDefaultDisplayMode;
sl@0: 	}
sl@0: TSize CScreen::ScreenModeSizeInPixelsL(TInt aIndex) const
sl@0: 	{
sl@0: 	return ModePtrL(aIndex)->iScreenSize;
sl@0: 	}
sl@0: TSize CScreen::ScreenModeSizeInTwipsL(TInt aIndex) const 
sl@0: 	{
sl@0: 	return ModePtrL(aIndex)->iScreenTwipsSize;
sl@0: 	}
sl@0: 
sl@0: CFbsBitGc::TGraphicsOrientation CScreen::OrientationL(TInt aIndex) const
sl@0: 	{
sl@0: 	return ModePtrL(aIndex)->iRotation;
sl@0: 	}
sl@0: TInt CScreen::AvailableOrientationsL(TInt aIndex) const
sl@0: 	{
sl@0: 	return ModePtrL(aIndex)->iAlternativeRotations;
sl@0: 	}
sl@0: TSize CScreen::ScalingFactorL(TInt aIndex) const
sl@0: 	{
sl@0: 	return ModePtrL(aIndex)->iScreenScale;
sl@0: 	}
sl@0: TPoint CScreen::OriginL(TInt aIndex) const
sl@0: 	{
sl@0: 	return ModePtrL(aIndex)->iOrigin;
sl@0: 	}
sl@0: TPoint CScreen::ScaledOriginL(TInt aIndex) const
sl@0: 	{
sl@0: 	return ModePtrL(aIndex)->ScaledOrigin();
sl@0: 	}
sl@0: TInt CScreen::ModeFlagsL(TInt aIndex) const
sl@0: 	{
sl@0: 	return ModePtrL(aIndex)->iFlags;
sl@0: 	}
sl@0: void CScreen::SetCurrentScreenModeAttributes(const TSizeMode &aModeData)
sl@0: 	{	
sl@0: 	TSizeMode* modeToOverwrite=(*iModes)[iScreenSizeMode];
sl@0: 	*modeToOverwrite=aModeData;
sl@0: 	}
sl@0: 
sl@0: void CScreen::ScheduleWindow(CWsWindow* aWindow)
sl@0: 	{
sl@0: 	iRedraw->ScheduleWindow(aWindow);
sl@0: 	}
sl@0: 
sl@0: void CScreen::RemoveFromScheduledList(CWsWindow* aWindow)
sl@0: 	{
sl@0: 	iRedraw->RemoveFromScheduledList(aWindow);
sl@0: 	}
sl@0: 
sl@0: void CScreen::RemoveFromTimedDrawList(CWsWindow* aWindow)
sl@0: 	{
sl@0: 	iRedraw->RemoveFromTimedDrawList(aWindow);
sl@0: 	}
sl@0: 
sl@0: void CScreen::SetupVisibleRegionTracking(CWsWindow& aWindow, TBool aRegister) const
sl@0: 	{
sl@0: 	if(ChangeTracking() && iWindowVisibilityNotifier)
sl@0: 		{
sl@0: 		if(aRegister)
sl@0: 			{
sl@0: 			iWindowVisibilityNotifier->RegisterWindow(aWindow);
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			iWindowVisibilityNotifier->UnregisterWindow(aWindow);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TBool CScreen::IsAnimating() const
sl@0:     {
sl@0:     return iRedraw->IsAnimating();
sl@0:     }