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

// Test multiple level transparent window

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TMulTran.H"

LOCAL_D TDisplayMode DisplayMode=EColor64K;

LOCAL_D TSize WinSize;

static const TRgb KRed=TRgb(255, 0, 0, 128);

static const TRgb KGreen=TRgb(0, 255, 0, 128);

static const TRgb KYellow=TRgb(255, 255, 0, 128);

static const TRgb KBlue=TRgb(0, 0, 255, 128);

static const TRgb KCyan=TRgb(0, 255, 255, 128);

/*CTransWindow*/

CTransWindow* CTransWindow::NewL(RPointerArray<CTransWindow>& aWindows,TRgb aColor,TRect aPos)

	{

	CTransWindow* self=NewL(TheClient->iGroup,aColor,aPos,&DisplayMode);

	aWindows.Insert(self,0);

	return self;

	}

CTransWindow* CTransWindow::NewL(CTWinBase* aParent,TRgb aColor,TRect aPos, TDisplayMode* aDisplayMode)

	{

	CTransWindow* self=new(ELeave) CTransWindow(aColor);

	CleanupStack::PushL(self);

	self->SetUpL(aPos.iTl,aPos.Size(),aParent,*TheClient->iGc,aDisplayMode);

	User::LeaveIfError(self->iError);

	CleanupStack::Pop(self);

	return self;

	}

//the following function doesn't activate a window

CTransWindow* CTransWindow::NewL(CTWinBase* aParent,TRgb aColor,TDisplayMode* aDisplayMode)

	{

	CTransWindow* self=new(ELeave) CTransWindow(aColor);

	CleanupStack::PushL(self);

	self->ConstructL(*aParent);

	if (aDisplayMode)

		{

		self->BaseWin()->SetRequiredDisplayMode(*aDisplayMode);

		}

	User::LeaveIfError((self->iError) && (self->iError != KErrNotSupported));

	CleanupStack::Pop(self);

	return self;

	}

void CTransWindow::InitWin()

	{

	AdjustShadow(-1);

	iShadowHight=0;

	iWin.SetShadowDisabled(ETrue);

	iShadowing=EFalse;

	iError = iWin.SetTransparencyAlphaChannel();

	iWin.SetBackgroundColor(iCol);

	iDrawOpaque=EFalse;

	}

void CTransWindow::ToggleVisibility()

	{

	iVisible=!iVisible;

	SetVisible(iVisible);

	}

void CTransWindow::SetOrdinal(RPointerArray<CTransWindow>& aWindows,TInt aOldPos,TInt aNewPos)

	{

	CTransWindow* win=aWindows[aOldPos];

	aWindows.Remove(aOldPos);

	aWindows.Insert(win,aNewPos);

	win->iWin.SetOrdinalPosition(aNewPos);

	}

void CTransWindow::SetShadowDisabled(TBool aState)

	{

	iWin.SetShadowDisabled(aState);

	iShadowing=!aState;

	}

void CTransWindow::AdjustShadow(TInt aAdjust)

	{

	CBlankWindow::AdjustShadow(aAdjust);

	iShadowHight+=aAdjust;

	}

TPoint CTransWindow::Position() const

	{

	return CBlankWindow::Position()+iPosOffset;

	}

void CTransWindow::Draw()

	{

	//don't call CBlankWindow::Draw() since the background is already drawn

	if(iDrawOpaque)

		{

		iGc->SetPenStyle(CGraphicsContext::ESolidPen);

		iGc->SetPenSize(TSize(4,4));

		iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

		iGc->SetPenColor(~iCol);

		iGc->SetOpaque(ETrue);

		iGc->DrawLine(TPoint(0,0),TPoint(1000,1000));

		iGc->SetOpaque(EFalse);

		}

	}

/*CTMultipleTrans*/

CTMultipleTrans::CTMultipleTrans(CTestStep* aStep) : CTWsGraphicsBase(aStep), iWindows(5), iShadows(EFalse)

	{

	}

CTMultipleTrans::~CTMultipleTrans()

	{

	((CTMultipleTransStep*)iStep)->CloseTMSGraphicsStep();

	delete iBackgroundWin;

	delete iCheckWin;

	delete iCheckBitmap;

	iWindows.ResetAndDestroy();

	iBlankWin.Close();

	}

