// 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:
// Window redraw/validate/invalidate tests
// 
//

/**
 @file
 @test
 @internalComponent - Internal Symbian test code
*/

#include "TREDRAW.H"

LOCAL_D TSize FullScreenModeSize;

const TRgb KRed = TRgb(255,0,0);
const TRgb KBlack = TRgb(0,0,0);
const TRgb KWhite = TRgb(255,255,255);
const TRgb KTransBisque = TRgb(255,228,196,128);
const TRgb KTransLightSalmon = TRgb(255,160,122,128);
const TRgb KLightSteelBlue = TRgb(176,196,222);
const TRgb KCadetBlue = TRgb(95,158,160);

TInt CTRedrawOrderWindow::iRedrawNumber=0;

#define InvalidRegionLogging
#if defined(InvalidRegionLogging)
#define BLOG_MESSAGE(p) (const_cast<CTRedrawTest*>(&iGraphicsTest))->LogMessage(((TText8*)__FILE__), __LINE__,(p))
#endif

//
//  //
//

CTCheckDefectWin* CTCheckDefectWin::NewL(TPoint aPos,TSize aWinSize)
	{
	CTCheckDefectWin* win=new(ELeave) CTCheckDefectWin;
	win->ConstructExtLD(*TheClient->iGroup,aPos,aWinSize);
	win->BaseWin()->SetRequiredDisplayMode(EColor256);
	win->AssignGC(*TheClient->iGc);
	win->BaseWin()->SetShadowDisabled(ETrue);
	win->BaseWin()->SetShadowHeight(0);
	TheClient->Flush();
	return win;
	}

CRedrawWindow::CRedrawWindow(CTRedrawTest *aTest) : CTWin(), iTest(aTest)
	{
	}

CRedrawWindow::~CRedrawWindow()
	{
	iInvalid.Close();
	}

void CRedrawWindow::Draw()
	{
	ReceivedDrawRequest();
	DrawPattern(iTest->WinContent());
	}

void CRedrawWindow::ReceivedDrawRequest()
	{
	iDrawRequests++;
	}

TInt CRedrawWindow::DrawRequests() const
	{
	return iDrawRequests;
	}

void CRedrawWindow::DrawPattern(TInt aPattern)
	{
	iGc->Clear();
	TPoint drawBase(-10,-20);
	TSize drawSize(iSize.iWidth-2*drawBase.iX,iSize.iHeight-2*drawBase.iY);
	TPoint offset=drawBase+iOffset;
	switch(aPattern)
		{
		case EDrawGraphPaperlHatched:
			{
			iGc->DrawRect(TRect(drawBase,drawBase+drawSize));
			iGc->SetPenColor(TRgb(85,85,85));
			iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);
			TInt xpos;
			for(xpos=0;xpos<drawSize.iWidth;xpos+=15)
				iGc->DrawLine(TPoint(xpos,0)+offset,TPoint(xpos,drawSize.iHeight)+offset);
			TInt ypos;
			for(ypos=0;ypos<drawSize.iHeight;ypos+=15)
				iGc->DrawLine(TPoint(0,ypos)+offset,TPoint(drawSize.iWidth,ypos)+offset);
			break;
			}
		case EDrawSlantingHatched:
			{
			iGc->SetPenColor(TRgb(255,255,255));
			iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);
			for(TInt xpos=0;xpos<drawSize.iWidth;xpos+=16)
				{
				iGc->DrawLine(TPoint(xpos,0)+offset,TPoint(drawSize.iWidth,xpos*drawSize.iHeight/drawSize.iWidth)+offset);
				iGc->DrawLine(TPoint(xpos,0)+offset,TPoint(0,drawSize.iHeight-xpos*drawSize.iHeight/drawSize.iWidth)+offset);
				iGc->DrawLine(TPoint(xpos,drawSize.iHeight)+offset,TPoint(drawSize.iWidth,drawSize.iHeight-xpos*drawSize.iHeight/drawSize.iWidth)+offset);
				iGc->DrawLine(TPoint(xpos,drawSize.iHeight)+offset,TPoint(0,xpos*drawSize.iHeight/drawSize.iWidth)+offset);
				}
			}
			break;
		case EDrawCenteredRectangle:
			{
			TRect rect(5,iSize.iHeight/4,iSize.iWidth-5,iSize.iHeight/2);
			iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);
			iGc->SetPenColor(TRgb(255,255,255));
			iGc->DrawRect(rect);
			}
			break;
		default:
			// Other pattern values requested are ignored
			break;
		}
	}

void CRedrawWindow::Reset()
	{
	iOffset=TPoint(0,0);
	iWin.Invalidate();
	iInvalid.Clear();
	}

/**
 * Calculate the window region minus the region covered by the child
 * window; this is the "visible region"
 */
void CRedrawWindow::VisibleRegion(RRegion &aRegion)
	{
	aRegion.Clear();
	aRegion.AddRect(TRect(Size()));
	TRect child;
	child.iTl=Child()->BaseWin()->InquireOffset(iWin);
	child.iBr=child.iTl+Child()->Size();
	aRegion.SubRect(child);
	}


void CRedrawWindow::ValidateAndClear()
	{
	Win()->Invalidate();
	Win()->BeginRedraw();
	iGc->Activate(*Win());
	iGc->Clear();
	iGc->Deactivate();
	Win()->EndRedraw();
	}

void CRedrawWindow::ActivateAndDraw(TInt aPattern, TRegion *aRegion)
	{
	iGc->Activate(*Win());
	if (aRegion)
		iGc->SetClippingRegion(*aRegion);
	DrawPattern(aPattern);
	iGc->Deactivate();
	}

CReferenceComparisonRedrawWindow::CReferenceComparisonRedrawWindow(CTRedrawTest *aTest) : CRedrawWindow(aTest)
	{}

/**
 * Prepare the invalid region.
 * 
 * Update the invalid region with a rectangle where such a rectangle is minus
 * any area covered by a child window.
 * 
 * @param aRect Rectangle to be added to the invalid region
 */
void CReferenceComparisonRedrawWindow::PrepareInvalidation(const TRect &aRect)
	{
	RRegion clipped_visible;
	VisibleRegion(clipped_visible);
	clipped_visible.ClipRect(aRect);
	iInvalid.Union(clipped_visible);
	clipped_visible.Close();
	iInvalid.Tidy();
	}

/**
 * Mop up all pending invalid regions and simulate a Draw().
 * 
 * Normally, we would rely on WServ to call this window's Draw() method
 * to obtain drawing operations to cover the currently invalid regions
 * of the window.
 * 
 * This method does that task by marking all invalid regions as clean and
 * then performs the drawing required in the invalid portions of the screen.
 * 
 * The purpose of this is to then allow a comparison to be made against a
 * different window which does rely on the WServ framework calling back
 * to do a Draw().
 * 
 * @post the window has no outstanding invalid regions
 */
void CReferenceComparisonRedrawWindow::PerformInvalidation()
	{
	for(TInt index=0;index<iInvalid.Count();index++)
		{
		iWin.Invalidate(iInvalid[index]);
		iWin.BeginRedraw(iInvalid[index]);
		iWin.EndRedraw();
		}
	iWin.BeginRedraw(iInvalid.BoundingRect());
	iGc->Activate(iWin);
	iGc->SetClippingRegion(iInvalid);
	DrawPattern(iTest->WinContent());
	iGc->Deactivate();
	iWin.EndRedraw();
	}

CRedrawWindow2::CRedrawWindow2(CTRedrawTest *aTest) : CRedrawWindow(aTest)
	{
	}

