// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/**

 @file

 @test

 @internalComponent

*/

#include "t_wservintegstepbasic.h"

#include <test/tefunit.h>

#include <e32const.h>	//KNullUidValue

#include <pixelformats.h>

namespace t_wservintegstepbasic

	{

	static const TUint delay=100000;	//0.5 sec

	const TInt KSurfaceWidth = 50;

	const TInt KSurfaceHeight = 50;

	const TUidPixelFormat KSurfaceFormat = EUidPixelFormatXRGB_8888;

	const TInt KBytesPerPixel = 4;	// Four bytes per pixel for the format above.

	// Events delivered to this handle are thrown away

	const TUint32 ENullWsHandle = 0xFFFFFFFF;

	_LIT(KT_WServIntegStepBasicTestId,"testid");

	_LIT(KT_BasicStepPanicTxt, "t_wservintegstepbasic");

	}

using namespace t_wservintegstepbasic;

CT_WServIntegStepBasic::CT_WServIntegStepBasic()

	{

	SetTestStepName(KT_WServIntegStepBasic);

	}

CT_WServIntegStepBasic::~CT_WServIntegStepBasic()

	{

	delete iGc;

	delete iScreen;

	iWinGroup.Close();

	iWsSession.Flush();

	iWsSession.Close();

	}

enum TVerdict CT_WServIntegStepBasic::doTestStepPreambleL()

	{

	TVerdict ret=CTestStep::doTestStepPreambleL();

	if ( !GetIntFromConfig( ConfigSection(), KT_WServIntegStepBasicTestId, iTestId ) )

		{

		User::Leave(KErrNotFound);

		}

	else

		{

		User::LeaveIfError(iWsSession.Connect());

		iScreen = new (ELeave) CWsScreenDevice(iWsSession);

		User::LeaveIfError(iScreen->Construct());

		iWinGroup  = RWindowGroup(iWsSession);

		User::LeaveIfError(iWinGroup.Construct(ENullWsHandle) );

		iWinGroup.AutoForeground(ETrue);

		iGc = new (ELeave) CWindowGc(iScreen);

		User::LeaveIfError(iGc->Construct());

		iWsSession.Flush();

		}

	return ret;

	}

enum TVerdict CT_WServIntegStepBasic::doTestStepPostambleL()

	{

	return TestStepResult();

	}

/**

Starts test step

More detail on each test step can be

found in the respective script file.

@internalComponent

@return TVerdict pass / fail

@pre N/A

@post N/A

*/