void CTMultipleTrans::ConstructL()

	{

	if(TransparencySupportedL() == KErrNotSupported)

		return;

	iMajorTest=0;

	const TSize scrSize(TheClient->iScreen->SizeInPixels());

	WinSize.SetSize(scrSize.iWidth/2,scrSize.iHeight);

	iBackgroundWin=new(ELeave) CTBlankWindow();

	iBackgroundWin->SetUpL(TPoint(),WinSize,TheClient->iGroup,*TheClient->iGc);

	TheClient->WaitForRedrawsToFinish();

	CTBackedUpWin* checkWin=new(ELeave) CTBackedUpWin(DisplayMode);

	checkWin->ConstructExtLD(*TheClient->iGroup,TPoint(WinSize.iWidth,0),WinSize);

	iCheckWin=checkWin;

	RBackedUpWindow& backWin=*iCheckWin->BackedUpWin();

	backWin.SetShadowHeight(0);

	iCheckWin->Activate();

	backWin.MaintainBackup();

	iCheckBitmap=CBitmap::NewL(backWin.BitmapHandle());

	iCheckBitmap->Gc().SetPenStyle(CGraphicsContext::ENullPen);

	iCheckBitmap->Gc().SetBrushStyle(CGraphicsContext::ESolidBrush);

	TheClient->Flush();

	TheClient->WaitForRedrawsToFinish();

	RecreateWindowsL();

	iBlankWin=RBlankWindow(TheClient->iWs);

	User::LeaveIfError(iBlankWin.Construct(*TheClient->iGroup->WinTreeNode(),ENullWsHandle));

	iBlankWinVis=EFalse;

	iBlankWin.SetVisible(iBlankWinVis);

	User::LeaveIfError(iBlankWin.SetRequiredDisplayMode(EColor256));

	iBlankWinCol=TRgb(170,170,170);		//Grey

	iBlankWin.SetColor(iBlankWinCol);

	iBlankWin.SetOrdinalPosition(0,1);		//Set the priority to 1 so that the 4 main windows are the first 4 with priory 0

	iBlankWin.Activate();

	iOpacitySupported=EFalse;

	}

void CTMultipleTrans::ShadowRegion(TRegion& aRegion,TInt aWin)

	{

	TRect rect;

	TInt height;

	TInt window;

	aRegion.Clear();

	RRegion single;

	RRegion noShadow1;

	RRegion noShadow2;

	RRegion temp;

	RRegion temp2;

	for (window=0;window<aWin;++window)

		{

		CTransWindow& win=*iWindows[window];

		if (win.IsVisible())

			{

			rect.SetRect(win.Position(),win.Size());

			height=win.ShadowHeight();

			temp.Copy(single);

			temp.ClipRect(rect);

			noShadow1.Union(temp);

			temp.Clear();

			temp.AddRect(rect);

			temp.SubRegion(noShadow1);

			temp.SubRegion(noShadow2);

			temp.SubRegion(aRegion,&temp2);

			noShadow2.Union(temp2);

			temp2.Clear();

			single.Union(temp);

			if (win.IsShadowing())

				aRegion.AddRect(rect);

			aRegion.Offset(2*height,2*height);

			aRegion.Tidy();

			noShadow1.Tidy();

			noShadow2.Tidy();

			single.Tidy();

			}

		}

	if (window<iWindows.Count())

		{

		CTransWindow& win=*iWindows[window];

		rect.SetRect(win.Position(),win.Size());

		aRegion.ClipRect(rect);

		}

	aRegion.SubRegion(noShadow1);

	aRegion.SubRegion(noShadow2);

	aRegion.Tidy();

	noShadow1.Close();

	noShadow2.Close();

	single.Close();

	temp.Close();

	temp2.Close();

	}

