// 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:

// Code for testing CWindowGc::SetCurrentRegion

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TRegion.H"

TBool RegionCanFade;

TBool RegionCanFadeSet;

LOCAL_D TBuf<0x10> text=_L("SOME TEXT");

LOCAL_D TPoint textRefPos(210, 80);

LOCAL_D TRect regionRectList[]={

					TRect(0,0,0,0),	TRect(30,10,70,40),TRect(60,30,80,70),TRect(10,110,70,170),

					TRect(190,0,240,60),TRect(62,63,67,115),TRect(0,180,240,200),TRect(40,50,210,130),

					TRect(160,130,190,160),TRect(100,140,140,170),TRect(140,170,100,140),TRect(90,120,230,200)};

LOCAL_D TRect clippingRectList[]={

					TRect(0,0,200,400),	TRect(30,10,500,600),TRect(-60,0,80,70),TRect(20,0,170,500),

					TRect(0,0,2000,6000),TRect(-1000,-2000,123,195),TRect(10,10,230,190),TRect(0,0,510,730),

					TRect(110,30,190,150),TRect(1,1,500,11170),TRect(0,0,800,940),TRect(-10,-20,240,210)};

LOCAL_D TPoint originList[]={

					TPoint(0,0),TPoint(10,0),TPoint(0,10),TPoint(-5,-20),

					TPoint(1,1),TPoint(0,0),TPoint(0,0),TPoint(100,0),

					TPoint(0,111),TPoint(90,40),TPoint(0,0),TPoint(-1,0)};

CTRegion::CTRegion(CTestStep* aStep) : CTWsGraphicsBase(aStep)

	{

	}

void CTRegion::ConstructL()

	{

	iDrawableSize=TestWin->Size();

//

	User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)iFont,TFontSpec(_L("Arial"),200)));

  	User::LeaveIfError(iPicture.Load(TEST_BITMAP_NAME,0));

	iBitmap = new (ELeave) CWsBitmap(TheClient->iWs);

	User::LeaveIfError(iBitmap->Create(TSize(iDrawableSize.iWidth+1,iDrawableSize.iHeight),EGray16));

	iBitmap->SetSizeInTwips(TheClient->iScreen);

	iBitmapDevice=CFbsBitmapDevice::NewL(iBitmap);

	User::LeaveIfError(iBitmapDevice->CreateContext(iBitGc));

	User::LeaveIfError(iBitmapDevice->GetNearestFontToDesignHeightInTwips((CFont *&)iBitFont,TFontSpec(_L("Arial"),200)));

	}

CTRegion::~CTRegion()

	{

	delete iBitGc;

	TheClient->iScreen->ReleaseFont(iFont);

	if (iBitmapDevice)

		iBitmapDevice->ReleaseFont(iBitFont);

	delete iBitmapDevice;

	DeleteChildWindows();

	delete iBitmap;

	}

void CTRegion::CreateChildWindowsL()

	{

	TSize screenSize=TheClient->iGroup->Size();

	TInt winWidth=(screenSize.iWidth/3)-10;

	TInt winHeight=screenSize.iHeight-10;

	iBaseChildWin=new(ELeave) CBlankWindow();

	iBaseChildWin->SetUpL(BaseWin->Win()->InquireOffset(*TheClient->iGroup->GroupWin())+TPoint(winWidth>>2,winHeight>>2),TSize(winWidth>>2,winHeight>>1),TheClient->iGroup,*TheClient->iGc);

	iBaseChildWin->Win()->SetShadowHeight(2);

	iTestChildWin=new(ELeave) CBlankWindow();

	iTestChildWin->SetUpL(TestWin->Win()->InquireOffset(*TheClient->iGroup->GroupWin())+TPoint(winWidth>>2,winHeight>>2),TSize(winWidth>>2,winHeight>>1),TheClient->iGroup,*TheClient->iGc);

	}

void CTRegion::DeleteChildWindows()

	{

	delete iBaseChildWin;

	iBaseChildWin=NULL;

	delete iTestChildWin;

	iTestChildWin=NULL;

	}

void CTRegion::DrawNonClippedSample1(CBitmapContext &aGc)

	{

	aGc.SetPenColor(TRgb::Gray4(0));

	aGc.SetBrushColor(TRgb::Gray4(2));

	aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

	aGc.DrawRect(TRect(TPoint(30,100), TPoint(120,200)));

	TheClient->iWs.Flush();

	}