enum TVerdict CT_WServIntegStepBasic::doTestStepL()

	{

	__UHEAP_MARK;

	RWindow win;

	RBlankWindow blankWin;

	switch( iTestId )

		{

		case 1:

			Graphics_Wserv_Gce_1L(win);

			break;

		case 2:

			Graphics_Wserv_Gce_2L(blankWin);

			break;

		case 3:

			Graphics_Wserv_Gce_3L();

			break;

		case 4:

			Graphics_Wserv_Gce_4L(win);

			break;

		case 5:

			Graphics_Wserv_Gce_5L(win);

			break;

		case 6:

			Graphics_Wserv_Gce_6L(win);

			break;

		case 7:

			//Test removed in CR1489

			break;

		case 8:

			//Test removed in CR1489

			break;

		case 9:

			//Test removed in CR1489

			break;

		case 10:

			//Test removed in CR1489

			break;

		case 11:

			Graphics_Wserv_Gce_11L(win);

			break;

		case 12:

			//Test removed in CR1489

			break;

		case 13:

			Graphics_Wserv_Gce_13L(win);

			break;

		case 14:

			//Test removed in CR1489

			break;

		case 15:

			Graphics_Wserv_Gce_15L(win);

			break;

		case 16:

			//Test removed in CR1489

			break;

		case 17:

			Graphics_Wserv_Gce_17L(win);

			break;

		case 18:

			//Test removed in CR1489

			break;

		case 19:

			Graphics_Wserv_Gce_19L(win);

			break;

		case 20:

			//Test removed in CR1489

			break;

		case 21:

			Graphics_Wserv_Gce_21L(win);

			break;

		case 22:

			Graphics_Wserv_Gce_22L(win);

			break;

		case 23:

			//Test removed in CR1489

			break;

		case 24:

			//Test removed in CR1489

			break;

		case 25:

			//Test removed in CR1489

			break;

		case 26:

			//Test removed in CR1489

			break;

		case 27:

			//Test removed in CR1489

			break;

		case 28:

			//Test removed in CR1489

			break;

		case 29:

			//Test removed in CR1489

			break;

		case 30:

			//Test removed in CR1489

			break;

		case 31:

			Graphics_Wserv_Gce_31L(blankWin);

			break;

		case 32:

			Graphics_Wserv_Gce_32L(win);

			break;

		case 33:

			Graphics_Wserv_Gce_33L(win);

			break;

		case 34:

			Graphics_Wserv_Gce_34L(win);

			break;

		case 35:

			Graphics_Wserv_Gce_35L(win);

			break;

		case 36:

			Graphics_Wserv_Gce_36L(win);

			break;

		case 37:

			//Test removed in CR1489

			break;

		default:

			User::Panic(KT_BasicStepPanicTxt, KErrNotFound);  //Unexpected value!

		}

	__UHEAP_MARKEND;

	return TestStepResult();

	}

//Test setting a surface as the background of a window

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_1L(RWindow& aWin)

	{

	CreateSurfaceL(iSurfaceId);

	CreateRWindowL(aWin);

	TEST(KErrNone==aWin.SetBackgroundSurface(iSurfaceId));

	ForceWindowToRedraw(aWin);

	DestroySurface();

	aWin.Close();

	}

//Test setting a surface as the background of a RBlankWindow

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_2L(RBlankWindow& aBlankWin)

	{

	CreateSurfaceL(iSurfaceId);

	CreateRBlankWindowL(aBlankWin);

	TEST(KErrNone==aBlankWin.SetBackgroundSurface(iSurfaceId));

	ForceWindowToRedraw(aBlankWin);

	DestroySurface();

	aBlankWin.Close();

	}

//Negative test for setting a surface as the background of a RBackedUpWindow

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_3L()

	{

	CreateSurfaceL(iSurfaceId);

	RBackedUpWindow backedUpWindow( iWsSession );

	CleanupClosePushL( backedUpWindow );

	User::LeaveIfError( backedUpWindow.Construct( iWinGroup, EColor16MA, ENullWsHandle) );

	backedUpWindow.SetSizeErr( iScreen->SizeInPixels() );

	backedUpWindow.SetVisible( ETrue );

	backedUpWindow.Activate();

	iWsSession.Flush();

	User::After(delay);

	// Expect a panic here - TClientPanic::EWservPanicDrawable

	backedUpWindow.SetBackgroundSurface( iSurfaceId );

	DestroySurface();

	CleanupStack::PopAndDestroy( &backedUpWindow );

	}

//Test for moving a window with its background set

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_4L(RWindow& aWin)

	{

	// Create window and assign a surface to it

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	TSize scrSize(iScreen->SizeInPixels());

	// move the window around

	aWin.SetPosition( TPoint( (scrSize.iWidth)-KTempWindowWidth, 0) );

	iWsSession.Flush();

	User::After(delay);

	aWin.SetPosition( TPoint(aWin.Position().iX, (scrSize.iHeight)-KTempWindowHeight ));

	iWsSession.Flush();

	User::After(delay);

	aWin.SetPosition( TPoint(0, (scrSize.iHeight)-KTempWindowHeight) );

	iWsSession.Flush();

	User::After(delay);

	aWin.SetPosition(TPoint(0,0));

	iWsSession.Flush();

	User::After(delay);

	DestroySurface();

	aWin.Close();

		}