void CTMultipleTrans::CheckDisplay()

	{

	RRegion shadowRegion;

	CFbsBitGc& gc=iCheckBitmap->Gc();

	gc.SetBrushColor(KRgbWhite);

	gc.DrawRect(TRect(WinSize));

	TInt windows=iWindows.Count();

	if (iShadows)

		{

		ShadowRegion(shadowRegion,windows);

		gc.ShadowArea(&shadowRegion);

		}

	TInt window;

	for (window=windows;window>0;)

		{

		CTransWindow& win=*iWindows[--window];

		if (win.IsVisible())

			{

			gc.SetBrushColor(win.Color());

			const TPoint& winTopLeft=win.Position();

			gc.DrawRect(TRect(winTopLeft, win.Size()));

			if(win.DrawOpaque())

				{

				gc.SetPenColor(~(win.Color()));

				gc.SetPenSize(TSize(4,4));

				gc.SetPenStyle(CGraphicsContext::ESolidPen);

				gc.SetClippingRect(TRect(TPoint(winTopLeft.iX,winTopLeft.iY),TPoint(winTopLeft.iX + win.Size().iWidth, winTopLeft.iY + win.Size().iHeight)));

				gc.DrawLine(TPoint(winTopLeft.iX,winTopLeft.iY),TPoint(winTopLeft.iX+1000, winTopLeft.iY+1000));

				gc.SetPenStyle(CGraphicsContext::ENullPen);

				gc.SetClippingRect(TRect(WinSize));

				}

			if (iShadows)

				{

				ShadowRegion(shadowRegion,window);

				gc.ShadowArea(&shadowRegion);

				}

			}

		}

	iCheckWin->BackedUpWin()->UpdateScreen();

	TheClient->Flush();

	if (windows>=4)

		{

		AdvancedCheckRect();

		}

	_LIT(KTest,"Multiple Transparent Test, SubTest %d, OpacityOn=%d");

	TBuf<128> buf;

	buf.Format(KTest,iTest->iState,iMajorTest);

	CheckRect(iBackgroundWin,iCheckWin,TRect(WinSize),buf);

	shadowRegion.Close();

	}

#define OFFSET 2

void CTMultipleTrans::AdvancedCheckRect()

	{

	const TSize compareSize(5,5);

	const TInt OFFSET2=OFFSET+compareSize.iWidth;

	TPoint comparePos=iCheckWin->Position();

	TPoint checkPos;

	//Check Single Level for Top Left Win

	checkPos=iTopLeft->Position()+TPoint(OFFSET,OFFSET);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	//Check Single Level for Top Right Win

	checkPos=iTopRight->Position()+TPoint(iTopRight->Size().iWidth-OFFSET2,OFFSET);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	//Check Single Level for Bottom Left Win

	checkPos=iBotLeft->Position()+TPoint(OFFSET,iBotLeft->Size().iHeight-OFFSET2);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	//Check Single Level for Bottom Right Win

	checkPos=iBotRight->Position()+TPoint(iBotRight->Size().iWidth-OFFSET2,iBotRight->Size().iHeight-OFFSET2);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	//Double level top 2 windows

	checkPos=iTopRight->Position()+TPoint(OFFSET,OFFSET);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	//Double level left 2 windows

	checkPos=iBotLeft->Position()+TPoint(OFFSET,OFFSET);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	//Double level bot 2 windows

	checkPos=iBotRight->Position()+TPoint(OFFSET,iBotRight->Size().iHeight-OFFSET2);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	//Double level right 2 windows

	checkPos=iBotRight->Position()+TPoint(iBotRight->Size().iWidth-OFFSET2,OFFSET);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	//Triple level all but bot right

	checkPos=iTopRight->Position()+TPoint(OFFSET,iTopRight->Size().iHeight-OFFSET2);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	//Triple level all but bot left

	checkPos=iBotRight->Position()+TPoint(OFFSET,OFFSET);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	//Triple level all but top right

	checkPos=iTopLeft->Position()+TPoint(iTopLeft->Size().iWidth-OFFSET2,iTopLeft->Size().iHeight-OFFSET2);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	//Triple level all but top left

	checkPos=iBotLeft->Position()+TPoint(iBotLeft->Size().iWidth-OFFSET2,OFFSET);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	//Quad level

	checkPos=TPoint(iBotRight->Position().iX,iBotLeft->Position().iY)+TPoint(OFFSET,OFFSET);

	CheckRect(checkPos,checkPos+comparePos,compareSize);

	}

void CTMultipleTrans::SimpleTest()

	{

	CheckDisplay();

	}

void CTMultipleTrans::ChangeVisibility()

	{

	TUint toggle;

	TUint toggle2;

	TInt win;

	TInt ii=0;

	for (ii=2;ii>0;--ii)

		{

		for (toggle=1;toggle<16;++toggle)

			{

			win=0;

			toggle2=toggle;

			while ((toggle2&0x1)==0)

				{

				++win;

				toggle2/=2;

				}

			iWindows[win]->ToggleVisibility();

			CheckDisplay();

			}

		}

	}