void CRedrawWindow2::Draw()
	{
	ReceivedDrawRequest();
	if (iClipped)
		iGc->SetClippingRegion(iInvalid);
	DrawPattern(iTest->WinContent());
	if (iClipped)
		iGc->CancelClippingRegion();
	}

/**
 * Prepare the invalid region.
 * @param aRect rectangle to be added to the invalid region
 */
void CRedrawWindow2::PrepareInvalidation(const TRect &aRect)
	{
	iInvalid.Clear();
	iInvalid.AddRect(aRect);
	}

/**
 * Perform invalidation by setting the window's invalid region.
 * 
 * The purpose of this method is to stimulate a call from WServ to the
 * Draw() method of this class.
 */
void CRedrawWindow2::PerformInvalidation()
	{
	iWin.Invalidate(iInvalid.BoundingRect());
	}

void CRedrawWindow2::Reset()
	{
	CRedrawWindow::Reset();
	iClipped=EFalse;
	}

CRedrawWindow3::CRedrawWindow3(CTRedrawTest *aTest) : CRedrawWindow(aTest)
	{
	}

void CRedrawWindow3::Draw()
	{
	ReceivedDrawRequest();
	iGc->Clear();
	iGc->SetPenStyle(CGraphicsContext::ENullPen);
	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	iGc->SetBrushColor(TRgb(0,255,255));
	iGc->DrawRect(TRect(TPoint(0,0),TSize(50,50)));
	}

void CRedrawWindow3::PrepareInvalidation(const TRect &aRect)
	{
	iInvalid.Clear();
	iInvalid.AddRect(aRect);
	}

void CRedrawWindow3::PerformInvalidation()
	{
	iWin.Invalidate(iInvalid.BoundingRect());
	}

void CRedrawWindow3::SetUp1L(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc)
	{
	ConstructL(*parent);
	SetExtL(pos,size);
	AssignGC(aGc);
	}

void CRedrawWindow3::Redraw(const TRect &aRect)
	{
	if(!isActive)
		{//make an empty redraw
		iWin.BeginRedraw(aRect);
		iWin.EndRedraw();
		}
	else
		{
		CTWin::Redraw(aRect);
		}	
	}

void CRedrawWindow3::Activate()
	{
	isActive = ETrue;
	Win()->Activate();
	}

//

CTRedrawOrderWindow::CTRedrawOrderWindow(TInt aOrder, CTRedrawTest *aTest) : iTest(aTest), iOrder(aOrder)
	{}

CTRedrawOrderWindow* CTRedrawOrderWindow::NewLC(TInt aOrder,CTWinBase* aParent,const TPoint& aPos,const TSize& aSize,CTRedrawTest* aTest)
	{
	CTRedrawOrderWindow* self=new(ELeave) CTRedrawOrderWindow(aOrder,aTest);
	CleanupStack::PushL(self);
	self->SetUpL(aPos,aSize,aParent,*TheGc);
	return self;
	}

void CTRedrawOrderWindow::Draw()
	{
	iGc->SetBrushColor(TRgb::Gray16(iOrder*2));
	iGc->Clear();
	}

void CTRedrawOrderWindow::ResetRedrawNumber()
	{
	iRedrawNumber=0;
	}

void CTRedrawOrderWindow::Redraw(const TRect &aRect)
	{
	if (++iRedrawNumber!=iOrder)
		iTest->Failed(iOrder);
	CTWin::Redraw(aRect);
	}

//

TInt DestructCallback(TAny *aParam)
	{
	((CTRedrawTest *)aParam)->doDestruct();
	return(0);
	}

CTRedrawTest::CTRedrawTest(CTestStep* aStep):
	CTWsGraphicsBase(aStep)//, iInvalidRegionChecker(*this)
	{}

void CTRedrawTest::doDestruct()
	{
	BaseWin->SetVisible(ETrue);
	TestWin->SetVisible(ETrue);
	delete iBaseRedrawWin;
	delete iTestRedrawWin;
	delete iBaseChildWin;
	delete iTestChildWin;
	}

CTRedrawTest::~CTRedrawTest()
	{
	TCallBack callBack(DestructCallback,this);
	TheClient->SetRedrawCancelFunction(callBack);
	delete iInvalidRegionChecker;	
	}

void CTRedrawTest::ConstructL()
	{
#if defined(InvalidRegionLogging)
	LOG_MESSAGE(_L("  CTRedrawTest::ConstructL()"));
	LOG_MESSAGE4(_L("  Ex Wins 0x%08x, 0x%08x, 0x%08x"), BaseWin, TestWin, &(TheClient->StdLogWindow()));
#endif
	
	iInvalidRegionChecker = new(ELeave)CInvalidRegionChecker(*this);
	User::LeaveIfError(iInvalidRegionChecker->AddExcludedWindow(BaseWin));
	User::LeaveIfError(iInvalidRegionChecker->AddExcludedWindow(TestWin));
	User::LeaveIfError(iInvalidRegionChecker->AddExcludedWindow(&(TheClient->StdLogWindow())));
	WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);	
	
	iWinContent=0;
	BaseWin->SetVisible(EFalse);
	TestWin->SetVisible(EFalse);
	FullScreenModeSize=TheClient->iGroup->Size();
	TInt winWidth=(FullScreenModeSize.iWidth/3)-10;
	TInt winHeight=FullScreenModeSize.iHeight-10;
	iBaseRedrawWin=new(ELeave) CReferenceComparisonRedrawWindow(this);
	iBaseRedrawWin->SetUpL(TPoint(FullScreenModeSize.iWidth/3+5,5),TSize(winWidth,winHeight),TheClient->iGroup,*TheClient->iGc);
	iTestRedrawWin=new(ELeave) CRedrawWindow2(this);
	iTestRedrawWin->SetUpL(TPoint(FullScreenModeSize.iWidth/3*2+5,5),TSize(winWidth,winHeight),TheClient->iGroup,*TheClient->iGc);
	iBaseChildWin=new(ELeave) CBlankWindow();
	iBaseChildWin->SetUpL(TPoint(winWidth>>2,winHeight>>2),TSize(winWidth>>1,winHeight>>1),iBaseRedrawWin,*TheClient->iGc);
	iTestChildWin=new(ELeave) CBlankWindow();
	iTestChildWin->SetUpL(TPoint(winWidth>>2,winHeight>>2),TSize(winWidth>>1,winHeight>>1),iTestRedrawWin,*TheClient->iGc);

#if defined(InvalidRegionLogging)
	LOG_MESSAGE5(_L("  In Wins %08x, %08x, %08x, %08x"), iBaseRedrawWin, iBaseChildWin, iTestRedrawWin, iTestChildWin);
#endif

	WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);

#if defined(InvalidRegionLogging)
	LOG_MESSAGE(_L("  Done"));
#endif
	}

void CTRedrawTest::CheckRedrawWindows()
	{
	_LIT(KTest,"Redraw Test, SubTest %d ");
	TBuf<64> buf;
	buf.Format(KTest,iTest->iState);
	CheckRect(iBaseRedrawWin,iTestRedrawWin,TRect(iBaseRedrawWin->Size()),buf);
	}

void CTRedrawTest::InvalidateTestWins(const TRect &aRect)
	{
	iBaseRedrawWin->PrepareInvalidation(aRect);
	iTestRedrawWin->PrepareInvalidation(aRect);
	iBaseRedrawWin->PerformInvalidation();
	iTestRedrawWin->PerformInvalidation();
	}

inline TInt CTRedrawTest::WinContent()
	{
	return iWinContent;
	}