//Test moving a window with its background set partially and wholly offscreen

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_5L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	TSize screenSize(iScreen->SizeInPixels());

	// partially off screen

	TUint xCord=(screenSize.iWidth-KTempWindowWidth)+(KTempWindowWidth/2);

	TUint yCord=(screenSize.iHeight-KTempWindowHeight)+(KTempWindowHeight/2);

	aWin.SetPosition(TPoint(xCord,yCord));

	iWsSession.Flush();

	User::After(delay);

	// wholly off screen

	aWin.SetPosition( TPoint(screenSize.iWidth, screenSize.iHeight) );

	iWsSession.Flush();

	User::After(delay);

	DestroySurface();

	aWin.Close();

	}

//Test resizing a window with its background set to a surface

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_6L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	TSize sz(aWin.Size());

	aWin.SetSize( sz+TPoint(20,0) );

	iWsSession.Flush();

	User::After( delay );

	aWin.SetSize( sz+TPoint(0,20) );

	iWsSession.Flush();

	User::After( delay );

	aWin.SetSize( sz+TPoint(20,20) );

	iWsSession.Flush();

	User::After( delay );

	aWin.SetSize( TSize(KSurfaceWidth, KSurfaceHeight ) );

	iWsSession.Flush();

	User::After( delay );

  	DestroySurface();

	aWin.Close();

	}

// Test Opaque drawing in front of a background surface

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_11L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	// Opaque drawing on bkgd surface

	DrawShape( aWin, 0x0000FF00 );

	DestroySurface();

	aWin.Close();

	}

//Test Semi-transparent drawing in front of a background surface

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_13L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	// semi Transp on bkgd surface

	DrawShape( aWin, 0x8000FF00 );

	DestroySurface();

	aWin.Close();

	}

//Test that an opaque window can be put in front of an Rwindow with background surface

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_15L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	CleanupClosePushL(aWin);

	// draw 2nd window partially over the first one

	RWindow win2;

	CreateRWindowL(win2, TPoint(10,10), KRgbGreen );

	DestroySurface();

	CleanupStack::PopAndDestroy(&aWin);

	win2.Close();

	aWin.Close();

	}

//Test that a semi-transparent window can be put in front of a Rwindow with surface

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_17L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	CleanupClosePushL(aWin);

	// draw semi Transp win partially over first win with surface

	RWindow win2;

	CreateRWindowL(win2, TPoint(10,10));

	INFO_PRINTF1(_L("Destroy Surface"));

	DestroySurface();

	CleanupStack::PopAndDestroy(&aWin);

	win2.Close();

	aWin.Close();

	}

//Test updating a background surface

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_19L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	CleanupClosePushL(aWin);

	// create a 2nd surface

	TSurfaceId surfaceId2;

	CreateSurfaceL(surfaceId2, 0x0000FF00);

	ASSERT_EQUALS( KErrNone, aWin.SetBackgroundSurface(surfaceId2) );

	ForceWindowToRedraw(aWin);

	TInt ret = iSurfaceManager.CloseSurface(surfaceId2);

	if(ret!=KErrNone)

		{

		INFO_PRINTF1(_L("Surface manager failed to close surface"));

		}

	// destroys iSurfaceId plus closes iSurfaceUpdateSession,iChunk,iSurfaceManager

	DestroySurface();

	CleanupStack::PopAndDestroy(&aWin);

	}

//Test shape of a window is applied to window a surface

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_21L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	TRect rc[2] = { TRect(0,0,100,200),TRect(100,120,200,200) };

	RRegion region(2, rc);

	aWin.SetShape( region );

	User::After(delay);	// For DEBUG

	DestroySurface();

	aWin.Close();

	}

//Test that a valid key color is returned when a surface