void CTMultipleTrans::ChangeVisibility2()

	{

	iBlankWin.SetOrdinalPosition(0,0);

	iBlankWin.SetVisible(ETrue);

	iBlankWin.SetVisible(EFalse);

	CheckDisplay();

	const TInt xSteps=4;

	const TInt ySteps=3;

	iBlankWinSize.SetSize(WinSize.iWidth/xSteps,WinSize.iHeight/ySteps);

	iBlankWin.SetSize(iBlankWinSize);

	TInt ordPos,xx,yy;

	for (ordPos=0;ordPos<=4;++ordPos)

		{

		iBlankWin.SetOrdinalPosition(ordPos);

		for (xx=0;xx<xSteps;++xx)

			{

			TInt xPos=xx*WinSize.iWidth/xSteps;

			for (yy=0;yy<ySteps;++yy)

				{

				iBlankWin.SetPosition(TPoint(xPos,yy*WinSize.iHeight/ySteps));

				iBlankWin.SetVisible(ETrue);

				iBlankWin.SetVisible(EFalse);

				CheckDisplay();

				}

			}

		}

	iBlankWin.SetOrdinalPosition(0,1);

	}

void CTMultipleTrans::OrdinalPos()

	{

	TInt ii,jj,kk;

	for (kk=2;kk>=0;--kk)

		{

		for (jj=3;jj>kk;--jj)

			{

			for (ii=jj;ii>=kk;--ii)

				{

				CTransWindow::SetOrdinal(iWindows,jj,kk);

				CheckDisplay();

				}

			}

		}

	for (kk=2;kk>=0;--kk)

		{

		for (jj=3;jj>kk;--jj)

			{

			for (ii=jj;ii>=kk;--ii)

				{

				CTransWindow::SetOrdinal(iWindows,kk,jj);

				CheckDisplay();

				}

			}

		}

	}

TSize CTMultipleTrans::GetSize(TInt aPos)

	{		//Comments show values for 640x240 screen

	const TInt halfSize=40;

	const TPoint topLeft=iTopLeft->Position();	//10,10

	const TInt xLeft=WinSize.iWidth/2-topLeft.iX-halfSize;		//110

	const TInt xRight=xLeft+2*halfSize;		//190

	const TInt yTop=WinSize.iHeight/2-topLeft.iY-halfSize;		//70

	const TInt yBot=yTop+2*halfSize;		//150

	if (aPos<6)

		return TSize(xLeft+16*aPos-8,yTop);		//1->118, 5->182

	if (aPos<11)

		return TSize(xRight,yTop+16*aPos-88);		//6->78, 10->142

	if (aPos<16)

		return TSize(xRight-16*aPos+168,yBot);		//11->182, 15->118

	return TSize(xLeft,yBot-16*aPos+248);			//16->142, 20->78

	}

void CTMultipleTrans::SizeChange(TInt aJump)

	{

	TInt ii=aJump;

	TSize size;

	while (ii<20)

		{

		size=GetSize(ii);

		iTopLeft->SetSize(size);

		if(iTopLeft->DrawOpaque())

			{

			iTopLeft->CTWin::DrawNow();

			TheClient->Flush();

			}

		CheckDisplay();

		ii+=aJump;

		if (ii>20)

			ii-=20;	

		}

	}

void CTMultipleTrans::SizeChange()

	{

	CTransWindow::SetOrdinal(iWindows,2,1);

	TSize size=iBotLeft->Size();

	TInt change;

	for (change=70;change>=0;change-=14)

		{

		iBotLeft->SetSize(TSize(size.iWidth-change,size.iHeight));

		if(iBotLeft->DrawOpaque())

			{

			iBotLeft->CTWin::DrawNow();

			TheClient->Flush();

			}

		CheckDisplay();

		}

	size=iTopRight->Size();

	for (change=25;change>-50;change-=14)

		{

		iTopRight->SetSize(TSize(size.iWidth,size.iHeight+change));

		if(iTopRight->DrawOpaque())

			{

			iTopRight->CTWin::DrawNow();

			TheClient->Flush();

			}

		CheckDisplay();

		}

	iTopRight->SetSize(size);

	if(iTopRight->DrawOpaque())

		{

		iTopRight->CTWin::DrawNow();

		TheClient->Flush();

		}

	CTransWindow::SetOrdinal(iWindows,1,0);

	CheckDisplay();

	size=iTopLeft->Size();

	SizeChange(3);

	iTopLeft->SetSize(size);

	if(iTopLeft->DrawOpaque())

		{

		iTopLeft->CTWin::DrawNow();

		TheClient->Flush();

		}

	CheckDisplay();

	CTransWindow::SetOrdinal(iWindows,0,2);

	CheckDisplay();

	SizeChange(7);

	iTopLeft->SetSize(size);

	if(iTopLeft->DrawOpaque())

		{

		iTopLeft->CTWin::DrawNow();

		TheClient->Flush();

		}

	CheckDisplay();

	}