void CTRedrawTest::SetBackground(const TRgb &aRgb)
	{
	iBaseRedrawWin->iWin.SetBackgroundColor(aRgb);
	iTestRedrawWin->iWin.SetBackgroundColor(aRgb);
	}

void CTRedrawTest::DumpRegion(const TRegion &aRegion)
	{
	_LIT(KLog,"RegionRect %d: (%d,%d,%d,%d)");
	for (TInt ii=0;ii<aRegion.Count();++ii)
		{
		const TRect& rect=aRegion[ii];
		LOG_MESSAGE6(KLog,ii,rect.iTl.iX,rect.iTl.iY,rect.iBr.iX,rect.iBr.iY);
		}
	}

/**
 * Compare Regions to see if the region we think we have dirtied can be
 * completely covered by the WServ invalid region.
 * 
 * @param aDirtyRegion 			Region we have made dirty
 * @param aWservInvalidRegion	Region WServ thinks is dirty
 */
void CTRedrawTest::CompareRegionsL(const TRegion &aDirtyRegion,const TRegion &aWservInvalidRegion)
	{
	_LIT(KDirty,"Dirty Region, %d Rects");
	_LIT(KInvalid,"Invalid Region, %d Rects");
	_LIT(KDiff,"Diff Region, %d Rects");
	RRegion tmp;
	TBool loggedRegions=EFalse;
	tmp.Copy(aDirtyRegion);
	tmp.SubRegion(aWservInvalidRegion);
	if (tmp.CheckError())
		User::Leave(KErrNoMemory);
	TBool isEmpty=tmp.IsEmpty();
	TEST(isEmpty);
	if (!isEmpty)
		{
		_LIT(KLog,"DirtyRegion contains area not in WservInvalidRegion");
		LOG_MESSAGE(KLog);
		loggedRegions=ETrue;
		LOG_MESSAGE2(KDirty,aDirtyRegion.Count());
		DumpRegion(aDirtyRegion);
		LOG_MESSAGE2(KInvalid,aWservInvalidRegion.Count());
		DumpRegion(aWservInvalidRegion);
		LOG_MESSAGE2(KDiff,tmp.Count());
		DumpRegion(tmp);
		}
	tmp.Copy(aWservInvalidRegion);
	tmp.SubRegion(aDirtyRegion);
	if (tmp.CheckError())
		User::Leave(KErrNoMemory);
	isEmpty=tmp.IsEmpty();
	//TEST(isEmpty);		//This test currently fails and a defect will be raises about it
	if (!isEmpty)
		{
		_LIT(KLog,"WservInvalidRegion contains area not in DirtyRegion");
		LOG_MESSAGE(KLog);
		if (!loggedRegions)
			{
			LOG_MESSAGE2(KDirty,aDirtyRegion.Count());
			DumpRegion(aDirtyRegion);
			LOG_MESSAGE2(KInvalid,aWservInvalidRegion.Count());
			DumpRegion(aWservInvalidRegion);
			}
		LOG_MESSAGE2(KDiff,tmp.Count());
		DumpRegion(tmp);
		}
	tmp.Close();
	}

void CTRedrawTest::MoveInvalidAreaL()
	{
	TPoint old=iTestRedrawWin->iWin.Position();
	TSize screenSize=TheClient->iGroup->Size();
	iBaseRedrawWin->iWin.Invalidate();
	iTestRedrawWin->iWin.Invalidate();
	iTestRedrawWin->iWin.SetPosition(TPoint(10,10));
	iTestRedrawWin->iWin.SetPosition(TPoint(0,0));
	iTestRedrawWin->iWin.SetPosition(TPoint(-10,-10));
	iTestRedrawWin->iWin.SetPosition(TPoint(screenSize.iWidth-10,screenSize.iHeight-10));
	iTestRedrawWin->iWin.SetPosition(TPoint(screenSize.iWidth,screenSize.iHeight));
	iTestRedrawWin->iWin.SetPosition(TPoint(screenSize.iWidth+10,screenSize.iHeight+10));
	iTestRedrawWin->iWin.SetPosition(old);
	RRegion baseInvalidRegion;
	RRegion testInvalidRegion;
	iBaseRedrawWin->iWin.GetInvalidRegion(baseInvalidRegion);
	iTestRedrawWin->iWin.GetInvalidRegion(testInvalidRegion);
	CompareRegionsL(baseInvalidRegion,testInvalidRegion);
	baseInvalidRegion.Close();
	testInvalidRegion.Close();
	}

void CTRedrawTest::GetInvalidRegionTestsL()
	{
	TSize stdWinSize(iTest->StdTestWindowSize());
	CArrayFixFlat<TRect>* rectList=new(ELeave) CArrayFixFlat<TRect>(3);
	rectList->AppendL(TRect(1,1,5,2));
	rectList->AppendL(TRect(stdWinSize.iWidth>>1,stdWinSize.iHeight>>1,stdWinSize.iWidth,stdWinSize.iHeight));
	rectList->AppendL(TRect(2,0,4,5));
	TestGetInvalidRegionL(rectList);
	rectList->Reset();
	rectList->AppendL(TRect(-1000,-1,10000,5));
	rectList->AppendL(TRect(0,0,stdWinSize.iWidth>>1,stdWinSize.iHeight>>1));
	rectList->AppendL(TRect(2,100,2*stdWinSize.iWidth,105));
	TestGetInvalidRegionL(rectList);
	delete rectList;
	}

void CTRedrawTest::TestGetInvalidRegionL(const CArrayFixFlat<TRect> *aRectList)
	{
	RRegion invalidRegion;
	RRegion region;
	iTestRedrawWin->iWin.BeginRedraw();
	iTestRedrawWin->iWin.EndRedraw();
	for (TInt index=0;index<aRectList->Count();index++)
		{
		iTestRedrawWin->iWin.Invalidate((*aRectList)[index]);
		region.AddRect((*aRectList)[index]);
		}
	//Currently WSERV includes areas under a child or other window in the invalid region
	//This is arguable the incorrect thing to do
	/*TRect subRect;
	subRect.iTl=iTestChildWin->BaseWin()->InquireOffset(iTestRedrawWin->iWin);
	subRect.SetSize(iTestChildWin->Size());
	region.SubRect(subRect);*/
	region.ClipRect(TRect(iTestRedrawWin->Size()));
	iTestRedrawWin->iWin.GetInvalidRegion(invalidRegion);
	CompareRegionsL(region,invalidRegion);
	region.Close();
	invalidRegion.Close();
	}

void CTRedrawTest::Failed(TInt aOrder)
	{
	_LIT(KLog,"Redraw Order Error, Window Drawn at Position %d should be drawn at Position %d");
	LOG_MESSAGE3(KLog,CTRedrawOrderWindow::RedrawNumber(),aOrder);
	if (iRedrawNo==0)
		iRedrawNo=CTRedrawOrderWindow::RedrawNumber();
	}