void CTRegion::DrawClippedSample1(CBitmapContext &aGc)

	{

	aGc.SetPenColor(TRgb::Gray4(0));

	aGc.SetBrushColor(TRgb::Gray4(1));

	aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

	aGc.DrawRect(TRect(TSize(100,200)));

//	aGc.BitBlt(TPoint(55,65), iPicture);

	aGc.SetPenStyle(CGraphicsContext::ENullPen);

	aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

	aGc.SetBrushColor(TRgb::Gray4(2));

	aGc.DrawEllipse(TRect(TPoint(20,35), TPoint(90,79)));

	aGc.SetBrushColor(TRgb::Gray4(0));

	aGc.DrawEllipse(TRect(TPoint(110,110), TPoint(175,200)));

	aGc.SetBrushColor(TRgb::Gray4(1));

	aGc.DrawEllipse(TRect(TPoint(170,30), TPoint(220,150)));

	aGc.SetBrushColor(TRgb::Gray4(3));

	aGc.DrawEllipse(TRect(TPoint(0,150), TPoint(240,190)));

	aGc.SetPenStyle(CGraphicsContext::ESolidPen);

	aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

	TheClient->iWs.Flush();

	}

void CTRegion::DrawNonClippedSample2(CBitmapContext &aGc, CFont *aFont)

	{

	aGc.SetPenColor(TRgb::Gray4(0));

	aGc.SetPenColor(TRgb::Gray4(0));

	aGc.UseFont(aFont);

	TPoint textPos=textRefPos-TPoint(iFont->TextWidthInPixels(text)*3/4, 0);

	aGc.DrawText(text, textPos);

	aGc.DiscardFont();

	TheClient->iWs.Flush();

	}

void CTRegion::DrawClippedSample2(CBitmapContext &aGc, CFont *aFont)

	{

	aGc.SetPenColor(TRgb::Gray4(0));

	aGc.SetPenColor(TRgb::Gray4(2));

	aGc.UseFont(aFont);

	TPoint textPos=textRefPos-TPoint(iFont->TextWidthInPixels(text)*3/4, -20);

	aGc.DrawText(text, textPos);

	aGc.DiscardFont();

	aGc.SetBrushColor(TRgb::Gray4(3));

	aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

	aGc.DrawRect(TRect(TPoint(10,100), TPoint(210,120)));

	TheClient->iWs.Flush();

	}

void CTRegion::DrawClippedSample3(CBitmapContext &aGc)

	{

	aGc.SetPenColor(TRgb::Gray4(0));

	aGc.SetPenColor(TRgb::Gray4(2));

	aGc.DrawRect(TRect(TPoint(10,200), TPoint(20,210)));

	}

void CTRegion::DrawNonClippedSample1(CTWin *aWindow, const TPoint &aOrigin)

	{

	TheGc->Activate(*aWindow->Win());

	TheGc->SetOrigin(aOrigin);

	DrawNonClippedSample1(*TheGc);

	TheGc->Deactivate();

	}

void CTRegion::DrawNonClippedSample1(CTWin *aWindow, const TRegion &aRegion, const TPoint &aOrigin)

	{

	TheGc->Activate(*aWindow->Win());

	TheGc->SetOrigin(aOrigin);

	TheGc->SetClippingRegion(aRegion);

	DrawNonClippedSample1(*TheGc);

	TheGc->Deactivate();

	}

void CTRegion::DrawClippedSample1(TestWindow *aWindow, const TRegion &aRegion, const TRect &aClippingRect, const TPoint &aOrigin)

	{

	TheGc->Activate(*aWindow->Win());

	TheGc->SetOrigin(aOrigin);

	TheGc->SetClippingRegion(aRegion);

	TheGc->SetClippingRect(aClippingRect);

	DrawClippedSample1(*TheGc);

	TheGc->Deactivate();

	}

void CTRegion::DrawNonClippedSample2(CTWin *aWindow, const TPoint &aOrigin)

	{

	TheGc->Activate(*aWindow->Win());

	TheGc->SetOrigin(aOrigin);

	DrawNonClippedSample2(*TheGc,iFont);

	TheGc->Deactivate();

	}

void CTRegion::DrawNonClippedSample2(CTWin *aWindow, const TRegion &aRegion, const TPoint &aOrigin)

	{

	TheGc->Activate(*aWindow->Win());

	TheGc->SetOrigin(aOrigin);

	TheGc->SetClippingRegion(aRegion);

	DrawNonClippedSample2(*TheGc,iFont);

	TheGc->Deactivate();

	}