void CTMultipleTrans::MoveWin()

	{

	const TPoint topLeftPos=iTopLeft->Position();

	const TPoint topRightPos=iTopRight->Position();

	const TPoint botLeftPos=iBotLeft->Position();

	const TPoint botRightPos=iBotRight->Position();

	const TInt maxMove=Min(topRightPos.iX,botRightPos.iY)-10;

	TInt steps,move;

	for (steps=2;steps>=0;--steps)

		{

		move=maxMove*(3-steps)/3;

		iTopLeft->SetPos(TPoint(topLeftPos.iX+move,topLeftPos.iY+move));

		CheckDisplay();

		iTopRight->SetPos(TPoint(topRightPos.iX-move,topRightPos.iY+move));

		CheckDisplay();

		iBotRight->SetPos(TPoint(botRightPos.iX-move,botRightPos.iY-move));

		CheckDisplay();

		iBotLeft->SetPos(TPoint(botLeftPos.iX+move,botLeftPos.iY-move));

		CheckDisplay();

		}

	for (steps=4;steps>=0;--steps)

		{

		move=maxMove*steps/5;

		iBotLeft->SetPos(TPoint(botLeftPos.iX+move,botLeftPos.iY-move));

		CheckDisplay();

		iTopLeft->SetPos(TPoint(topLeftPos.iX+move,topLeftPos.iY+move));

		CheckDisplay();

		iBotRight->SetPos(TPoint(botRightPos.iX-move,botRightPos.iY-move));

		CheckDisplay();

		iTopRight->SetPos(TPoint(topRightPos.iX-move,topRightPos.iY+move));

		CheckDisplay();

		}

	}

void CTMultipleTrans::GroupWinL()

	{

	CTWindowGroup* group=new(ELeave) CTWindowGroup(TheClient);

	CleanupStack::PushL(group);

	group->ConstructL();

	CTransWindow* win=CTransWindow::NewL(group,KCyan,TRect(40,40,WinSize.iWidth-40,WinSize.iHeight-40),&DisplayMode);

	win->CTWin::DrawNow();

	if(iMajorTest==1)

		{

		win->SetDrawOpaque(ETrue);

		win->Invalidate();

		TheClient->WaitForRedrawsToFinish();

		}

	iWindows.Insert(win,0);

	CheckDisplay();

	group->GroupWin()->SetOrdinalPosition(1);

	iWindows.Remove(0);

	CheckDisplay();

	group->GroupWin()->SetOrdinalPosition(0);

	iWindows.Insert(win,0);

	CheckDisplay();

	iWindows.Remove(0);

	delete win;		//Would be better to delete this after the group window but the test window don't support this behaviour currently.

	CleanupStack::PopAndDestroy(group);

	CheckDisplay();

	}

void CTMultipleTrans::FadeTranWin()

	{

	// system fade on

	TheClient->iWs.SetSystemFaded(ETrue);

	// system fade off

	TheClient->iWs.SetSystemFaded(EFalse);

	CheckDisplay();

	}

void CTMultipleTrans::StartShadows()

	{

	iShadows=ETrue;

	iTopLeft->SetShadowDisabled(EFalse);

	iTopLeft->AdjustShadow(1);

	iTopRight->SetShadowDisabled(EFalse);

	iTopRight->AdjustShadow(1);

	iBotLeft->SetShadowDisabled(EFalse);

	iBotLeft->AdjustShadow(1);

	iBotRight->SetShadowDisabled(EFalse);

	iBotRight->AdjustShadow(1);

	if(!iOpacitySupported)

		{

		iTopRight->ToggleVisibility();		// In 8.1 this isn't needed.

		iTopRight->ToggleVisibility();

		}

	CheckDisplay();

	}

