// 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();