void CTRegion::DrawClippedSample2(TestWindow *aWindow, const TRegion &aRegion, const TRect &aClippingRect, const TPoint &aOrigin)

	{

	TheGc->Activate(*aWindow->Win());

	TheGc->SetClippingRegion(TRegionFix<1>());

	DrawClippedSample3(*TheGc);	// needed to trigger region update in wserv

	TheGc->SetOrigin(aOrigin);

	TheGc->SetClippingRect(aClippingRect);

	TheGc->SetClippingRegion(aRegion);

	DrawClippedSample2(*TheGc,iFont);

	TheGc->CancelClippingRegion();

	TheGc->Deactivate();

	}

void CTRegion::ClearBitmapAndWindows()

	{

	TestWin->Win()->Invalidate();

	TestWin->Win()->BeginRedraw();

	TheGc->Activate(*TestWin->Win());

	TheGc->SetBrushColor(TRgb::Gray4(3));

	TheGc->Clear();

	TheGc->Deactivate();

	TestWin->Win()->EndRedraw();

//

	BaseWin->Win()->Invalidate();

	BaseWin->Win()->BeginRedraw();

	TheGc->Activate(*BaseWin->Win());

	TheGc->SetBrushColor(TRgb::Gray4(3));

	TheGc->Clear();

	TheGc->Deactivate();

	BaseWin->Win()->EndRedraw();

//

	iBitGc->SetBrushColor(TRgb::Gray4(3));

	iBitGc->Clear();

	TheClient->iWs.Flush();

	}

void CTRegion::TestRegionL(const TRegion &aClippingRegion, const TRect &aClippingRect, const TPoint &aOrigin)

	{

	if (aClippingRegion.CheckError())

		User::Leave(KErrGeneral);

	ClearBitmapAndWindows();

	// draw to iWindow1 (clipping intermittently) and iBitmap (not clipping)

	DrawNonClippedSample1(TestWin,aOrigin);

	DrawNonClippedSample1(*iBitGc);

	DrawNonClippedSample2(TestWin,aOrigin);

	DrawNonClippedSample2(*iBitGc, iBitFont);

	DrawClippedSample1(TestWin,aClippingRegion,aClippingRect,aOrigin);

	DrawClippedSample1(*iBitGc);

	DrawClippedSample2(TestWin,aClippingRegion,aClippingRect,aOrigin);

	DrawClippedSample2(*iBitGc, iBitFont);

	// copy each rectangle of the clipping region from iBitmap to iWindow2

	TheGc->Activate(*BaseWin->Win());

	for (TUint i=0; i<(TUint)aClippingRegion.Count(); i++)

		{

		TRect rect=aClippingRegion.RectangleList()[i];

		rect.Intersection(aClippingRect);

		TheGc->SetOrigin(aOrigin);

		TheGc->BitBlt(rect.iTl, iBitmap, rect);

		TheClient->Flush();

		}

	TheGc->Deactivate();

	// draw the non-clipped samples to everywhere in iWindow2 *except* the clipping region

	RRegion inverseClippingRegion(TRect(-aOrigin,iDrawableSize));

	RRegion clip;

	clip.Copy(aClippingRegion);

	clip.ClipRect(aClippingRect);

	inverseClippingRegion.SubRegion(clip);

	clip.Close();

	DrawNonClippedSample1(BaseWin,inverseClippingRegion,aOrigin);

	DrawNonClippedSample2(BaseWin,inverseClippingRegion,aOrigin);

	inverseClippingRegion.Close();

	CompareWindows(_L("CTRegion::TestRegionL"));

	}

void CTRegion::CompareRectsL(TPoint aTl1,TPoint aTl2,TSize aSize)

	{

	_LIT(KError,"Pixels Differ: (%d,%d),(%d,%d)");

	CFbsScreenDevice* device;

	device=CFbsScreenDevice::NewL(KNullDesC,iBaseChildWin->BaseWin()->DisplayMode());

	TPoint br=aTl1+aSize;

	TInt startX1=aTl1.iX;

	TInt startX2=aTl2.iX;

	TSize pixelSize(1,1);

	TPoint zero;

	while(aTl1.iY<br.iY+1)

		{

		while (aTl1.iX<br.iX+1)

			{

			if (!device->RectCompare(TRect(aTl1,pixelSize),*device,TRect(aTl2,pixelSize)))

				{

				RDebug::Print(KError,aTl1.iX,aTl1.iY,aTl2.iX,aTl2.iY);

				iTest->LogColors(*device,zero,aTl1,aTl1);

				iTest->LogColors(*device,zero,aTl2,aTl2);

				}

			++aTl1.iX;

			++aTl2.iX;

			}

		aTl1.iX=startX1;

		aTl2.iX=startX2;

		++aTl1.iY;

		++aTl2.iY;

		}

	}