void CTRedrawTest::CheckOrderL()
	{
	_LIT(KLog,"Fail in redraw order test, first position of error is %d");
	iRedrawNo=0;
	CTRedrawOrderWindow* order1;
	CTRedrawOrderWindow* order2;
	CTRedrawOrderWindow* order3;
	CTRedrawOrderWindow* order4;
	CTRedrawOrderWindow* order5;
	CTRedrawOrderWindow* order6;
	CTRedrawOrderWindow* order7;
	order6=CTRedrawOrderWindow::NewLC(6,TheClient->iGroup,TPoint(100,10),TSize(40,40),this);
	order7=CTRedrawOrderWindow::NewLC(7,order6,TPoint(0,0),TSize(20,20),this);
	order1=CTRedrawOrderWindow::NewLC(1,TheClient->iGroup,TPoint(10,10),TSize(60,40),this);
	order4=CTRedrawOrderWindow::NewLC(4,order1,TPoint(20,0),TSize(20,40),this);
	order5=CTRedrawOrderWindow::NewLC(5,order4,TPoint(0,0),TSize(20,20),this);
	order2=CTRedrawOrderWindow::NewLC(2,order1,TPoint(0,0),TSize(20,40),this);
	order3=CTRedrawOrderWindow::NewLC(3,order2,TPoint(0,0),TSize(20,20),this);
	TheClient->iWs.Finish();  // Fix for DEF133199 - Intermittant failure with windows out of order 
	WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);	// Check order is correct after initial creation
	TEST(order1!=NULL && order2!=NULL && order3!=NULL && order4!=NULL && order5!=NULL && order6!=NULL && order7!=NULL);	// redundant check to shut up the compiler
	TEST(iRedrawNo==0);
	if (iRedrawNo>0)
		LOG_MESSAGE2(KLog,iRedrawNo);

	CTRedrawOrderWindow::ResetRedrawNumber();
	iRedrawNo=0;
	CTUser::Splat(TheClient,TRect(0,0,200,60),TRgb(0,0,0));
	TheClient->iWs.Flush();
	WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);	// Check it's still correct on subsequent redraws
	TEST(iRedrawNo==0);
	if (iRedrawNo>0)
		LOG_MESSAGE2(KLog,iRedrawNo);
	CTRedrawOrderWindow::ResetRedrawNumber();
	CleanupStack::PopAndDestroy(7,order6);
	}

// For reproducing INC049554
void CTRedrawTest::CheckDefectINC049554L()
	{
	if(TransparencySupportedL() == KErrNotSupported) //the defect only happens when transparency enabled
		return;
	TSize screenSize=TheClient->iScreen->SizeInPixels();
	TPoint winPos(screenSize.iWidth/3,0);
	TSize winSize(screenSize.iWidth/3,screenSize.iHeight);
	CTCheckDefectWin* lowerWin=CTCheckDefectWin::NewL(winPos,winSize);
	CleanupStack::PushL(lowerWin);
	lowerWin->Activate();
	TheClient->Flush();
	WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);

	winPos.iX+=screenSize.iWidth/12;

	CTCheckDefectWin* upperWin=CTCheckDefectWin::NewL(winPos,winSize);
	CleanupStack::PushL(upperWin);
	upperWin->Activate();
	TheClient->Flush();
	WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);

	// Invalidate the lower win and while drawing its content, move top window
	lowerWin->Invalidate();
	lowerWin->Win()->BeginRedraw();
	TheClient->iGc->Activate(*lowerWin->DrawableWin());
	TheClient->iGc->SetPenStyle(CGraphicsContext::ENullPen);
	TheClient->iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	TheClient->iGc->SetBrushColor(TRgb(0,255,0));
	TheClient->iGc->DrawRect(TRect(TPoint(0,0),TSize(50,50)));

	winPos.iX+=screenSize.iWidth/12;
	upperWin->SetExt(winPos,winSize);

	TheClient->iGc->SetBrushColor(TRgb(255,0,0));
	TheClient->iGc->DrawRect(TRect(TPoint(0,0),TSize(50,50)));
	TheClient->iGc->Deactivate();
	lowerWin->Win()->EndRedraw();

	TheClient->Flush();
	WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);

	CleanupStack::PopAndDestroy(upperWin);

	// Create 2 transaprent windows, slightly over lapping the background window
	winPos.iX=screenSize.iWidth/3;
	TPoint winPosTop(winPos.iX-screenSize.iWidth/6,0);
	TSize winSizeTop(screenSize.iWidth/3+screenSize.iWidth/6,screenSize.iHeight/2);

	CTCheckDefectWin* leftWin=CTCheckDefectWin::NewL(winPosTop,winSizeTop);
	CleanupStack::PushL(leftWin);
	leftWin->Win()->SetTransparencyAlphaChannel();
	leftWin->Win()->SetBackgroundColor(TRgb(0,0,0, 128));
	leftWin->Activate();
	TheClient->iWs.Finish();
	WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);

	CTCheckDefectWin* rightWin=CTCheckDefectWin::NewL(winPos,winSizeTop);
	CleanupStack::PushL(rightWin);
	rightWin->Win()->SetTransparencyAlphaChannel();
	rightWin->Win()->SetBackgroundColor(TRgb(0,0,0, 128));
	rightWin->Activate();
	TheClient->iWs.Finish();
	WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);

	lowerWin->Invalidate();
	lowerWin->Win()->BeginRedraw();
	TheClient->iGc->Activate(*lowerWin->DrawableWin());
	TheClient->iGc->SetPenStyle(CGraphicsContext::ENullPen);
	TheClient->iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	TheClient->iGc->SetBrushColor(TRgb(0,255,0));
	TheClient->iGc->DrawRect(TRect(TPoint(0,0),TSize(50,50)));

	TheClient->iGc->SetBrushColor(TRgb(255,0,0));
	TheClient->iGc->DrawRect(TRect(TPoint(0,0),TSize(50,50)));
	TheClient->iGc->Deactivate();
	lowerWin->Win()->EndRedraw();

	TheClient->iWs.Finish();
	WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);

	CleanupStack::PopAndDestroy(3,lowerWin);
	}


TInt myKK=1;
_LIT(KSnap,"c:\\TestRect%2i.mbm");
_LIT(KSnapE,"c:\\TestRect%2iErr.mbm");
void CTRedrawTest::TestRect()
	{
	
	TBuf<50> snapshotFileName;
	snapshotFileName.Zero();
	CFbsBitmap *snapshot=new(ELeave) CFbsBitmap();
	CleanupStack::PushL(snapshot);
	User::LeaveIfError(snapshot->Create(TheClient->iScreen->SizeInPixels(),TheClient->iScreen->DisplayMode()));		

	User::LeaveIfError(TheClient->iScreen->CopyScreenToBitmap(snapshot));
	
	TRect rect1=TRect(TPoint(),TSize(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight));
	TRect rect2=TRect(TPoint(FullScreenModeSize.iWidth/2,0),TSize(FullScreenModeSize.iWidth/2,FullScreenModeSize.iHeight));
	TBool retVal = TheClient->iScreen->RectCompare(rect1,rect2);

	RDebug::Printf("Picture %i !!!: Rect1: (%i,%i)->(%i,%i)  -  Rect2: (%i,%i)->(%i,%i)",myKK,
			rect1.iTl.iX,rect1.iTl.iY,rect1.iBr.iX,rect1.iBr.iY,
			rect2.iTl.iX,rect2.iTl.iY,rect2.iBr.iX,rect2.iBr.iY);	
	
	
	if (retVal)
		{
		snapshotFileName.Format(KSnap,myKK);
		}
	else
		{
		snapshotFileName.Format(KSnapE,myKK);	
		}
	snapshot->Save(snapshotFileName);
	CleanupStack::PopAndDestroy(snapshot);
	myKK++;	
		
	

	TEST(retVal);
	if(!retVal)
		INFO_PRINTF3(_L("TheClient->iScreen->RectCompare() return value  - Expected: %d, Actual: %d"), ETrue, retVal);
	}