void CTMultipleTrans::ShadowsOnOff()

	{

	if(!iOpacitySupported)

		return;								// In 8.1 this isn't needed.

	iBotRight->SetShadowDisabled(EFalse);

	iBotRight->AdjustShadow(1);

	CheckDisplay();

	iBotRight->SetShadowDisabled(ETrue);

	CheckDisplay();

	iTopLeft->SetShadowDisabled(EFalse);

	iTopLeft->AdjustShadow(1);

	CheckDisplay();

	iTopLeft->SetShadowDisabled(ETrue);

	CheckDisplay();

	iTopRight->SetShadowDisabled(ETrue);

	CheckDisplay();

	iBotLeft->SetShadowDisabled(EFalse);

	iBotLeft->AdjustShadow(1);

	CheckDisplay();

	iBotLeft->SetShadowDisabled(ETrue);

	CheckDisplay();

	iTopLeft->SetShadowDisabled(EFalse);

	iTopRight->SetShadowDisabled(EFalse);

	iBotLeft->SetShadowDisabled(EFalse);

	iBotRight->SetShadowDisabled(EFalse);

	iTopLeft->ToggleVisibility();

	CheckDisplay();

	iTopLeft->ToggleVisibility();

	CheckDisplay();

	iTopRight->ToggleVisibility();

	CheckDisplay();

	iTopRight->ToggleVisibility();

	CheckDisplay();

	iBotLeft->ToggleVisibility();

	CheckDisplay();

	iBotLeft->ToggleVisibility();

	CheckDisplay();

	iBotRight->ToggleVisibility();

	CheckDisplay();

	iBotRight->ToggleVisibility();

	CheckDisplay();

	}

void CTMultipleTrans::StartChildL()

	{

	CTransWindow* win;

	TInt windows=iWindows.Count();

	TInt window;

	//Delete the first 4 windows from the array, could use ResetAndDestroy but would be broken by other uses of the array

	for (window=windows;window>0;--window)

		{

		win=iWindows[0];

		iWindows.Remove(0);

		delete win;

		}

	RecreateWindowsL(iBackgroundWin);

	CheckDisplay();	

	}

void CTMultipleTrans::StartChild2L()

	{

	CTransWindow* win;

	TInt windows=iWindows.Count();

	TInt window;

	//Delete the first 4 windows from the array, could use ResetAndDestroy but would be broken by other uses of the array

	for (window=windows;window>0;--window)

		{

		win=iWindows[0];

		iWindows.Remove(0);

		delete win;

		}

	iShadows=EFalse;

	TRect rect=WinSize;

	rect.Shrink(10,10);

	iBotRight=CTransWindow::NewL(iBackgroundWin,KBlue,rect,&DisplayMode);

	iBotRight->CTWin::DrawNow();

	iWindows.Insert(iBotRight,0);

	CheckDisplay();	

	rect.Resize(-20,-20);

	iTopLeft=CTransWindow::NewL(iBotRight,KRed,rect,&DisplayMode);

	iTopLeft->CTWin::DrawNow();

	iTopLeft->SetPosOffset(TPoint(10,10));

	iWindows.Insert(iTopLeft,0);

	CheckDisplay();	

	rect.Resize(-20,-20);

	iTopRight=CTransWindow::NewL(iTopLeft,KGreen,rect,&DisplayMode);

	iTopRight->CTWin::DrawNow();

	iTopRight->SetPosOffset(TPoint(20,20));

	iWindows.Insert(iTopRight,0);

	CheckDisplay();	

	rect.Resize(-20,-20);

	iBotLeft=CTransWindow::NewL(iTopRight,KYellow,rect,&DisplayMode);

	iBotLeft->CTWin::DrawNow();

	iBotLeft->SetPosOffset(TPoint(30,30));

	iWindows.Insert(iBotLeft,0);

	if(iMajorTest==1)

		{

		for (TInt window = 0; window < iWindows.Count(); ++window)

			{

			iWindows[window]->SetDrawOpaque(ETrue);

			iWindows[window]->Invalidate();

			}

		TheClient->WaitForRedrawsToFinish();

		}

	CheckDisplay();	

	}