void CTRegion::ScrollBugL()

	{

	CBlankWindow* testWin;

	RBlankWindow win(TheClient->iWs);

	CleanupClosePushL(win);

	TSize screenSize=TheClient->iGroup->Size();

	testWin=new(ELeave) CBlankWindow(TRgb::Gray4(0));

	CleanupStack::PushL(testWin);

	//testWin->ConstructL(*TheClient->iGroup);

	testWin->SetUpL(TPoint(screenSize.iWidth/3,0),TSize(screenSize.iWidth/3,screenSize.iHeight),TheClient->iGroup,*TheGc);

	//testWin->Win()->SetBackgroundColor(TRgb::Gray2(1));

	testWin->Win()->EnableRedrawStore(EFalse);

	testWin->SetColor(TRgb::Gray4(1));

	testWin->RealDraw(ETrue);

	win.Construct(*TheClient->iGroup->WinTreeNode(),3456);

	win.SetColor(TRgb::Gray4(2));

	win.SetExtent(TPoint(screenSize.iWidth/3+30,20),TSize(screenSize.iWidth/3-62,25));

	win.Activate();

	TheClient->iWs.Flush();

	TheClient->WaitForRedrawsToFinish();

	win.SetVisible(EFalse);

	TheClient->iWs.Flush();

	testWin->Win()->BeginRedraw();

	testWin->DrawNow();

	testWin->SetColor(TRgb::Gray4(2));

	testWin->Win()->Scroll(TPoint(0,-50));

	testWin->DrawNow();

	testWin->Win()->EndRedraw();

	TheClient->iWs.Flush();

	TBool retVal = TheClient->iScreen->RectCompare(TRect(TPoint(screenSize.iWidth/3,0),TSize(screenSize.iWidth/3,screenSize.iHeight/2-30))

							,TRect(TPoint(screenSize.iWidth/3,screenSize.iHeight/2-30),TSize(screenSize.iWidth/3,screenSize.iHeight/2-30)));

	TEST(retVal);

	if (!retVal)

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

	retVal = !TheClient->iScreen->RectCompare(TRect(TPoint(screenSize.iWidth/3,screenSize.iHeight-60),TSize(10,10))

							,TRect(TPoint(screenSize.iWidth/3,screenSize.iHeight-50),TSize(10,10)));

	TEST(retVal);

	if (!retVal)

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

	TheClient->WaitForRedrawsToFinish();

	win.SetVisible(ETrue);

	win.SetVisible(EFalse);

	testWin->Win()->BeginRedraw();

	testWin->Win()->Scroll(TPoint(0,-50));

	testWin->SetColor(TRgb::Gray4(1));

	testWin->DrawNow();

	testWin->Win()->EndRedraw();

	TheClient->iWs.Flush();	

	retVal = TheClient->iScreen->RectCompare(TRect(TPoint(screenSize.iWidth/3+35,0),TSize(screenSize.iWidth/6-35,100))

							,TRect(TPoint(screenSize.iWidth/2,0),TSize(screenSize.iWidth/6-35,100)));

	TEST(retVal);

	if (!retVal)

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

	retVal = !TheClient->iScreen->RectCompare(TRect(TPoint(screenSize.iWidth/3+30,20),TSize(10,10))

							,TRect(TPoint(screenSize.iWidth/3+30,50),TSize(10,10)));

	TEST(retVal);

	if (!retVal)

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

	TheClient->WaitForRedrawsToFinish();

	testWin->Win()->BeginRedraw();

	testWin->DrawNow();

	testWin->Win()->EndRedraw();

	CleanupStack::PopAndDestroy(2,&win);

	}