void CTRedrawTest::ConstructAndSetBlankWinLC(RBlankWindow& aWindow, TSize aSize, TPoint aPoint/*=TPoint()*/,
						   					TRgb aBackgroundColor/*=TRgb(0,0,0)*/)
	{
	User::LeaveIfError(aWindow.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle));
	CleanupClosePushL(aWindow);
	aWindow.SetExtent(aPoint, aSize);
	aWindow.SetColor(aBackgroundColor);
	aWindow.Activate();
	}

void CTRedrawTest::ConstructWindowLC(RWindow& aWindow, TSize aSize, TPoint aPoint/*=TPoint()*/,
						   			 TRgb aBackgroundColor/*=TRgb(255,255,255)*/, TBool aTransparencyByAlpha/*=EFalse*/,
						   			 TDisplayMode aDisplayMode/*=EColor64K*/)
	{
	User::LeaveIfError(aWindow.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle));
	CleanupClosePushL(aWindow);
	aWindow.SetExtent(aPoint,aSize);
	aWindow.SetBackgroundColor(aBackgroundColor);
	aWindow.SetRequiredDisplayMode(aDisplayMode);
	if (aTransparencyByAlpha)
		{
		aWindow.SetTransparencyAlphaChannel();
		}
	aWindow.Activate();
	}

void CTRedrawTest::ActivateAndSetGc(CWindowGc& aGc, RWindow& aWindow, CGraphicsContext::TBrushStyle aBrushStyle/*=CGraphicsContext::ESolidBrush*/, TRgb aBrushColor/*=TRgb(0,0,0)*/,
					  				CGraphicsContext::TPenStyle aPenStyle/*=CGraphicsContext::ENullPen*/, TRgb aPenColor/*=TRgb(0,0,0)*/)
	{
	aGc.Activate(aWindow);
	aGc.Reset();
	aGc.SetBrushStyle(aBrushStyle);
	aGc.SetBrushColor(aBrushColor);
	aGc.SetPenStyle(aPenStyle);
	aGc.SetPenColor(aPenColor);
	}

void CTRedrawTest::DrawWin(CWindowGc& aGc, RWindow& aWin, TSize aWinSize, TRgb aRectColor1, TRgb aRectColor2, TInt aNewOrdinalPos/*=0*/, RWindow* aWinToMove/*=NULL*/, TBool aDrawAllPixels/*=EFalse*/)
	{
	const TUint startX = 10;
	const TUint endX = aWinSize.iWidth - startX;
	const TUint startY = 10;
	const TUint sHeight = (aWinSize.iHeight >> 1) - startY;
	ActivateAndSetGc(aGc,aWin);
	aWin.BeginRedraw();
	if(aDrawAllPixels)
		{
		aGc.SetBrushColor(KWhite);
		aGc.DrawRect(TRect(aWinSize));
		}
	aGc.SetBrushColor(aRectColor1);
	aGc.DrawRect(TRect(startX, startY, endX, sHeight));
	if (aWinToMove)
		{
		aWinToMove->SetOrdinalPosition(aNewOrdinalPos);
		TheClient->iWs.Finish();
		}
	aGc.SetBrushColor(aRectColor2);
	aGc.DrawRect(TRect(startX, sHeight + startY, endX, aWinSize.iHeight - startY));
	aWin.EndRedraw();
	aGc.Deactivate();
	}

void CTRedrawTest::CheckOrdinalPositionDefectL()
	{
	if(TransparencySupportedL() == KErrNotSupported) //the defect only happens when transparency enabled
		{
		return;
		}

	const TRgb KTransWinColor = TRgb(0,0,255,128);
	const TUint hWidth  = FullScreenModeSize.iWidth >> 1;
	const TSize windowSize = TSize(hWidth,FullScreenModeSize.iHeight);
	const TPoint rightWinStartPt = TPoint(hWidth,0);

	// A Blank Window to clear the screen.
	// It is required to clear all the pixels on the screen.
	RBlankWindow clrWin(TheClient->iWs);
	ConstructAndSetBlankWinLC(clrWin, FullScreenModeSize);

	// Transparent window
	RWindow winLeftT(TheClient->iWs);
 	ConstructWindowLC(winLeftT, windowSize, TPoint(), KTransWinColor,ETrue);

	CWindowGc& gc = *(TheClient->iGc);
	// Draw the Transparent Window (winLeftT) on the Left side
 	DrawWin(gc, winLeftT, windowSize, KTransBisque, KTransLightSalmon);
	
	// Invisible window
	RWindow winRightI(TheClient->iWs);
	User::LeaveIfError(winRightI.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle));
	CleanupClosePushL(winRightI);
	winRightI.SetExtent(rightWinStartPt, windowSize);
	winRightI.SetVisible(EFalse);
	winRightI.Activate();

	// Transparent window
	RWindow winRightT(TheClient->iWs);
 	ConstructWindowLC(winRightT, windowSize, rightWinStartPt, KTransWinColor,ETrue);

	// Draw the Transparent Window (winRightT) on the Right side and change the
	// Ordinal Position for Invisible Window (winRightI) to move it front
	// to the Transparent Window.
	// Invisible window is behind the Transparent Window
 
 	DrawWin(gc, winRightT, windowSize, KTransBisque, KTransLightSalmon, 0, &winRightI); // Move winRightI to Front of winRightT
	TestRect();

	CleanupStack::PopAndDestroy(4, &clrWin);
	}

// For reproducing PDEF099892
void CTRedrawTest::CheckDefectPDEF099892L()
	{
	if(TransparencySupportedL() == KErrNotSupported) //the defect only happens when transparency enabled
		{
		return;
		}

	const TRgb KTransWinColor = TRgb(0,0,255,128);
	const TUint hWidth  = FullScreenModeSize.iWidth >> 1;
	const TUint hHeight = FullScreenModeSize.iHeight >> 1;
	const TSize windowSize = TSize(hWidth,FullScreenModeSize.iHeight);
	const TSize transWinSize = TSize(hWidth,hHeight + 10);
	const TPoint rightWinStartPt = TPoint(hWidth,0);

	// A Blank Window to clear the screen.
	// It is required to clear all the pixels on the screen.
	RBlankWindow clrWin(TheClient->iWs);
	ConstructAndSetBlankWinLC(clrWin, FullScreenModeSize);

	// Create an Opaque and a Transparent Window and Draw them on the
	// Left Side of the Screen. Opaque Window is Behind the Transparent Window.
	
	// Opaque Window
	RWindow winLeftOpq(TheClient->iWs);
	ConstructWindowLC(winLeftOpq, windowSize, TPoint(), KRed);

	// Transparent window
	RWindow winLeftT(TheClient->iWs);
	ConstructWindowLC(winLeftT, transWinSize, TPoint(), KTransWinColor, ETrue);

	CWindowGc& gc = *(TheClient->iGc);
	// Draw the transparent Window (winLeftT) on the Left side
 	DrawWin(gc, winLeftT, transWinSize, KTransBisque, KTransLightSalmon);

	// Draw the Opaque Window (winLeftOpq) on the Left side
	DrawWin(gc, winLeftOpq, windowSize, KLightSteelBlue, KCadetBlue, 0, NULL, ETrue);

	// Create an Invisible, an Opaque and a Transparent Window and Draw them on the
	// Right Side of the Screen. Invisible Window is Behind the Opaque Window and
	// Opaque Window is Behind the Transparent Window.
	// While drawing the Transparent Window, move the Invisible Window to the Front of Opaque Window.
	// And while Drawing the Opaque Window move the Invisible Window again Behind the Opaque Window.

	// Invisible window
	RWindow winRightI(TheClient->iWs);
	User::LeaveIfError(winRightI.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle));
	CleanupClosePushL(winRightI);
	winRightI.SetExtent(rightWinStartPt, windowSize);
	winRightI.SetVisible(EFalse);
	winRightI.Activate();

	// Opaque Window
	RWindow winRightOpq(TheClient->iWs);
	ConstructWindowLC(winRightOpq, windowSize, rightWinStartPt, KRed);

	// Transparent window
	RWindow winRightT(TheClient->iWs);
	ConstructWindowLC(winRightT, transWinSize, rightWinStartPt, KTransWinColor, ETrue);

	// Draw the transparent Window (winRightT) on the Right side
 	DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 1, &winRightI );

	// Draw the Opaque Window (winRightOpq) on the Right side
	DrawWin(gc, winRightOpq, windowSize, KLightSteelBlue, KCadetBlue, 2, &winRightI, ETrue);
	
	// Compare the Left and Right side Rectangles
	TestRect();

	CleanupStack::PopAndDestroy(6, &clrWin);
	}

