// Copyright (c) 2008-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:

 //

 /**

  @file

 */

 #include <e32std.h>

 #include <e32math.h>

 #include <w32std.h>

 #include <w32debug.h>

 #include "teflogextensions.h"

 #include "t_wsdynamicreswinbase.h"

 #include "globalsettings.h"

 #include <bitdraw.h>

 #include <bitdrawinterfaceid.h>

 #include <u32hal.h>

 #include <dispchannel.h>

 #include <graphics/displaycontrol.h>

 #if (!defined(K_DISPLAY_CH_MAJOR_VERSION_NUMBER) && !defined(K_DISPLAY_CH_MINOR_VERSION_NUMBER))

 #define MODE_CHANGE_BASE_FUNCTIONALITY_NOT_PRESENT_IN_HEADER

 #endif

 _LIT(KMonospaceTestFontTypefaceName,"Arial");

 const TInt KMaxFontSize = 150;

 TBool	CWsDynamicResWinBase::iTransparencyEnabled=EFalse;

 CWsDynamicResWinBase::CWsDynamicResWinBase():

 	iDoTearDown(EFalse),

 	iSession(TGlobalSettings::Instance().iScreen)

 {

 }

 void CWsDynamicResWinBase::SetupL()

 	{

 	SetupL(EFalse);

 	}

 CActiveScheduler	CWsDynamicResWinBase::iScheduler;

 void CWsDynamicResWinBase::SetupL(TBool aUseOtherScreenForInfo)

 	{	

 	if (CActiveScheduler::Current()!=&iScheduler)

 		{

 		new (&iScheduler) CActiveScheduler;

 		CActiveScheduler::Install(&iScheduler);

 		}

 	iDoTearDown=ETrue;

 	iRed.SetInternal(0xFFFF0000);

 	iGreen.SetInternal(0xFF00FF00);

 	iBlue.SetInternal(0xFF0000FF);

 	iCyan.SetInternal(0xFF00FFFF);

 	iMagenta.SetInternal(0xFFFF00FF);

 	iYellow.SetInternal(0xFFFFFF00);

 	iWhite.SetInternal(0xFFFFFFFF);

 	iLastGceHoleColor.SetInternal(0);

 	TITLE_BACKGROUND=iCyan;

 	COMPARE_BACKGROUND=iBlue;

 	ASSERT_EQUALS_X(iSession.Connect(), KErrNone);

 		{//Stolen from TAuto CloseAllPanicWindows()

 		TInt idFocus = iSession.GetFocusWindowGroup();

 		TWsEvent event;

 		event.SetType(EEventKey); //EEventKeyDown

 		TKeyEvent *keyEvent = event.Key();

 		keyEvent->iCode = EKeyEscape;

 		keyEvent->iScanCode = EStdKeyEscape;

 		keyEvent->iModifiers = 0;

 		TInt theLimit = 50;

 		while(idFocus != NULL && (theLimit-- > 0))

 			{

 			iSession.SendEventToAllWindowGroups(event);

 			TInt idNewFocus = iSession.GetFocusWindowGroup();

 			if (idNewFocus!=idFocus)

 				{

 				INFO_PRINTF1(_L("A window was closed [probably a panic box from the previous test]."));

 				}

 			idFocus=idNewFocus;

 			}

 		}

 	TInt err = KErrNone;

 	TRAP(err, iScreenDevice = new (ELeave) CWsScreenDevice(iSession));

 	PRINT_ON_ERROR2_L(err, _L("Failed to create screen device: %d"), err);

 	ASSERT_EQUALS_X(iScreenDevice->Construct(TGlobalSettings::Instance().iScreen), KErrNone);

 	iDisplayMode = iScreenDevice->DisplayMode();	// Get default display mode

 	CheckAndConnectScreen();

 	TRAP(err, iGc = new (ELeave) CWindowGc(iScreenDevice));

 	PRINT_ON_ERROR2_L(err, _L("Failed to create graphics context: %d"), err);

 	ASSERT_EQUALS_X(iGc->Construct(), KErrNone);

 	iGroup = RWindowGroup(iSession);

 	ASSERT_EQUALS_X(iGroup.Construct(++iWindowHandle,iScreenDevice), KErrNone);

 	iGroup.SetOrdinalPositionErr(0, KPasswordWindowGroupPriority - 1); // Added code ---- Fastpath

 	iSession.Flush();

 	if (aUseOtherScreenForInfo)

 		{

 		if (iSession.NumberOfScreens()>1)

 			{	//Create server objects for info windows to appear on alternate screen

 			TInt alternateScreenNum=iSession.NumberOfScreens()-1;

 			if (TGlobalSettings::Instance().iScreen==alternateScreenNum)

 				{	//Alternate screen is last screen, or first screen if that is being tested. 

 				alternateScreenNum=0;

 				}

 			TRAP(err, iInfoScreenDevice = new (ELeave) CWsScreenDevice(iSession));

 			PRINT_ON_ERROR2_L(err, _L("Failed to create second screen device: %d"), err);

 			ASSERT_EQUALS_X(iInfoScreenDevice->Construct(alternateScreenNum), KErrNone);

 			TRAP(err, iInfoGc = new (ELeave) CWindowGc(iInfoScreenDevice));

 			PRINT_ON_ERROR2_L(err, _L("Failed to create second graphics context: %d"), err);

 			ASSERT_EQUALS_X(iInfoGc->Construct(), KErrNone);

 			iInfoGroupInstance = RWindowGroup(iSession);

 			ASSERT_EQUALS_X(iInfoGroupInstance.Construct(++iWindowHandle,iInfoScreenDevice), KErrNone);

 			iInfoGroup=&iInfoGroupInstance;

 			}

 		else

 			{	//If alternate screen is not available then no text or compare windows should be created!

 			iInfoScreenDevice=iScreenDevice;	//it is "convenient" for the device to still be good.

 			iInfoGc=NULL;

 			iInfoGroup=NULL;

 			}

 		}

 	else

 		{	//

 		iInfoScreenDevice=iScreenDevice;

 		iInfoGc=iGc;

 		iInfoGroup=&iGroup;

 		}

 	if (iInfoGroup && iInfoGc)

 		{

 		// Add a plain background window to obscure anything else that

 		// happens to be behind the test. Setting this window's display mode is also

 		// used to set the screen device display mode, and hence the composition

 		// mode: alpha or chroma key.

 		iBackground = RBlankWindow(iSession);

 		ASSERT_EQUALS_X(iBackground.Construct(*iInfoGroup, ++iWindowHandle), KErrNone);

 		iBackground.SetOrdinalPosition(100);	// Behind anything else in this group.

 		iBackground.SetColor(TRgb(iWhite));

 		//iBackground.SetExtent(TPoint(-1000,-1000),TSize(3000,3000));

 		iBackground.Activate();

 		iBackground.SetVisible(ETrue);

 		}

 	iSession.Flush();

 	RWindow testTrans(iSession);

 	ASSERT_EQUALS_X(testTrans.Construct(iGroup, ++iWindowHandle), KErrNone);

 	iTransparencyEnabled=(testTrans.SetTransparencyFactor(iWhite)==KErrNone);

 	if (iTransparencyEnabled)

 		{

 		TTestName testName;

 		testName.Format(_L("Screen %i, depth %i: Found Trans Man"),

 				TGlobalSettings::Instance().iScreen

 			);

 		UpdateTitleWindowL(testName,KMaxInfoLines-1);

 		}

 	else

 		{

 		TTestName testName;

 		testName.Format(_L("Screen %i, depth %i: No Trans Man"),

 				TGlobalSettings::Instance().iScreen

 			);

 		UpdateTitleWindowL(testName,KMaxInfoLines-1);

 		}

 	testTrans.Close();

 	}

 void CWsDynamicResWinBase::CheckAndConnectScreen()

 	{

 	if (TGlobalSettings::Instance().iDisconnected) //set from script file to match wsini keyword SIMULATE_STARTUP_DISCONNECTED

 		{

 		//Verify that the display really is disconnected

 		ASSERT_TRUE_X(iScreenDevice != NULL);

 		MDisplayControl* interface = static_cast<MDisplayControl*>(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

 		ASSERT_TRUE_X(interface != NULL);

 		RArray<MDisplayControl::TResolution> resolutions;

 		const TInt err = interface->GetResolutions(resolutions);

 		ASSERT_EQUALS_X(err, KErrDisconnected);

 		resolutions.Close();

 		}

 #ifndef MODE_CHANGE_BASE_FUNCTIONALITY_NOT_PRESENT_IN_HEADER

 	//make sure display is attached to screen (only if I/F is available at compile time...)

 	TInt displayState = ENormalResolution;

 	UserSvr::HalFunction(EHalGroupDisplay | (TGlobalSettings::Instance().iScreen<<16), EDisplayHalSetDisplayState, &displayState, NULL);

 	Pause(200);

 #endif	

 	if (TGlobalSettings::Instance().iDisconnected)

 		{

 		//Verify that the display now is connected

 		MDisplayControl* interface = static_cast<MDisplayControl*>(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

 		RArray<MDisplayControl::TResolution> resolutions;

 		const TInt err = interface->GetResolutions(resolutions);

 		ASSERT_EQUALS_X(err, KErrNone);

 		const_cast<TGlobalSettings&>(TGlobalSettings::Instance()).iDisconnected = EFalse;

 		resolutions.Close();

 		}

 	}

 /**

 Common tear down code for all tests.

 Windows, group and session created are closed. Screen device is destroyed.

 Surfaces, manager and update session are closed.

 */

 void CWsDynamicResWinBase::TearDownL()

 	{

 	iDoTearDown=EFalse;

 	if (iInfoGc!=iGc)

 		delete iInfoGc;

 	delete iGc;

 	if (iInfoScreenDevice!=iScreenDevice)

 		delete iInfoScreenDevice;

 	delete iScreenDevice;

 	iGroup.Close();

 	if (iInfoGroupInstance.WsHandle())

 		iInfoGroupInstance.Close();

 	iSession.Flush();

 	iSession.Close();

 	}

 /**

  * Note that this is not the ideal mechanism.

  * A derived class may thinks its TearDown is safe to do from delete, but in the class it is derived from it may not be safe

  **/

 void CWsDynamicResWinBase::TearDownFromDeleteL()	

 	{

 	CWsDynamicResWinBase::TearDownL();	//Explicitly call the non-derived implementation.

 	}

 CWsDynamicResWinBase::~CWsDynamicResWinBase()

 {

 	if (iDoTearDown)

 		TearDownFromDeleteL();	//This mechanism is not entirely clean to use.

 }

 /**

 Pause for the given number of milliseconds.

 @param aMilliseconds	Time to wait in milliseconds.

 */

 void CWsDynamicResWinBase::Pause(TInt aMilliseconds)

 	{

 	User::After(TTimeIntervalMicroSeconds32(aMilliseconds * 1000));

 	}

 // This handles any non-member uses of the extended ASSERT_XXX macros

 void TefUnitFailLeaveL()

 	{

 	User::Leave(KErrTEFUnitFail);

 	}

 /**

  * side-effect: log the state info just before I leave!

  * Note that this only logs intentional assertion failures.

  * Fails due to panics or throws won't log this info.

  **/

 void CWsDynamicResWinBase::TefUnitFailLeaveL()

 	{

 	for (TInt line=0;line<KMaxInfoLines;line++)

 		if (iTestInfo[line].Length())

 			Logger().LogExtra((TText8*)"Test state at fail - line",line, ESevrAll, iTestInfo[line]);

 	User::Leave(KErrTEFUnitFail);

 	}

 /**	Creates the LHS info window, annd a middle window to display a representation of the expected result.

  *  Also sets up a rectangle representing the space on the right to be used for the test

  * 	@param	aTitle	The title to display on the info window

  *  @param	aDetail	Optional text to display on the first line under the title

 **/

 void CWsDynamicResWinBase::MakeTitleAndCompareWindowsL(TRefByValue<const TDesC16> aTitle,TRefByValue<const TDesC16> aDetail)

 	{	

 	iTestName=aTitle;

 	iTestInfo[0]=aDetail;

 	TRect screenSize(iInfoScreenDevice->SizeInPixels());

 	TPoint oneThird(screenSize.iBr.iX/3,screenSize.iBr.iY/3);

 	TRect winSize(0,0,oneThird.iX,oneThird.iY);

 	if (oneThird.iX>oneThird.iY)

 		{

 		oneThird.iY=0;

 		winSize.iBr.iY=screenSize.iBr.iY;

 		}

 	else

 		{

 		oneThird.iX=0;

 		winSize.iBr.iX=screenSize.iBr.iX;

 		}

 	winSize.Shrink(5,5);

 	if (iInfoGc)

 		{

 		iTitle=RWindow(iSession);

 		ASSERT_EQUALS_X(iTitle.Construct(*iInfoGroup, ++iWindowHandle), KErrNone);

 		iTitle.SetBackgroundColor(iCyan);

 		iTitle.SetExtent(winSize.iTl,winSize.Size());

 		iTitle.Activate();

 		RepaintTitleWindowL();

 		iTitle.SetVisible(ETrue);

 		winSize.Move(oneThird);

 		iCompare=RWindow(iSession);

 		ASSERT_EQUALS_X(iCompare.Construct(*iInfoGroup, ++iWindowHandle), KErrNone);

 		iCompare.SetBackgroundColor(COMPARE_BACKGROUND);

 		iCompare.SetExtent(winSize.iTl,winSize.Size());

 		iCompare.Activate();

 		iCompare.BeginRedraw();

 		ActivateWithWipe(iInfoGc,iCompare,COMPARE_BACKGROUND);

 		TFontSpec fspec(KMonospaceTestFontTypefaceName,KMaxFontSize);

 		CFont *font=NULL;

 		ASSERT_EQUALS(iScreenDevice->GetNearestFontToDesignHeightInTwips(font,fspec),KErrNone);

 		iInfoGc->UseFont(font);

 		iInfoGc->DrawText(_L("Simulation"),winSize.Size(),winSize.Size().iHeight-5,iGc->ECenter);

 		iInfoGc->Deactivate();

 		iCompare.EndRedraw();

 		iCompare.SetVisible(ETrue);

 		if (iScreenDevice!=iInfoScreenDevice)

 			{

 			winSize.Move(-oneThird);

 			}

 		else

 			{

 			winSize.Move(oneThird);

 			}

 		}

 	else

 		{

 		winSize=iScreenDevice->SizeInPixels();

 		}

 	iTestPos=winSize;

 	iTestPointCentre=winSize.Center();

 	iCenteredFrontWinRect=winSize;

 	iCenteredFrontWinRect.Shrink(winSize.Size().iWidth/3,winSize.Size().iHeight/3);

 	}

 /**	Makes the compare window larger by covering the test window area as well.

  * 	Copes with vertically aligned screens, but will be naughty if called multiple times!!!

  *  @param aGoLarger	If set false, resets the size back.

  **/

 void CWsDynamicResWinBase::LargerCompareWindow(TBool aGoLarger)

 	{

 	TPoint currPos=iCompare.AbsPosition();

 	TSize currSize=iCompare.Size();

 	if (currPos.iX<currPos.iY)

 		{

 		if (aGoLarger)

 			currSize.iHeight<<=1;

 		else

 			currSize.iHeight>>=1;

 		}

 	else

 		{

 		if (aGoLarger)

 			currSize.iWidth<<=1;

 		else

 			currSize.iWidth>>=1;

 		}

 	iCompare.SetSize(currSize);

 	}

 /**	Puts a line of text on the LHS window.

  *  Repaints the window. The line of text will also be shown in the log if the test fails.

  *	@param	aDetail	The text to display

  * 	@param	aIndex	The row number to display at

  **/

 void CWsDynamicResWinBase::UpdateTitleWindowL(TRefByValue<const TDesC16> aDetail,TInt aIndex)

 	{

 	ASSERT(aIndex>=0 && aIndex<KMaxInfoLines);

 	iTestInfo[aIndex]=aDetail;

 	RepaintTitleWindowL();

 	}

 /**	Activate the GC onto the Window.

  *  In non-transparent mode it also performs a wipe background as the WServ system does not necessarily do this.

  * 	@param	aGc		The GC to associate

  * 	@param	aWin	The window to associate

  * 	@param	aColor	The color to use as the wipe. Default is transparent, which means no wipe.

  **/

 TBool	CWsDynamicResWinBase::ActivateWithWipe(CWindowGc* aGc,RWindow& aWin,TRgb aColor)

 	{

 	aGc->Activate(aWin);

 	aGc->SetBrushColor(aColor);

 	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

 	if (aColor!=TRgb(0,0) && !iTransparencyEnabled)	//presume that all redraw-stored windows will draw background

 		{

 		aGc->Clear();

 		return ETrue;	//window was cleared

 		}

 	return EFalse;	

 	}

 CWindowGc*	CWsDynamicResWinBase::GcForWindow(RWindow& aWin)

 	{

 	if (aWin.WsHandle()==NULL)

 		return NULL;	//can't activate uninitialised window.

 	CWindowGc* gc=iGc;

 	if (iGc!=iInfoGc)

 		if (&aWin==&iCompare || &aWin==&iTitle)

 			gc=iInfoGc;

 		else if (iInfoGroup && aWin.WindowGroupId()==iInfoGroup->WindowGroupId())

 			gc=iInfoGc;

 	return gc;

 	}

 /** Activates an appropriate predefined GC on the specified window and wipes the background if necessary. 

  *  @param	aWin	The window to wipe

  * 	@param	aColor	The colour to wipe with (if necessary)

  * 	@return	the GC to use for drawing and deactivate at end. This may be NULL if the window is not "live"

  **/

 CWindowGc*	CWsDynamicResWinBase::BeginActivateWithWipe(TBool aInvalidate,RWindow& aWin,TRgb aColor)

 	{

 	CWindowGc* gc=GcForWindow(aWin);

 	iSession.Flush();

 	if (gc==NULL)

 		return gc;	//can't activate uninitialised window.

 	if (aInvalidate)

 		aWin.Invalidate();

 	iSession.Flush();

 	aWin.BeginRedraw();

 	iSession.Flush();

 	ActivateWithWipe(gc,aWin,aColor);

 	return gc;	

 	}

 /** Activates an appropriate predefined GC on the specified window and wipes the background if necessary. 

  *  @param	aWin	The window to wipe

  * 	@param	aColor	The colour to wipe with (if necessary)

  * 	@return	the GC to use for drawing and deactivate at end. This may be NULL if the window is not "live"

  **/

 CWindowGc*	CWsDynamicResWinBase::BeginActivateWithWipe(TBool aInvalidate,TRect aRect,RWindow& aWin,TRgb aColor)

 	{

 	if (aWin.WsHandle()==NULL)

 		return NULL;	//can't activate uninitialised window.

 	if (aInvalidate)

 		aWin.Invalidate(aRect);

 	aWin.BeginRedraw(aRect);

 	CWindowGc* gc=iGc;

 	if (iGc!=iInfoGc)

 		if (&aWin==&iCompare || &aWin==&iTitle)

 			gc=iInfoGc;

 		else if (aWin.WindowGroupId()==iInfoGroup->WindowGroupId())

 			gc=iInfoGc;

 	ActivateWithWipe(gc,aWin,aColor);

 	return gc;	

 	}

 TBool		CWsDynamicResWinBase::InvalidateRegion(const TRegion& aRegion,RWindow& aWin)

 	{

 	if (aWin.WsHandle()==NULL)

 		return false;	//can't activate uninitialised window.

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

 		{

 		aWin.Invalidate(aRegion[ii]);

 		}

 	return true;

 	}

 CWindowGc*	CWsDynamicResWinBase::BeginActivateWithWipe(const TRegion& aRegion,RWindow& aWin,TRgb aColor)

 	{

 	if (!InvalidateRegion(aRegion,aWin))

 		return NULL;	//can't activate uninitialised window.

 	aWin.BeginRedraw();

 	CWindowGc* gc=iGc;

 	if (iGc!=iInfoGc)

 		if (&aWin==&iCompare || &aWin==&iTitle)

 			gc=iInfoGc;

 		else if (aWin.WindowGroupId()==iInfoGroup->WindowGroupId())

 			gc=iInfoGc;

 	ActivateWithWipe(gc,aWin,aColor);

 	return gc;	

 	}

 /**	Paints the LHS window with rows of text.

  * 

  **/

 void CWsDynamicResWinBase::RepaintTitleWindowL()

 	{

 	if (iTitle.WsHandle())

 		{

 		iTitle.Invalidate();

 		iTitle.BeginRedraw();

 		ActivateWithWipe(iInfoGc,iTitle,TITLE_BACKGROUND);

 		iInfoGc->SetUnderlineStyle(EUnderlineOn);

 		TSize winSize=iTitle.Size();

 		TRect textRect(winSize);

 		textRect.iBr.iY/=4;

 		TFontSpec fspec(KMonospaceTestFontTypefaceName,KMaxFontSize);

 		CFont *font=NULL;

 		ASSERT_EQUALS(iInfoScreenDevice->GetNearestFontToDesignHeightInTwips(font,fspec),KErrNone);

 		iInfoGc->UseFont(font);

 		iInfoGc->DrawText(iTestName,textRect,textRect.iBr.iY/2,iGc->ECenter);

 		iInfoGc->SetUnderlineStyle(EUnderlineOff);

 		textRect.iTl.iY=textRect.iBr.iY;

 		TInt rowHeight=winSize.iHeight*3/(4*(KMaxInfoLines+1));

 		textRect.iBr.iY+=rowHeight;

 		for (TInt index=0;index<KMaxInfoLines;index++)

 			{

 			if (iTestInfo[index].Length())

 			    {

 				iInfoGc->DrawText(iTestInfo[index],textRect,textRect.Size().iHeight*3/4,iInfoGc->ECenter);

 			    }

 			textRect.Move(0,rowHeight);

 			}

 		iInfoGc->DiscardFont();

 		iInfoGc->Deactivate();

 		iTitle.EndRedraw();

 		iInfoScreenDevice->ReleaseFont(font);

 		iSession.Flush();

 		iSession.Finish();

 		}

 	}

 /** Useful test culled from other GCE test classes.

  * 	

  * 

  * 

  **/

 TBool CWsDynamicResWinBase::DisplayHasAlpha() const

 	{

 	return (iDisplayMode == EColor16MA || iDisplayMode == EColor16MAP);

 	}

 /**	Test using an indipendent method that GCE version of WServ is running

  *  This method can only be called after the testcase is started

  * 

  * 	@return	true if WServ version is GCE technology, false if legacy technology

  **/

 TBool CWsDynamicResWinBase::GCEIsSupported() const

 	{

 	CFbsDrawDevice* screenDevice=NULL;

 	TDisplayMode displayMode=iScreenDevice->DisplayMode();

 	TRAPD(err, screenDevice = CFbsDrawDevice::NewScreenDeviceL(TGlobalSettings::Instance().iScreen, displayMode));

 	TBool rv=EFalse;

 	if(err == KErrNone)

 		{

 		TAny* p=NULL;

 		rv=(screenDevice->GetInterface(KSurfaceInterfaceID, p)==KErrNone);

 		delete screenDevice;

 		}

 	return rv;

 	}

 /**	Test using an indipendent method that GCE version of WServ is running

  *  This method can be called at any time, even by external code, but creates temporary window session objects

  * 

  * 	@return	true if WServ version is GCE technology, false if legacy technology

  **/

 TBool CWsDynamicResWinBase::GCEIsSupportedStatic()

 	{

 	CFbsDrawDevice* screenDevice=NULL;

 	RWsSession session;

 	if (session.Connect()!=KErrNone)

 		{

 		return EFalse;

 		}

 	TDisplayMode displayMode=ENone;

 		{CWsScreenDevice screen(session);

 		if (screen.Construct(TGlobalSettings::Instance().iScreen)!=KErrNone)

 			{

 			return EFalse;

 			}

 			displayMode=screen.DisplayMode();

 		}//screen destroyed

 		TRAPD(err, screenDevice = CFbsDrawDevice::NewScreenDeviceL(TGlobalSettings::Instance().iScreen, displayMode));

 		TBool rv=EFalse;

 		if(err == KErrNone)

 			{

 			TAny* p=NULL;

 			rv=(screenDevice->GetInterface(KSurfaceInterfaceID, p)==KErrNone);

 			delete screenDevice;

 			}

 	return rv;

 	}//session destroyed

 /**

 Use the full-screen background window to select a display mode that doesn't use

 alpha (anything other than EColor16MA or EColor16MAP). Record the mode for use

 in setting all other windows.

 @return ETrue if an appropriate mode was selected, EFalse otherwise.

 */

 TBool CWsDynamicResWinBase::SelectChromaCompositionMode()

 	{

 	// Request EColor64K, but as long as the actual mode doesn't use alpha, it

 	// doesn't matter too much which one is used.

 	if (iInfoGc==iGc)

 		{

 		iDisplayMode = (TDisplayMode)iBackground.SetRequiredDisplayMode(EColor64K);

 		iSession.Flush();		// Force switching to the display mode.

 		}

 	return !DisplayHasAlpha();

 	}

 /**	Returns the colour used by WServ to paint holes in UI layer to reveal the GCE behind.

  * 	The window should have a surface attached.

  * 	If the method is called after the surface has been detached or the window was removed then 

  * 	the previous recorded hole color is returned.

  **/

 TRgb  CWsDynamicResWinBase::GceHoleColor( RWindowBase& aWin)const

 	{

 	if (aWin.WsHandle()==NULL)

 		{

 		return iLastGceHoleColor;

 		}

 	TRgb retVal=aWin.KeyColor();

 	if (retVal==TRgb(0,0))

 		{

 		return iLastGceHoleColor;

 		}

 	else

 		{

 		iLastGceHoleColor=retVal;

 		return retVal;

 		}

 	}

 /**

 Use the full-screen background window to select a display mode that can use

 alpha (either EColor16MA or EColor16MAP). Record the mode for use in setting all

 other windows.

 @return ETrue if an appropriate mode was selected, EFalse otherwise.

 */

 TBool CWsDynamicResWinBase::SelectAlphaCompositionMode(TDisplayMode aMode)

 	{

 	// Request EColor16MA, but as long as the actual mode can use alpha, it

 	// doesn't matter too much which one is used.

 	if (iInfoGc==iGc)

 		{

 		iDisplayMode = (TDisplayMode)iBackground.SetRequiredDisplayMode(aMode);

 		iSession.Flush();		// Force switching to the display mode.

 		}

 	return DisplayHasAlpha();

 	}

 /**

  * 	Interesting UI pattern used by other GCE tests.

  * 

  * 

  **/

 void CWsDynamicResWinBase::DrawUIContent(RWindow& aWindow)

 	{

 	aWindow.BeginRedraw();

 	CWindowGc* gc=(&aWindow==&iCompare)?iInfoGc:iGc;

 	gc->Activate(aWindow);

 	TBool hasAlpha = DisplayHasAlpha();

 	// Draw a red-green graduated box in the central portion of the window,

 	// with alpha if available.

 	TPoint start;

 	TPoint end;

 	TInt halfW = KSurfaceWidth / 2;

 	TInt quarterW = halfW / 2;

 	TInt halfH = KSurfaceHeight / 2;

 	TInt quarterH = halfH / 2;

 	// Set constant ordinals for non-alpha case.

 	start.iX = quarterW;

 	end.iX = quarterW + halfW;

 	for (TInt yy = 0; yy < halfH; yy++)

 		{

 		TInt yval = yy * 255 / (halfH - 1);

 		start.iY = yy + quarterH;

 		end.iY = start.iY;

 		if (hasAlpha)

 			{

 			for (TInt xx = 0; xx < halfW; xx++)

 				{

 				TInt xval = xx * 255 / (halfW - 1);

 				start.iX = xx + quarterW;

 				end.iX = start.iX + 1;

 				gc->SetPenColor(TRgb(yval, 255 - yval, 0, xval));

 				gc->DrawLine(start, end);

 				}

 			}

 		else

 			{

 			gc->SetPenColor(TRgb(yval, 255 - yval, 0));

 			gc->DrawLine(start, end);

 			}

 		}

 	gc->Deactivate();

 	aWindow.EndRedraw();

 	}

 /**

  * 	Causes the given window to be redrawn.

  * 	Doesn't draw anything except the background wipe, when the transparency manager hasn't

  * 

  **/

 void CWsDynamicResWinBase::DrawPlainUI(RWindow& aWindow,TBool aInvalidate,TRgb aWipeColor)

 	{

 	if (CWindowGc* gc=BeginActivateWithWipe(aInvalidate,aWindow,aWipeColor))

 		{

 		//actually does nothing!

 		gc->Deactivate();

 		aWindow.EndRedraw();

 		}

 	}

 /**

  *  	Interesting UI pattern used by other GCE tests.

  * 

  * 

  **/

 void CWsDynamicResWinBase::DrawCross(RWindow& aWindow, TRgb aColor, TInt aThickness)

 	{

 	aWindow.BeginRedraw();

 	CWindowGc* gc=(&aWindow==&iCompare)?iInfoGc:iGc;

 	gc->Activate(aWindow);

 	// Draw a red diagonal cross in the window.

 	gc->SetPenColor(aColor);

 	gc->SetPenSize(TSize(aThickness, aThickness));

 	gc->DrawLine(TPoint(0, 0), TPoint(KSurfaceWidth, KSurfaceHeight));

 	gc->DrawLine(TPoint(KSurfaceWidth, 0), TPoint(0, KSurfaceHeight));

 	gc->Deactivate();

 	aWindow.EndRedraw();

 	}

 /**

  * 	Checks the RGB value

  * 

  * 

  **/

 void CWsDynamicResWinBase::TestPixelL(TPoint aPt, TRgb aColor, TBool aMatch)

 	{

 	TRect screenArea(iScreenDevice->SizeInPixels());

 	if (aPt.iX < screenArea.iTl.iX)

 		{

 		aPt.iX = screenArea.iTl.iX;

 		}

 	else if (aPt.iX >= screenArea.iBr.iX)

 		{

 		aPt.iX = screenArea.iBr.iX - 1;

 		}

 	if (aPt.iY < screenArea.iTl.iY)

 		{

 		aPt.iY = screenArea.iTl.iY;

 		}

 	else if (aPt.iY >= screenArea.iBr.iY)

 		{

 		aPt.iY = screenArea.iBr.iY - 1;

 		}

 	TRgb pixel;

 	iScreenDevice->GetPixel(pixel, aPt);

 	if (aMatch)

 		{

 		ASSERT_EQUALS_X(pixel.Internal(), aColor.Internal());

 		}

 	else

 		{

 		ASSERT_NOT_EQUALS_X(pixel.Internal(), aColor.Internal());

 		}

 	}

 struct CountColour

 	{

 	TRgb	iColor;

 	TInt	iCount;

 	TBool operator  < (const CountColour& aRhs)const	

 		{	return iColor.Value()<aRhs.iColor.Value();	}

 	CountColour(TRgb	aColor,TInt	aCount=0): 

 			iColor(aColor),iCount(aCount) {}

 	CountColour(const CountColour& aRhs): 

 			iColor(aRhs.iColor),iCount(aRhs.iCount) {}

 	};

 void LogColorL(TRgb aPixel,RArray<CountColour>& aColors)

 	{

 	//I am sure one of the find methods would do this, but life is too short!

 	TInt existingIndex;

 	for (existingIndex=0;existingIndex<aColors.Count();existingIndex++)

 		if (aColors[existingIndex].iColor==aPixel)

 			break;

 	if (existingIndex==aColors.Count())

 		aColors.AppendL(CountColour(aPixel,1));

 	else

 		aColors[existingIndex].iCount++;

 	}

 /**

  * Tests the outline of the given rectangle to verify that it has the expected inner and outer colors

  * There may be a limited number of other colors present.

  * If the given count of other colors is exceeded then false is returned

  * If the majority of inner and outer edge pixels are not the given colors then returns false

  * If the  colors are repeated on inside and outside then returns false

  * If there are corners then the insides of the corners are also check for outside color

  * Note that the right and bottom edge coordinates are outside the rectangle.

  * Note that I am not performing any safety clipping at present. The rectangle must be on-screen!

  * A negative value for corner size indicates that the window may or may not have corners that size.

  * Only leaves if fatal memory condition!

 **/

 TBool CWsDynamicResWinBase::TestRectL(TRect aRect,TRgb aInnerColor,TInt aOtherInnerColors,TRgb aOuterColor,TInt aOtherOuterColors,TInt aExpectedCornerSize)

 	{

 	if (aRect.iTl.iX<=0 || aRect.iTl.iY<=0)

 		return ETrue;	//can't perform the test against the outside of the screen

 	//quantise the expectation based on the current mode.

 	TDisplayMode displayMode=iScreenDevice->DisplayMode();

 	switch (displayMode)

 		{

 	case EColor4K:

 		aInnerColor=aInnerColor.Color4K(aInnerColor.Color4K());

 		aOuterColor=aOuterColor.Color4K(aOuterColor.Color4K());

 		break;

 	case EColor64K:

 		aInnerColor=aInnerColor.Color64K(aInnerColor.Color64K());

 		aOuterColor=aOuterColor.Color64K(aOuterColor.Color64K());

 		break;

 	case EColor16M:

 	case EColor16MU:

 	case EColor16MA:

 	case EColor16MAP:

 		break;

 	default:

 		ASSERT_EQUALS(EColor16MA,displayMode);		//Can't quantise color for this display mode!

 		}

 	RArray<CountColour> innerColors;

 	innerColors.AppendL(aInnerColor);

 	RArray<CountColour> outerColors;

 	outerColors.AppendL(aOuterColor);

 	TInt cornerSize=aExpectedCornerSize>=0?aExpectedCornerSize:-aExpectedCornerSize;

 	//Check outside first!

 	TRgb pixelVal;

 	for(TPoint pixelPos(aRect.iTl.iX-1,aRect.iTl.iY-1);pixelPos.iX<aRect.iBr.iX;pixelPos.iX++)

 		{

 		iScreenDevice->GetPixel(pixelVal, pixelPos);

 		LogColorL(pixelVal,outerColors);

 		}

 	for(TPoint pixelPos(aRect.iTl.iX,aRect.iBr.iY);pixelPos.iX<=aRect.iBr.iX;pixelPos.iX++)

 		{

 		iScreenDevice->GetPixel(pixelVal, pixelPos);

 		LogColorL(pixelVal,outerColors);

 		}

 	for(TPoint pixelPos(aRect.iTl.iX-1,aRect.iTl.iY);pixelPos.iY<=aRect.iBr.iY;pixelPos.iY++)

 		{

 		iScreenDevice->GetPixel(pixelVal, pixelPos);

 		LogColorL(pixelVal,outerColors);

 		}

 	for(TPoint pixelPos(aRect.iBr.iX,aRect.iTl.iY-1);pixelPos.iY<aRect.iBr.iY;pixelPos.iY++)

 		{

 		iScreenDevice->GetPixel(pixelVal, pixelPos);

 		LogColorL(pixelVal,outerColors);

 		}

 	TInt cornerStart=1;

 	if (cornerSize)

 		{

 		cornerStart=cornerSize;

 		if (aExpectedCornerSize>0)

 			{

 			iScreenDevice->GetPixel(pixelVal, aRect.iTl);

 			LogColorL(pixelVal,outerColors);

 			iScreenDevice->GetPixel(pixelVal, TPoint(aRect.iTl.iX,aRect.iBr.iY-1));

 			LogColorL(pixelVal,outerColors);

 			iScreenDevice->GetPixel(pixelVal, TPoint(aRect.iBr.iX-1,aRect.iTl.iY));

 			LogColorL(pixelVal,outerColors);

 			iScreenDevice->GetPixel(pixelVal, TPoint(aRect.iBr.iX-1,aRect.iBr.iY-1));

 			LogColorL(pixelVal,outerColors);

 			}

 		}

 	//test inside edges (excluding 4 corner pixels - do them seperately)

 	for(TPoint pixelPos(aRect.iTl.iX+cornerStart,aRect.iTl.iY);pixelPos.iX<aRect.iBr.iX-cornerStart;pixelPos.iX++)

 		{

 		iScreenDevice->GetPixel(pixelVal, pixelPos);

 		LogColorL(pixelVal,innerColors);

 		}

 	for(TPoint pixelPos(aRect.iTl.iX+cornerStart,aRect.iBr.iY-1);pixelPos.iX<aRect.iBr.iX-cornerStart;pixelPos.iX++)

 		{

 		iScreenDevice->GetPixel(pixelVal, pixelPos);

 		LogColorL(pixelVal,innerColors);

 		}

 	for(TPoint pixelPos(aRect.iTl.iX,aRect.iTl.iY+cornerStart);pixelPos.iY<aRect.iBr.iY-cornerStart;pixelPos.iY++)

 		{

 		iScreenDevice->GetPixel(pixelVal, pixelPos);

 		LogColorL(pixelVal,innerColors);

 		}

 	for(TPoint pixelPos(aRect.iBr.iX-1,aRect.iTl.iY+cornerStart);pixelPos.iY<aRect.iBr.iY-cornerStart;pixelPos.iY++)

 		{

 		iScreenDevice->GetPixel(pixelVal, pixelPos);

 		LogColorL(pixelVal,innerColors);

 		}

 	//the 4 corner cells - not checking the whole corner area...

 	if (aExpectedCornerSize>=0)

 		{

 		iScreenDevice->GetPixel(pixelVal, TPoint(aRect.iTl.iX+cornerSize,aRect.iTl.iY+cornerSize));

 		LogColorL(pixelVal,innerColors);

 		iScreenDevice->GetPixel(pixelVal, TPoint(aRect.iTl.iX+cornerSize,aRect.iBr.iY-1-cornerSize));

 		LogColorL(pixelVal,innerColors);

 		iScreenDevice->GetPixel(pixelVal, TPoint(aRect.iBr.iX-1-cornerSize,aRect.iBr.iY-1-cornerSize));

 		LogColorL(pixelVal,innerColors);

 		iScreenDevice->GetPixel(pixelVal, TPoint(aRect.iBr.iX-1-cornerSize,aRect.iTl.iY+cornerSize));

 		LogColorL(pixelVal,innerColors);

 		}

 	//OK... that has tested all the pixels, now check the result

 	if (innerColors.Count()>aOtherInnerColors+1)

 		return EFalse;

 	if (outerColors.Count()>aOtherOuterColors+1)

 		return EFalse;

 	for (TInt index=1;index<innerColors.Count();index++)

 		if (innerColors[0].iCount<innerColors[index].iCount)

 			{

 			return EFalse;

 			}

 	for (TInt index=1;index<outerColors.Count();index++)

 		if (outerColors[0].iCount<outerColors[index].iCount)

 			{

 			return EFalse;

 			}

 	for (TInt indexIn=1;indexIn<innerColors.Count();indexIn++)

 		for (TInt indexOut=0;indexOut<outerColors.Count();indexOut++)

 			if (innerColors[indexIn].iColor.Value()==outerColors[indexOut].iColor.Value())

 				{

 				return EFalse;

 				}

 	return ETrue;

 	}

 TRect CWsDynamicResWinBase::PentCellRect(const TRect& aFullRect,char aStartLetter,char aEndLetter)

 	{

 	if (aEndLetter==0)

 		aEndLetter=aStartLetter;

 	aStartLetter&=0x1f;

 	aEndLetter&=0x1f;

 	TInt startx=(aStartLetter-1)%5;

 	TInt starty=(aStartLetter-1)/5;

 	TInt endx=(aEndLetter-1)%5;

 	TInt endy=(aEndLetter-1)/5;

 	if (starty>endy)

 		{	//swap			//	s		e

 		starty-=endy;		//	s-e

 		endy+=starty;		//			s					

 		starty=endy-starty;	//	e

 		}

 	if (startx>endx)

 		{	//swap			//	s		e

 		startx-=endx;		//	s-e

 		endx+=startx;		//			s					

 		startx=endx-startx;	//	e

 		}

 	TSize fullSize=aFullRect.Size();

 	return TRect(	aFullRect.iTl.iX+fullSize.iWidth*startx/5,

 					aFullRect.iTl.iY+fullSize.iHeight*starty/5,

 					aFullRect.iTl.iX+fullSize.iWidth*(endx+1)/5,

 					aFullRect.iTl.iY+fullSize.iHeight*(endy+1)/5

 				);

 	}