void CTMultipleTrans::RecreateWindowsL(CTWinBase *aParent)

	{

	CTransWindow* win;

	TInt windows=iWindows.Count();

	TInt window;

	//Delete existing windows:

	for (window=windows;window>0;--window)

		{

		win=iWindows[0];

		iWindows.Remove(0);

		delete win;

		}

	if(!aParent)

		aParent = TheClient->iGroup;

	iBotRight=CTransWindow::NewL(aParent,KBlue,TRect(WinSize.iWidth/2-10,WinSize.iHeight/2-30,WinSize.iWidth-20,WinSize.iHeight-20),&DisplayMode);

	iBotRight->CTWin::DrawNow();

	iWindows.Insert(iBotRight,0);

	iTopLeft=CTransWindow::NewL(aParent,KRed,TRect(10,10,WinSize.iWidth/2+10,WinSize.iHeight/2+30),&DisplayMode);

	iTopLeft->CTWin::DrawNow();

	iWindows.Insert(iTopLeft,0);

	iTopRight=CTransWindow::NewL(aParent,KGreen,TRect(WinSize.iWidth/2-30,20,WinSize.iWidth-10,WinSize.iHeight/2+10),&DisplayMode);

	iTopRight->CTWin::DrawNow();

	iWindows.Insert(iTopRight,0);

	iBotLeft=CTransWindow::NewL(aParent,KYellow,TRect(20,WinSize.iHeight/2-10,WinSize.iWidth/2+30,WinSize.iHeight-10),&DisplayMode);

	iBotLeft->CTWin::DrawNow();

	iWindows.Insert(iBotLeft,0);

	iShadows=EFalse;

	if(iMajorTest==1)

		{

		for (TInt window=0;window<iWindows.Count();++window)

			{

			iWindows[window]->SetDrawOpaque(ETrue);

			iWindows[window]->Invalidate();

			}

		TheClient->WaitForRedrawsToFinish();

		}

	}