void CTRedrawTest::CheckMMSDefectL(TBool aMoveBlankWindow)
	{
	if(TransparencySupportedL() == KErrNotSupported) //the defect only happens when transparency enabled
		{
		return;
		}

	const TRgb KTransWinColor = TRgb(0,0,255,128);
	const TUint hWidth  = FullScreenModeSize.iWidth >> 1;
	const TUint hHeight = FullScreenModeSize.iHeight >> 1;
	const TSize windowSize = TSize(hWidth,FullScreenModeSize.iHeight);
	const TSize transWinSize = TSize(hWidth - 20,hHeight + 10);
	const TPoint rightWinStartPt = TPoint(hWidth,0);

	// A Blank Window to clear the screen.
	// It is required to clear all the pixels on the screen.
	RBlankWindow clrWin(TheClient->iWs);
	ConstructAndSetBlankWinLC(clrWin, FullScreenModeSize);

	// Create an Opaque and a Transparent Window and Draw them on the
	// Left Side of the Screen. Opaque Window is Behind the Transparent Window.

	// Opaque Window
	RWindow winLeftOpq(TheClient->iWs);
	ConstructWindowLC(winLeftOpq, windowSize, TPoint(), KRed);
	CWindowGc& gc = *(TheClient->iGc);
	// Draw the Opaque Window (winLeftOpq) on the Left side
	DrawWin(gc, winLeftOpq, windowSize, KLightSteelBlue, KCadetBlue, 0, NULL, ETrue);

	// Another Window - A Blank Window
	RBlankWindow winLeftBlank(TheClient->iWs);
	ConstructAndSetBlankWinLC(winLeftBlank, TSize(100,100), TPoint(20,20), TRgb(128,128,128));

	// Transparent window
	RWindow winLeftT(TheClient->iWs);
	ConstructWindowLC(winLeftT, transWinSize, TPoint(10, 10), KTransWinColor, ETrue);
	// Draw the Transparent Window (winLeftT) on the Left side
 	DrawWin(gc, winLeftT, transWinSize, KTransBisque, KTransLightSalmon);

	// Invisible window
	RWindow winRightI(TheClient->iWs);
	User::LeaveIfError(winRightI.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle));
	CleanupClosePushL(winRightI);
	winRightI.SetExtent(rightWinStartPt, windowSize);
	winRightI.SetVisible(EFalse);
	winRightI.Activate();

	// Opaque Window
	RWindow winRightOpq(TheClient->iWs);
	ConstructWindowLC(winRightOpq, windowSize, rightWinStartPt, KRed);

	// Draw the Opaque Window (winRightOpq) on the Right side
	DrawWin(gc, winRightOpq, windowSize, KLightSteelBlue, KCadetBlue, 0, NULL, ETrue);

	// Another Window - A Blank Window
	RBlankWindow winRightBlank(TheClient->iWs);
	ConstructAndSetBlankWinLC(winRightBlank, TSize(100,100), rightWinStartPt + TPoint(20,20), TRgb(128,128,128));

	// Transparent window
	RWindow winRightT(TheClient->iWs);
	ConstructWindowLC(winRightT, transWinSize, rightWinStartPt + TPoint(10,10), KTransWinColor, ETrue);

	if (aMoveBlankWindow)
		{
		winRightBlank.SetOrdinalPosition(0); // Move the Blank Window to the front of the Transparent Window
		TheClient->iWs.Finish();
		}
	// Draw the transparent Window (winRightT) on the Right side
 	DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 2, &winRightI);
	if (aMoveBlankWindow)
		{
		winRightBlank.SetOrdinalPosition(1); // Move the Blank Window back to behind the Transparent Window
		TheClient->iWs.Finish();
		}
	TestRect();

 	DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 0, &winRightI);
	TestRect(); // if aMoveBlankWindow is ETrue then this will test the Defect PDEF099892

	// Rest of the lines are just to check other possibilities.
	// But,currently, they are not affecting the result.
	// i.e. the DrawWin() functions called after this line will draw the same thing
	// as it was drawn for the DrawWin() called just before this line.
 	DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 1, &winRightI);
	TestRect();

	DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 0, &winRightI);
	TestRect();

	DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 2, &winRightI);
	TestRect();

	DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 1, &winRightI);
	TestRect();

	DrawWin(gc, winRightT, transWinSize, KTransBisque, KTransLightSalmon, 3, &winRightI);
	TestRect();

	CleanupStack::PopAndDestroy(8, &clrWin);
	}

/**

The test window is receiving a draw request before it activates, 
doing an empty redraw, then activating itself, and drawing itself properly in 
response to the next redraw request.  

Without the fix the next redraw request will not be received and it will be drawn blank. 
*/
void CTRedrawTest::CheckDefectPDEF117784L()
	{
	TSize winSize = BaseWin->Size();

	TInt winWidth=(FullScreenModeSize.iWidth/3)-10;
	TInt winHeight=FullScreenModeSize.iHeight-10;
	
	CRedrawWindow3* baseRedrawWin = new(ELeave) CRedrawWindow3(this);
	CleanupStack::PushL(baseRedrawWin);
	TPoint ptBase = TPoint(FullScreenModeSize.iWidth/3*2+5,5);
	baseRedrawWin->SetUp1L(ptBase,TSize(winWidth,winHeight),TheClient->iGroup,*TheClient->iGc);
	baseRedrawWin->SetVisible(ETrue);
	baseRedrawWin->Activate();

	CRedrawWindow3* testRedrawWin = new(ELeave) CRedrawWindow3(this);
	CleanupStack::PushL(testRedrawWin);
	TPoint ptTest = TPoint(FullScreenModeSize.iWidth/3+5,5);
	testRedrawWin->SetUp1L(ptTest,TSize(winWidth,winHeight),TheClient->iGroup,*TheClient->iGc);
	testRedrawWin->SetVisible(ETrue);
	testRedrawWin->Activate();
	
	TheClient->iWs.Finish();
	User::LeaveIfError(iInvalidRegionChecker->AddExcludedWindow(testRedrawWin));
	TBool retVal = WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);
	TEST(retVal == KErrNone);
	if(retVal != KErrNone)
	    {
	    ERR_PRINTF2(_L("CTRedrawTest::WaitForRedrawsToFinish failed with error: %d"), retVal);
	    }
	iInvalidRegionChecker->RemoveExcludedWindow(testRedrawWin);

	TheClient->iWs.Finish();
	retVal = WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);
	TEST(retVal == KErrNone);
	if(retVal != KErrNone)
	    {
        ERR_PRINTF2(_L("CTRedrawTest::WaitForRedrawsToFinish failed with error: %d"), retVal);
	    }
	
	retVal = TheClient->iScreen->RectCompare(TRect(TPoint(ptBase),TSize(winWidth,winHeight)),TRect(TPoint(ptTest),TSize(winWidth,winHeight)));
	TEST(retVal);
	if(!retVal)
		{
		ERR_PRINTF1(_L("New activated window has lost redraw request"));
		}

	CleanupStack::PopAndDestroy(2, baseRedrawWin);
	}