//has been set as the background of a window

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_22L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	TRgb colValue(aWin.KeyColor());

	if ( aWin.DisplayMode()==EColor16MA || aWin.DisplayMode()==EColor16MAP )

		{

		TEST(aWin.KeyColor().Internal()==0x00000000);

		}

	else

		{

		TEST(aWin.KeyColor().Alpha()==0xFF);

		}

	aWin.Close();

	}

//Test that the use of SetColor() i.e. with no parameters removes

//any surface assigned to the window

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_31L(RBlankWindow& aBlankWin)

	{

	CreateSurfaceL(iSurfaceId);

	CreateRBlankWindowL(aBlankWin);

	ASSERT_EQUALS(KErrNone, aBlankWin.SetBackgroundSurface(iSurfaceId));

	ForceWindowToRedraw(aBlankWin);

	aBlankWin.SetColor();

	ForceWindowToRedraw(aBlankWin);

	DestroySurface();

	aBlankWin.Close();

	}

//Test that the shaped window maintains the surface when moved

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_32L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	TRect rc[2] = { TRect(0,0,100,200),TRect(100,120,200,200) };

	RRegion region(2, rc);

	aWin.SetShape( region );

	User::After(delay);

	aWin.SetPosition( TPoint( aWin.Position().iX+10, aWin.Position().iY+10 ) );

	iWsSession.Flush();

	User::After(delay);

	DestroySurface();

	aWin.Close();

	}

//Test that window and surface scale to the new size when a shaped

//window with surface is resized

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_33L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	TRect rc[2] = { TRect(0,0,100,200),TRect(100,120,200,200) };

	RRegion region(2, rc);

	aWin.SetShape( region );

	User::After(delay);

	aWin.SetSize( TSize(200,150) );

	iWsSession.Flush();

	User::After(delay);

	DestroySurface();

	aWin.Close();

	}

//Test that the background surface blends with the semi transparent window

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_34L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	CleanupClosePushL(aWin);

	ForceWindowToRedraw(aWin);

	RWindow win2;

	CreateRWindowL(win2,TPoint(10,0), 0x80A9B9C9);

	// draw semi Transp on window bkgd

	DrawShape( win2, 0x8000FF00 );

	DestroySurface();

	CleanupStack::PopAndDestroy(&aWin);

	win2.Close();

	aWin.Close();

	}

// Test that the corner style is applied to the window with surface

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_35L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	aWin.SetCornerType( EWindowCorner5 );

	User::After(delay);

	DestroySurface();

	aWin.Close();

	}

/***

Test that shaped windows with background surfaces arranged such that

the back window overlaps the front's bounding box, but not its shaped

region (e.g. the front is L-shaped and the back overlaps the area within

the 'L'). In this situation, the back window's surface should be visible

in the overlap area

*/

void CT_WServIntegStepBasic::Graphics_Wserv_Gce_36L(RWindow& aWin)

	{

	ASSERT_EQUALS( EPass, SetSurfaceL(aWin,iSurfaceId));

	CleanupClosePushL(aWin);

	TRect rc1[2] = { TRect(110,20,150,80),TRect(150,60,200,100) };

	RRegion region1(2, rc1);

	aWin.SetShape( region1 );

	User::After(delay);

	// create a 2nd surface

	TSurfaceId surfaceId2;

	CreateSurfaceL(surfaceId2,0x00ABCDEF);

	RWindow win2;

	CreateRWindowL(win2);

	ASSERT_EQUALS( KErrNone, win2.SetBackgroundSurface(surfaceId2));

	User::After(delay);

	TRect rc2[2] = { TRect(0,0,100,200),TRect(100,120,200,200) };

	RRegion region2(2, rc2);

	win2.SetShape( region2 );

	User::After(delay);

	TInt ret = iSurfaceManager.CloseSurface(surfaceId2);

	if(ret!=KErrNone)

		{

		INFO_PRINTF1(_L("Surface manager failed to close surface"));

		}

	// destroys iSurfaceId plus closes iSurfaceUpdateSession,iChunk,iSurfaceManager

	DestroySurface();

	CleanupStack::PopAndDestroy(&aWin);

	win2.Close();

	aWin.Close();

	}