void CTRegion::ExposeTestL()

	{

	CBlankWindow* testWin;

	TSize screenSize=TheClient->iGroup->Size();

	TRect topHalf(0,0,screenSize.iWidth/3,screenSize.iHeight/2);

	TRect leftHalf(0,0,screenSize.iWidth/6,screenSize.iHeight);

	testWin=new(ELeave) CBlankWindow(TRgb::Gray4(0));

	CleanupStack::PushL(testWin);

	testWin->SetUpL(TPoint(screenSize.iWidth/3,0),TSize(screenSize.iWidth/3,screenSize.iHeight),TheClient->iGroup,*TheGc);

	testWin->Win()->EnableRedrawStore(EFalse);

	testWin->SetColor(TRgb::Gray4(2));

	testWin->RealDraw(ETrue);

	TheClient->iWs.Flush();

	TheClient->WaitForRedrawsToFinish();

	testWin->Win()->BeginRedraw();

	testWin->DrawNow();

	testWin->Win()->Invalidate(topHalf);

	testWin->SetColor(TRgb::Gray4(1));

	testWin->DrawNow();

	testWin->Win()->EndRedraw();

	TheClient->iWs.Flush();

	CheckRectNoMatch(TPoint(screenSize.iWidth/3,0),TPoint(screenSize.iWidth/3,screenSize.iHeight/2),TSize(10,10),_L("CTRegion::ExposeTestL() A"));

	TheClient->WaitForRedrawsToFinish();

	CheckRect(TPoint(screenSize.iWidth/3,0),TPoint(screenSize.iWidth/3,screenSize.iHeight/2),TSize(screenSize.iWidth/3,screenSize.iHeight/2),_L("CTRegion::ExposeTestL() B"));

	testWin->Win()->Invalidate(topHalf);

	testWin->SetColor(TRgb::Gray4(2));

	testWin->Win()->BeginRedraw();

	testWin->Win()->Invalidate(leftHalf);

	testWin->DrawNow();

	testWin->Win()->EndRedraw();

	TheClient->iWs.Flush();

	CheckRect(TPoint(screenSize.iWidth/3,0),TPoint(screenSize.iWidth/3,screenSize.iHeight/2),TSize(screenSize.iWidth/6-10,screenSize.iHeight/2),_L("CTRegion::ExposeTestL() C"));

	CheckRectNoMatch(TPoint(screenSize.iWidth/2,0),TPoint(screenSize.iWidth/2,screenSize.iHeight/2),TSize(10,10),_L("CTRegion::ExposeTestL() D"));

	CheckRectNoMatch(TPoint(screenSize.iWidth/3,0),TPoint(screenSize.iWidth/2,0),TSize(10,10),_L("CTRegion::ExposeTestL() E"));

	CheckRect(TPoint(screenSize.iWidth/3,screenSize.iHeight/2),TPoint(screenSize.iWidth/2,screenSize.iHeight/2),TSize(((screenSize.iWidth/6-5)/4*4),screenSize.iHeight/2),_L("CTRegion::ExposeTestL() F"));

	testWin->Win()->BeginRedraw();

	testWin->DrawNow();

	testWin->Win()->EndRedraw();

	TheClient->iWs.Flush();

	CheckRect(TPoint(screenSize.iWidth/3,0),TPoint(screenSize.iWidth/3,screenSize.iHeight/2),TSize(screenSize.iWidth/6-10,screenSize.iHeight/2),_L("CTRegion::ExposeTestL() G"));

	CheckRectNoMatch(TPoint(screenSize.iWidth/2,0),TPoint(screenSize.iWidth/2,screenSize.iHeight/2),TSize(10,10),_L("CTRegion::ExposeTestL() H"));

	CheckRect(TPoint(screenSize.iWidth/3,0),TPoint(screenSize.iWidth/2,0),TSize(((screenSize.iWidth/6-5)/4*4),screenSize.iHeight/2),_L("CTRegion::ExposeTestL() I"));

	CheckRectNoMatch(TPoint(screenSize.iWidth/3,screenSize.iHeight/2),TPoint(screenSize.iWidth/2,screenSize.iHeight/2),TSize(10,10),_L("CTRegion::ExposeTestL() J"));

	CleanupStack::PopAndDestroy(testWin);

	}

#if defined(__MARM_ARM4__)

	#define FADING ETrue

#elif defined(__MARM__)

	#define FADING EFalse

#else

	#define FADING ETrue

#endif