CInvalidRegionChecker::CInvalidRegionChecker(const CTRedrawTest& aGraphicsTest)
	: iGraphicsTest(aGraphicsTest) 
	{}

CInvalidRegionChecker::~CInvalidRegionChecker()
	{
	iExcludedWindowArray.Close();
	}

TInt CInvalidRegionChecker::AddExcludedWindow(const CTWinBase* aExcludedWindow)
	{
	TInt error = KErrNone;
	const CTWinBase** emptySlot = NULL;
	for(TInt win=iExcludedWindowArray.Count()-1; win>=0; win--)
		{
		if(iExcludedWindowArray[win]==aExcludedWindow)
			{
			// window is already excluded, we don't want to add it twice
			return error;
			}
		if(!emptySlot && iExcludedWindowArray[win]==NULL)
			{
			emptySlot = &iExcludedWindowArray[win];
			}
		}
	
	if(emptySlot)
		{
		// re-use the emptyslot		
		*emptySlot=aExcludedWindow; // re-use the element
		}
	else
		{
		// no empty elements re-used, so add a new one
		error = iExcludedWindowArray.Append(aExcludedWindow);
		}
	return error;
	};

void CInvalidRegionChecker::RemoveExcludedWindow(const CTWinBase* aExcludedWindow)
	{
	if(iExcludedWindowArray.Count())
		{
		for(TInt win=iExcludedWindowArray.Count()-1; win>=0; win--)
			{
			if(iExcludedWindowArray[win]==aExcludedWindow)
				{
				iExcludedWindowArray[win]=NULL; // Not worth deleting the array element, just mark it as NULL 
				return;
				}
			}
		}
	};

TBool CInvalidRegionChecker::ExcludedWindow(const CTWinBase* aWin) const
	{
	for(TInt win=iExcludedWindowArray.Count()-1; win>=0; win--)
		{
		if(aWin == iExcludedWindowArray[win])
			{
#if defined(InvalidRegionLogging)
				{
				_LIT(KText, "  Excluded Window %08x");
				TLogMessageText buf;		
				buf.Format(KText, aWin);
				BLOG_MESSAGE(buf);
				}
#endif					
			return ETrue;
			}
		}
	return EFalse;
	}

void CInvalidRegionChecker::ProcessWindow(const CTWinBase* aTWinBase)
	{
#if defined(InvalidRegionLogging)
			{
			_LIT(KText, "  ProcessWindow %08x %d - Child(%08x), Next(%08x), Prev(%08x)");
			TLogMessageText buf;		
			buf.Format(KText, aTWinBase, iInvalidRegionCount, aTWinBase->Child(), aTWinBase->NextSibling(), aTWinBase->PrevSibling());
			BLOG_MESSAGE(buf);
			}
#endif

	if(aTWinBase && !ExcludedWindow(aTWinBase))
		{
		RRegion invalidRegion;
		static_cast<const CTWin *>(aTWinBase)->Win()->GetInvalidRegion(invalidRegion);
		iInvalidRegionCount += invalidRegion.Count();

#if defined(InvalidRegionLogging)
		if(invalidRegion.Count())
			{
			_LIT(KText, "  IR Found for %08x %d");
			TLogMessageText buf;
			buf.Format(KText, aTWinBase, invalidRegion.Count());
			BLOG_MESSAGE(buf);
			}
#endif
		
		invalidRegion.Close();
		
		if(0==iInvalidRegionCount)
			{
			ProcessChildWindow(aTWinBase->Child());
			}
		}
	}

void CInvalidRegionChecker::ProcessChildWindow(const CTWinBase* aTWinBase)
	{
	if(aTWinBase)
		{
		// get the first sibling window
		const CTWinBase *sibling=aTWinBase;
		const CTWinBase *prevSibling=sibling->PrevSibling();
		while(prevSibling)
			{
			sibling=prevSibling;			
			prevSibling=sibling->PrevSibling();
			}
		// process all siblings inc. self	
		while(sibling && (0==iInvalidRegionCount))
			{	
			ProcessWindow(sibling);
			sibling=sibling->NextSibling();
			}
		}
	}	


void CInvalidRegionChecker::ProcessWindowGroup(const CTWinBase* aTWinBase)
	{
	if(aTWinBase && !ExcludedWindow(aTWinBase))
		{
		ProcessChildWindow(aTWinBase->Child());
		}
	}

TInt CInvalidRegionChecker::CheckInvalidRegions(const CTWindowGroup* aGroup)
	{
	iInvalidRegionCount=0;	
	ProcessWindowGroup(aGroup);	
#if defined(InvalidRegionLogging)
		{
		_LIT(KText, "  CheckInvalidRegions %d");
		TLogMessageText buf;
		buf.Format(KText, iInvalidRegionCount);
		BLOG_MESSAGE(buf);
		}
#endif	
	return iInvalidRegionCount;
	}

TInt CTRedrawTest::WaitForRedrawsToFinish(TRedrawCheckType aRedrawCheckType)
	{
	TInt error=KErrNone;
#define EnableCheckInvalidRegions
#if defined(EnableCheckInvalidRegions)	
	if(aRedrawCheckType == ECheckRedrawActiveObjectAndInvalidRegions)
		{
		TInt regions = 0;
		TInt count = 0;
		//We do not want to cycle round forever or too long, a limit of 10 has
		//been added but this is arbitrary.  If CTClient::WaitForRedrawsToFinish
		//fails too many times then possibly something else us wrong.
		do
			{
			count++;
			error = TheClient->WaitForRedrawsToFinish();
			if(error != KErrNone)
			    {
			    RDebug::Printf("CTRedrawTest::WaitForRedrawsToFinish, error %d", error);
			    }
			regions = iInvalidRegionChecker->CheckInvalidRegions(TheClient->iGroup);
			if(regions)
				{
				// Give the server a chance to do the redraws because 
				// the Animation Scheduler is an idle priority AO
				const TUint KOneSecond = 1000000; // us
				User::After(KOneSecond>>2); // 0.25s
				}
			} while (0 < regions && 10 < count); 
		}
	else // ECheckRedrawActiveObjectOnly
#endif // CheckInvalidRegions
		{
		error = TheClient->WaitForRedrawsToFinish();
		}
	return error;
	}