/**

Creates a RWindow

@param aWin	The window object

@param aPos	The Position of the window

@param aBkgdColor The background color of the window

@param aSize The size of the window

*/

void CT_WServIntegStepBasic::CreateRWindowL(RWindow& aWin, const TPoint& aPos, const TRgb& aBkgdColor, const TSize& aWinSize)

	{

	aWin = RWindow( iWsSession );

	CleanupClosePushL( aWin );

	User::LeaveIfError( aWin.Construct( iWinGroup, ENullWsHandle ) );

	CleanupStack::Pop(&aWin);

	aWin.SetExtent(aPos, aWinSize);

	aWin.SetBackgroundColor( aBkgdColor );

	aWin.Activate();

	aWin.BeginRedraw();

	aWin.EndRedraw();

	aWin.SetVisible( ETrue );

	iWsSession.Flush();

	User::After(delay);

	}

/**

Creates a RBlankWindow

@param aBlankWin The window object

*/

void CT_WServIntegStepBasic::CreateRBlankWindowL(RBlankWindow& aBlankWin)

	{

	aBlankWin = RBlankWindow(iWsSession);

	CleanupClosePushL(aBlankWin);

	User::LeaveIfError(aBlankWin.Construct(iWinGroup, ENullWsHandle) );

	TSize sz( KTempWindowWidth, KTempWindowHeight );

	aBlankWin.SetSize(sz);

	aBlankWin.SetColor(TRgb(0x800000FF));	// 0xAABBGGRR

	aBlankWin.Activate();

	CleanupStack::Pop(&aBlankWin);

	iWsSession.Flush();

	User::After(delay);

	}

void CT_WServIntegStepBasic::ForceWindowToRedraw(RWindowBase& aWin)

	{

	aWin.SetVisible( EFalse );

	iWsSession.Flush();

	aWin.SetVisible( ETrue );

	iWsSession.Flush();

	User::After(delay);

	}

void CT_WServIntegStepBasic::CreateSurfaceManager()

	{

	INFO_PRINTF1(_L("Loading the device driver"));

	TInt ret = iSurfaceManager.Open();

	if(ret==KErrNone)

		{

		INFO_PRINTF1(_L("Creating surface manager OK"));

		}

	}

/**

Set up code for creating a surface and fill it with a color

@param aSurfaceId The surface object, to be initialized.

@param aColorPattern The color to fill the surface with.

*/

void CT_WServIntegStepBasic::CreateSurfaceL(TSurfaceId& aSurfaceId, TUint aColorPattern)

	{

	INFO_PRINTF1(_L("Creating a surface manager"));

	CreateSurfaceManager();

	INFO_PRINTF1(_L("Setting up surface attributes"));

	RSurfaceManager::TSurfaceCreationAttributesBuf attribs;

	RSurfaceManager::TSurfaceCreationAttributes& surfaceCreationAtribs=attribs();

	surfaceCreationAtribs.iSize.iWidth = KSurfaceWidth;

	surfaceCreationAtribs.iSize.iHeight = KSurfaceHeight;

	surfaceCreationAtribs.iBuffers = 1;

	surfaceCreationAtribs.iPixelFormat = KSurfaceFormat;

	surfaceCreationAtribs.iStride = KBytesPerPixel*KSurfaceWidth;

	surfaceCreationAtribs.iOffsetToFirstBuffer = 0;

	surfaceCreationAtribs.iAlignment = 4;

	surfaceCreationAtribs.iContiguous = EFalse;

	surfaceCreationAtribs.iMappable = ETrue;

	INFO_PRINTF1(_L("Call to CreateSurfaceL()"));

	TInt err = iSurfaceManager.CreateSurface(attribs, aSurfaceId);

	if (err == KErrNone)

		{

		//we have a surface, so map it in

		INFO_PRINTF1(_L("Surface created ok, mapping to it"));

		TInt err = iSurfaceManager.MapSurface(aSurfaceId, iChunk);

		User::LeaveIfError(err);

		TUint32* surfacePtr = reinterpret_cast<TUint32*>(iChunk.Base());

		TUint32* linePtr = surfacePtr;

		// Fill first line

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

			{

			surfacePtr[xx] = aColorPattern;

			}

		// Now copy that to the other lines

		TInt stride = KBytesPerPixel * KSurfaceWidth;

		for (TInt yy = 1; yy < KSurfaceHeight; yy++)

			{

			linePtr += KSurfaceWidth;

			Mem::Move(linePtr, surfacePtr, stride);

			}

		}

	INFO_PRINTF1(_L("Create Surface update session"));

	CreateSurfaceUpdateSessionL();

	err = iSurfaceUpdateSession.SubmitUpdate(KAllScreens, aSurfaceId, 0, NULL);

	if (err!=KErrNone)

		{

	   INFO_PRINTF1(_L("Fail in submitting update"));

		}

	}