void CTRegion::ExposeTest2L()

	{

	TBool canFade=FADING;

#if defined(__MARM_THUMB__)

	if (!RegionCanFadeSet)

		return;

	canFade=RegionCanFade;

#endif

	INFO_PRINTF1(_L("AUTO REGN ExpostTest2 "));

	CBlankWindow* testWin;

	RBlankWindow win(TheClient->iWs);

	CleanupClosePushL(win);

	TSize screenSize=TheClient->iGroup->Size();

	TRect topHalf(0,0,screenSize.iWidth/3,screenSize.iHeight/2);

	testWin=new(ELeave) CBlankWindow(TRgb::Gray4(0));

	CleanupStack::PushL(testWin);

	testWin->SetUpL(TPoint(screenSize.iWidth/3,0),TSize(screenSize.iWidth/3,screenSize.iHeight),TheClient->iGroup,*TheGc);

	testWin->Win()->EnableRedrawStore(EFalse);

	testWin->Win()->SetRequiredDisplayMode(EGray16);

	testWin->SetColor(TRgb::Gray16(12));

	testWin->RealDraw(ETrue);

	win.Construct(*TheClient->iGroup->WinTreeNode(),3456);

	win.SetColor(TRgb::Gray4(2));

	win.SetExtent(TPoint(0,-screenSize.iHeight),TSize(screenSize.iWidth/3-2,2*screenSize.iHeight));

	win.SetShadowHeight(screenSize.iWidth/9);

	win.Activate();

	TheClient->iWs.Flush();

	TheClient->WaitForRedrawsToFinish();

	INFO_PRINTF1(_L(" Constructed Windows"));

	testWin->DrawNow();

	testWin->Win()->SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly);

	testWin->DrawNow(topHalf);

	TheClient->iWs.Flush();

	INFO_PRINTF1(_L(" Drawn TopHalf Faded"));

	TBool retVal = TheClient->iScreen->RectCompare(TRect(TPoint(screenSize.iWidth/3,0),TSize(screenSize.iWidth/3,screenSize.iHeight/2))

						,TRect(TPoint(screenSize.iWidth/3,screenSize.iHeight/2),TSize(screenSize.iWidth/3,screenSize.iHeight/2)));

	TEST(retVal);

	if (!retVal)

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

	testWin->DrawNow(topHalf);

	TheClient->iWs.Flush();

	canFade!=TheClient->iScreen->RectCompare(TRect(TPoint(screenSize.iWidth/3,0),TSize(10,10))

															,TRect(TPoint(screenSize.iWidth/3,screenSize.iHeight/2),TSize(10,10)));

	TEST(canFade);

	if (!canFade)

		INFO_PRINTF3(_L("TheClient->iScreen->RectCompare() return value  - Expected: %d, Actual: %d"), ETrue, canFade);		

	testWin->DrawNow();

	TheClient->iWs.Flush();

	INFO_PRINTF1(_L(" All Faded (Flush)"));

	retVal = TheClient->iScreen->RectCompare(TRect(TPoint(screenSize.iWidth/3,0),TSize(screenSize.iWidth/3,screenSize.iHeight/2))

						,TRect(TPoint(screenSize.iWidth/3,screenSize.iHeight/2),TSize(screenSize.iWidth/3,screenSize.iHeight/2)));

	TEST(retVal);

	if (!retVal)

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

	testWin->Win()->SetFaded(EFalse,RWindowTreeNode::EFadeWindowOnly);

	TheClient->iWs.Flush();

	TheClient->WaitForRedrawsToFinish();

	INFO_PRINTF1(_L(" Redrawn Screen Unfaded"));

	testWin->Win()->Invalidate(topHalf);

	testWin->Win()->SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly);

	testWin->DrawNow();

	TheClient->iWs.Flush();

	INFO_PRINTF1(_L(" Re Drawn Top Half Faded Again"));

	retVal = TheClient->iScreen->RectCompare(TRect(TPoint(screenSize.iWidth/3,0),TSize(screenSize.iWidth/3,screenSize.iHeight/2))

						,TRect(TPoint(screenSize.iWidth/3,screenSize.iHeight/2),TSize(screenSize.iWidth/3,screenSize.iHeight/2)));

	TEST(retVal);

	if (!retVal)

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

	testWin->DrawNow();

	TheClient->iWs.Flush();

	INFO_PRINTF1(_L(" Re Drawn Top Half Faded Yet Again"));

	canFade!=TheClient->iScreen->RectCompare(TRect(TPoint(screenSize.iWidth/3,0),TSize(10,10))

															,TRect(TPoint(screenSize.iWidth/3,screenSize.iHeight/2),TSize(10,10)));

	TEST(canFade);

	if (!canFade)

		INFO_PRINTF3(_L("TheClient->iScreen->RectCompare() return value  - Expected: %d, Actual: %d"), ETrue, canFade);		

	testWin->DrawNow();

	TheClient->iWs.Flush();