void CTRedrawTest::RunTestCaseL(TInt /*aCurTestCase*/)
	{
	_LIT(Redraw0,"Redraw1");
	_LIT(Redraw1,"Redraw2");
	_LIT(Redraw2,"GetInvalid");
	_LIT(Redraw3,"MoveInvalid");
	_LIT(Redraw4,"CheckOrder");
	_LIT(Redraw5,"Defect 49554");
	_LIT(Redraw6,"Check Ordinal Position");
	_LIT(Redraw7,"Defect 99892");
	_LIT(Redraw8,"Check MMS Defect 1");
	_LIT(Redraw9,"Check MMS Defect 2");
	_LIT(Redraw10,"Redraw inactive window");
	((CTRedrawTestStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	TInt testWindowDraws = -1;		// to prevent RVCT 546-D warning
	_LIT(KLog,"RunTestCase %d");
	if (++iTest->iState<6)
		LOG_MESSAGE2(KLog,iTest->iState);
	switch(iTest->iState)
		{
/**
@SYMTestCaseID		GRAPHICS-WSERV-0265

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test invalidation a test window and check it
					redraws correctly

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Invalidate a test window causing it to redraw 

@SYMTestExpectedResults The test window redraws correctly
*/
	case 1:
		((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0265"));
		iTest->LogSubTest(Redraw0);
		SetBackground(TRgb::Gray256(128));
		iDrawRequestsFromTestWindow=iTestRedrawWin->DrawRequests();
		InvalidateTestWins(TRect(10,10,50,50));
		break;
	case 2:
		((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0265"));
		TheClient->iWs.Finish();
		WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);
		testWindowDraws=iTestRedrawWin->DrawRequests();
		if (iDrawRequestsFromTestWindow+1!=testWindowDraws)
			{
			LOG_MESSAGE3(_L("wrong number of test window draw requests %d %d"),
					iDrawRequestsFromTestWindow,
					testWindowDraws);
			TEST(EFalse);
			}
		CheckRedrawWindows();
		++iWinContent;
		iTestRedrawWin->Reset();
		iBaseRedrawWin->Reset();
		TheClient->Flush();
		WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);
		break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0266

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test invalidation a test window and check it
					redraws correctly

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Invalidate a test window causing it to redraw 

@SYMTestExpectedResults The test window redraws correctly
*/
	case 3:
		((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0266"));
		iTest->LogSubTest(Redraw1);
		InvalidateTestWins(TRect(1,1,150,20));
		TheClient->iWs.Finish();
		WaitForRedrawsToFinish(ECheckRedrawActiveObjectAndInvalidRegions);
		break;
	case 4:
		((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0266"));
		CheckRedrawWindows();
		++iWinContent;
		iTestRedrawWin->Reset();
		iBaseRedrawWin->Reset();
		TheClient->iWs.Flush();
		break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0267

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test invalidation a region of a test window and check it
					redraws correctly

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Invalidate a region of a test window causing it to redraw 

@SYMTestExpectedResults The test window redraws correctly
*/
		case 5:
			((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0267"));
			iTest->LogSubTest(Redraw2);
			GetInvalidRegionTestsL();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0268

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test moving an invalid  region of a test window and check it
					redraws correctly

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Move an invalid region of a test window causing it to redraw 

@SYMTestExpectedResults The test window redraws correctly
*/
		case 6:
			((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0268"));
			iTest->LogSubTest(Redraw3);
			MoveInvalidAreaL();
			break;

/**
@SYMTestCaseID		GRAPHICS-WSERV-0270

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test the order redraws occur in a test window 

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Set up a number of redraws for a test window and
					invalidate it

@SYMTestExpectedResults The order the test window redraws occur is correct
*/

		case 7:
			((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0270"));
			iTest->LogSubTest(Redraw4);
			CheckOrderL();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0271

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test defect INC049554L does not occur

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Check that defect INC049554L does not occur when a test 
					window is redrawn

@SYMTestExpectedResults Defect INC049554L does not occur
*/
		case 8:
			((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0271"));
			iTest->LogSubTest(Redraw5);
			CheckDefectINC049554L();
			break;
/** 
 @SYMTestCaseID GRAPHICS-WSERV-0359

  @SYMDEF  			PDEF099892

  @SYMTestCaseDesc Ensure that changing the Ordinal postion of an Invisible Window
  				   does not affect the Transparent Window  or Opaque Window redrawing.

  @SYMTestPriority Medium

  @SYMTestStatus Implemented

  @SYMTestActions Create an Invisible Window
                  Create a Transparent Window
                  Inside the Begin and End Redraw for the Transparent Window,
                  change the Ordinal Position for Invisible Window to move it
                  front to the Transparent Window.

  @SYMTestExpectedResults Changing the Ordinal postion for Invisible Window should not
						  affect the Transparent Window redrawing.
*/
		case 9:
			((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0359"));
			iTest->LogSubTest(Redraw6);
			CheckOrdinalPositionDefectL();
			break;
/** 
 @SYMTestCaseID GRAPHICS-WSERV-0360

  @SYMDEF  			PDEF099892

  @SYMTestCaseDesc Ensure that changing the Ordinal postion of an Invisible window
  				   does not affect the Transparent Window  or Opaque Window redrawing.

  @SYMTestPriority Medium

  @SYMTestStatus Implemented

  @SYMTestActions Create an Invisible Window
  				  Create an Opaque Window
                  Create a Transparent Window
                  Invisible Window is Behind the Opaque Window
				  and Opaque Window is Behind the Transparent Window.
                  While drawing the Transparent Window, move the Invisible Window
                  to the Front of Opaque Window. And while Drawing the Opaque Window
                  move the Invisible Window again Behind the Opaque Window.

  @SYMTestExpectedResults Changing the Ordinal postion for Invisible window should not
						  affect the Transparent Window  or Opaque Window redrawing.
*/
		case 10:
			((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0360"));
			iTest->LogSubTest(Redraw7);
			CheckDefectPDEF099892L();
			break;
/** 
 @SYMTestCaseID GRAPHICS-WSERV-0361

  @SYMDEF  			DEF101548

  @SYMTestCaseDesc Ensure that changing the Ordinal postion of an Invisible window
  				   does not affect the Transparent Window redrawing.

  @SYMTestPriority Low

  @SYMTestStatus Implemented

  @SYMTestActions Create an Invisible Window
  				  Create an Opaque Window
  				  Create a Blank Window
  				  Create a Transparent Window
  				  Invisible Window is Behind the Opaque Window
  				  Opaque Window is Behind the Blank Window
  				  and Blank Window is Behind the Transparent Window.
  				  While drawing the Transparent Window, move the Invisible Window
  				  to the Front/Back to one or all the Other Windows.
  				  Also move the Blank Window Front/Back to the Transparent Window for other scenario.

  @SYMTestExpectedResults Changing the Ordinal postion for Invisible window should not
						  affect the Transparent Window redrawing.
*/
	case 11:
		((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0361"));
		iTest->LogSubTest(Redraw8);
		CheckMMSDefectL(EFalse);
	case 12:
		((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0361"));
		iTest->LogSubTest(Redraw9);
		CheckMMSDefectL(ETrue);// In this case we will move Blank Window Front/Back to the Transparent Window to Test Defect PDEF099892
		break;
	case 13:
		iTest->LogSubTest(Redraw10);
/**
  @SYMTestCaseID GRAPHICS-WSERV-0362

  @SYMDEF	PDEF117784
	
  @SYMTestCaseDesc Ensure that drawing request for non active window will not 
	impact following redrawings

  @SYMTestPriority High

  @SYMTestStatus Implemented
  
  
  @SYMTestActions 	Create test window as in active
  					Create base window in active mode.
  				    
					The test window is receiving a draw request before it activates, 
					doing an empty redraw, 
					Activate test window
					Draw test window properly in response to the next redraw request.  

  @SYMTestExpectedResults The next redraw request will be received and it will be drawn correctly. 
*/	
			((CTRedrawTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0362"));
			CheckDefectPDEF117784L();
			break;
		case 14:
			((CTRedrawTestStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
			((CTRedrawTestStep*)iStep)->CloseTMSGraphicsStep();
			TestComplete();
			break;
		default:
			TEST(EFalse);
		}
	((CTRedrawTestStep*)iStep)->RecordTestResultL();
	}

__WS_CONSTRUCT_STEP__(RedrawTest)