void CT_WServIntegStepBasic::CreateSurfaceUpdateSessionL()

	{

	TInt ret = iSurfaceUpdateSession.Connect();

	if (ret==KErrAlreadyExists)

		{

		INFO_PRINTF1(_L("Device driver already loaded"));

		}

	else if (ret==KErrNone)

		{

		INFO_PRINTF1(_L("Connected to surface update server"));

		}

	else

		{

		INFO_PRINTF1(_L("Fatal error connecting to surface update server"));

		User::LeaveIfError(ret);

		}

	}

void CT_WServIntegStepBasic::DestroySurface()

	{

	INFO_PRINTF1(_L("Destroy Surface update session"));

	iSurfaceUpdateSession.Close();

	//close the chunk

	INFO_PRINTF1(_L("Closing chunk"));

	iChunk.Close();

	INFO_PRINTF1(_L("Closing surface"));

	TInt ret = iSurfaceManager.CloseSurface(iSurfaceId);

	if(ret!=KErrNone)

		{

		INFO_PRINTF1(_L("Surface manager failed to close"));

		}

	INFO_PRINTF1(_L("Destroy Surface Manager"));

	iSurfaceManager.Close();

	}

/**

Common set up code for assigning a surface to the window. Calls other utility

functions for creating a window and a surface

@param aWin	The window object

@param aSurfaceId	The surface object, to be initialized.

*/

TVerdict CT_WServIntegStepBasic::SetSurfaceL(RWindow& aWin, TSurfaceId& aSurfaceId)

	{

	TVerdict verdict=EPass;

	CreateRWindowL(aWin);

	CleanupClosePushL(aWin);

	CreateSurfaceL( aSurfaceId );

	CleanupStack::Pop(&aWin);

	if ( aWin.SetBackgroundSurface(aSurfaceId)!=KErrNone)

		{

		verdict=EFail;

		}

	iWsSession.Flush();

	ForceWindowToRedraw(aWin);

	return verdict;

	}

/**

Draw an Ellipse shape

@param aWin	The window object, connected to a session

@param aColor The (transparent/opaque)color which the shape is filled with

*/

void CT_WServIntegStepBasic::DrawShape(RWindow& aWin, const TRgb& aColor)

	{

   	iGc->Activate( aWin );

   	iGc->SetBrushColor( aColor );

   	iGc->SetBrushStyle( CGraphicsContext::ESolidBrush );

   	TRect rect(TPoint(0,0), TPoint(aWin.Size().iWidth, aWin.Size().iHeight));

   	iGc->DrawEllipse(rect);

   	iWsSession.Flush();

   	User::After(delay);

   	iGc->Deactivate();

	}