void CTMultipleTrans::RunTestCaseL(TInt /*aCurTestCase*/)

	{

	_LIT(KCheck,"Check");

	_LIT(KSimple,"Simple Test");

	_LIT(KVisibility,"Change Visibility");

	_LIT(KVisibility2,"Change Visibility 2");

	_LIT(KOrdinal,"Ordinal Position");

	_LIT(KSizeChange,"Size Change");

	_LIT(KMoveWin,"Move Window");

	_LIT(KGroupWin,"Group Window Ordinal");

	_LIT(KBackground,"Background Color Changes");

	_LIT(KShadowsOnOff,"Shadows On Off");

	_LIT(KChild1,"Child 1");

	_LIT(KChild2,"Child 2");

	_LIT(KOpacity,"Opaque Drawing");

	_LIT(KTranWinFade,"Fading Transparent Windows");

	((CTMultipleTransStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(iTest->iState)

		{

		case 0:

/**

@SYMTestCaseID		GRAPHICS-WSERV-0500

*/

			((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0500"));

			// Check to see if Transparency is enabled before running tests

			iTest->LogSubTest(KCheck);

			if (TransparencySupportedL()==KErrNotSupported)

				{

				LOG_MESSAGE(_L("Transparency is not supported\n"));

				TestComplete();

				return;

				}

			++iTest->iState;		//Fall Through

/**

@SYMTestCaseID		GRAPHICS-WSERV-0111

@SYMDEF             DEF081259

@SYMTestCaseDesc    Simple transparent windows test.

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Four overlapping transparent windows (RWindow) are created before the test on the screen's left side.

					The test draws the windows on the screen's right side using FBS bitmaps direcly.

					The test does nothing if transparency is not enabled on the screen.

@SYMTestExpectedResults Expects that left and rightside bitmaps are identical

*/		

		case 1:

			((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0111"));

			iTest->LogSubTest(KSimple);

			SimpleTest();

			break;

/**

@SYMTestCaseID		GRAPHICS-WSERV-0112

@SYMDEF             DEF081259

@SYMTestCaseDesc    On/off switching of visibility of transparent windows

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Four overlapping transparent windows (RWindow) are created before the test on the screen's left side.

					The test toggles visibility of those four windows going through all

					combinations. For each combination it draws visible windows on the screen's right side using FBS bitmaps direcly.

					The test does nothing if transparency is not enabled on the screen.

@SYMTestExpectedResults Expects that left and rightside bitmaps are identical

*/		

		case 2:

		case 23:

		case 42:

			((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0112"));

			iTest->LogSubTest(KVisibility);

			ChangeVisibility();

			break;

/**

@SYMTestCaseID		GRAPHICS-WSERV-0113

@SYMDEF             DEF081259

@SYMTestCaseDesc    On/off switching of visibility of a small transparent window on top of existing transparent windows

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Four overlapping transparent windows (RWindow) are created before the test on the screen's left side.

					Toggles visibility of 5th blank little window making this appear in different places 

					with different ordinal position. Draws visible windows on the screen's right side using FBS bitmaps direcly

					each time when the 5th window becomes invisible.

					The test does nothing if transparency is not enabled on the screen.

@SYMTestExpectedResults Expects that left and rightside bitmaps are identical

*/		

		case 3:

			((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0113"));

			iTest->LogSubTest(KVisibility2);

			ChangeVisibility2();

			break;

/**

@SYMTestCaseID		GRAPHICS-WSERV-0114

@SYMDEF             DEF081259

@SYMTestCaseDesc    Ordinal positions' switches of intersecting transparent windows

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Four overlapping transparent windows (RWindow) are created before the test on the screen's left side.

					Switches ordinal positions of the four windows trying all combinations. Draws visible windows on the screen's right side

					using FBS bitmaps direcly each time when a new combination is applied.

					The test does nothing if transparency is not enabled on the screen.

@SYMTestExpectedResults Expects that left and rightside bitmaps are identical

*/		

		case 4:

		case 43:

			((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0114"));

			iTest->LogSubTest(KOrdinal);

			OrdinalPos();

			break;

/**

@SYMTestCaseID		GRAPHICS-WSERV-0115

@SYMDEF             DEF081259

@SYMTestCaseDesc    Changing sizes of intersecting transparent windows

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Four overlapping transparent windows (RWindow) are created before the test on the screen's left side.

					Plays with sizes of each of the four windows to affect overlapping. 

					Draws visible windows on the screen's right side using FBS bitmaps direcly

					each time when a new size for a particular window is applied.

					The test does nothing if transparency is not enabled on the screen.

@SYMTestExpectedResults Expects that left and rightside bitmaps are identical

*/		

		case 5:

		case 24:

			((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0115"));

			iTest->LogSubTest(KSizeChange);

			SizeChange();

			break;

/**

@SYMTestCaseID		GRAPHICS-WSERV-0116

@SYMDEF             DEF081259

@SYMTestCaseDesc    Moving intersecting transparent windows

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Four overlapping transparent windows (RWindow) are created before the test on the screen's left side.

					Performs moves of those windows one by one making little steps in direction of the center of intersection and backwards.

					Draws visible windows on the screen's right side using FBS bitmaps direcly

					each time when a position of a particular window changes.

					The test does nothing if transparency is not enabled on the screen.

@SYMTestExpectedResults Expects that left and rightside bitmaps are identical

*/		

		case 6:

			((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0116"));

			iTest->LogSubTest(KMoveWin);

			MoveWin();

			break;

/**

@SYMTestCaseID		GRAPHICS-WSERV-0117

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test with a second window group

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Four overlapping transparent windows (RWindow, within the same group) are created before the test on the screen's left side.

					Creates a 5th transparent window in a separate window group

					on top of existing windows which covers the intersection area of initial 4 windows. 

					Changes the ordinal position of the group to 1, changes ordinal position 

					back to 0, removes the new group.

					Redraws visible windows on the screen's right side using FBS bitmaps direcly

					each time when any change on the screen's left side is performed.

					The test does nothing if transparency is not enabled on the screen.

@SYMTestExpectedResults Expects that left and rightside bitmaps are identical

*/		

		case 7:

			((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0117"));

			iTest->LogSubTest(KGroupWin);

			GroupWinL();

			break;

		case 8:

			((CTMultipleTransStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

			iTest->LogSubTest(KBackground);

			//Change the background color of the 4 test windows and the window behind them

			break;

/**

@SYMTestCaseID		GRAPHICS-WSERV-0118

@SYMDEF             DEF081259

@SYMTestCaseDesc    On/off switching of fading

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Four overlapping transparent windows (RWindow) are created before the test on the screen's left side.

					Switches system fading on and right after that back to off.

					Draws visible windows on the screen's right side using FBS bitmaps direcly

					after that.

					The test does nothing if transparency is not enabled on the screen.

@SYMTestExpectedResults Expects that left and rightside bitmaps are identical

*/		

		case 9:

			((CTMultipleTransStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0118"));

			iTest->LogSubTest(KTranWinFade);

			FadeTranWin();

			break;

		case 10:

			((CTMultipleTransStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

			iTest->iState=21-1;

			break;

/**

@SYMTestCaseID		GRAPHICS-WSERV-0120

@SYMDEF             DEF081259

@SYMTestCaseDesc    Shadows' on/off test.

@SYMTestPriority    High