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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/**

 @file

 @test

 @internalComponent

*/

#include <e32std.h>

#include <fbs.h>

#include "test_step_logger.h"

#include "comparison.h"

#include "utils.h"

#include "compwin.h"

#include "crpwin.h"

#include "edgedwin.h"

#include "coordinatewin.h"

#include "backedupwin.h"

#include "enormouswin.h"

#include "animatedwin.h"

#include "spritewin.h"

#include "panic.h"

const TInt KSteps = 10;

CComparison::COperationTimer::COperationTimer(CComparison* aComp):CTimer(0), iComp(aComp)

{}

void CComparison::COperationTimer::ConstructL()

	{

	CTimer::ConstructL();

	}

void CComparison::COperationTimer::DoCancel()

	{}

void CComparison::COperationTimer::RunL()

	{

	iComp->Tick();

	}

/*-------------------------------------------------------------------------*/

// COneShotCompare

CComparison::COneShotCompare* CComparison::COneShotCompare::NewL(TInt aPriority, CComparison& aComparison)

	{

	return new(ELeave)CComparison::COneShotCompare(aPriority, aComparison);

	}

CComparison::COneShotCompare::COneShotCompare(TInt aPriority, CComparison& aComparison)

	:CAsyncOneShot(aPriority), iComparison(aComparison)

	{

	}

void CComparison::COneShotCompare::RunL()

	{

	iComparison.iScreen->CopyScreenToBitmap(iComparison.iScreenBitmap);

	iComparison.SetVerifyTick(User::NTickCount());

	iComparison.Verify(iComparison.iScreenBitmap);

	}

/*-------------------------------------------------------------------------*/

_LIT(KConfigurationWindowSuffix, "-Window");

/*******************************************************************************

This is the stresslet itself

*******************************************************************************/

CComparison * CComparison::NewLC(MTestStepReporter& aReporter)

	{

	CComparison * self = new (ELeave) CComparison(aReporter);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CComparison::ConstructL()

	{

	iWatchCat = CTestExecWatchCat::NewL( CExecutionContext::ECtxRandomAndRecord );

	}

CComparison::CComparison (MTestStepReporter& aReporter):

	CStresslet(aReporter), iDifferenceBitmap(NULL), iDifferenceDevice(NULL), iOneShotCompare(NULL)

	{

	}

/**

 Sets stress-test configuration (read from ini file).

 @param aRunData configuration data

 @param aConfFactory a factory interface for creating "section" readers. These

 are used to supply configuration data for each window type.

 */

void CComparison::SetRunDataL(const TRunData& aRunData, MTestStepConfigurationContextFactory* aConfFactory)

	{

	iData = aRunData;

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

	iFs.MkDirAll(iData.loggingPath);

	iWatchCat->SetLoggingPathL(iData.loggingPath);

	//each window type can have its own configuration

	MTestStepConfigurationContext* context; //context created by the factory argument

	RBuf section; //section name (window-type + "-window"

	section.Create(32);

	CleanupStack::PushL(&section);

	struct STestStepConfEntry

		{

		const TPtrC8 iType;	//section name

		void (*iFunc)(const MTestStepConfigurationContext*); //configuration loader

		} confLoaders[] = 

		{

			{KCommonWindowType(),    CCompWin::LoadConfiguration},

			{KAnimatedWindowType(),   CAnimatedWin::LoadConfiguration},

			{KBackedupWindowType(),   CBackedupWin::LoadConfiguration},

			{KCoordinateWindowType(), CCoordinateWin::LoadConfiguration},

			{KCrpWindowType(),        CCrpWin::LoadConfiguration},

			{KEdgedWindowType(),      CEdgedWin::LoadConfiguration},

			{KEnormousWindowType(),   CEnormousWin::LoadConfiguration},

			{KSpritedWindowType(),    CSpritedWin::LoadConfiguration}

		};

	for (int i=0; i<sizeof(confLoaders)/sizeof(STestStepConfEntry); i++)

		{

		section.Copy(confLoaders[i].iType);

		section.Append(KConfigurationWindowSuffix);

		context = aConfFactory->GetConfigurationContextLC(section);

		confLoaders[i].iFunc(context);

		CleanupStack::PopAndDestroy(context);

		}

	CleanupStack::Pop(&section);

	}

void CComparison::StartL()

	{

	iStartTime.UniversalTime();

	if (iData.randomSeed > -1)

		{

		//use seed from ini file

		iFirstSeed = iData.randomSeed;

		}

	else 

		{

		// randomize seed by time

		iFirstSeed = iStartTime.Int64();

		}

	TRnd::SetSeed(iFirstSeed);

	iWasOk = ETrue;

	iMode = EAct;

	iErrorNum = 0;

	iWinGroup=new(ELeave) RWindowGroup(Session());

	User::LeaveIfError(iWinGroup->Construct( (TUint32)(iWinGroup) ));

	iWinGroup->SetOrdinalPosition(0,0);

	//make sure at least minNumWindows are created, or if it's zero no limit

	iNumWindowsLeft = iData.minNumWindows;

	iScreen = new (ELeave) CWsScreenDevice(Session());	

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

	TDisplayMode screenMode = iScreen->DisplayMode();

	iScreenBitmap = new (ELeave) CFbsBitmap;

	iScreenBitmap->Create(TSize(iData.windowWidth, iData.windowHeight), screenMode);

	iBackground = new(ELeave) RBlankWindow(Session());

	iBackground->Construct(*iWinGroup,reinterpret_cast<TUint32>(iBackground));

	iBackground->SetColor(KRgbBlack);

	iBackground->SetExtent(TPoint(0,0), TSize(iData.windowWidth, iData.windowHeight));

	iBackground->SetOrdinalPosition(0);

	iBackground->Activate();

	iCurrentBmp = 0;

	iLastBmp = 1;

	iBmpGc = CFbsBitGc::NewL();

	for (TInt bmp = 0; bmp < 2; ++bmp)

		{

		iBitmap[bmp] = new (ELeave) CFbsBitmap;

		iBitmap[bmp]->Create(TSize(iData.windowWidth, iData.windowHeight), screenMode); //EColor16MU); //

		iDevice[bmp] = CFbsBitmapDevice::NewL(iBitmap[bmp]);

		//clear bitmap background

		iBmpGc->Activate(iDevice[bmp]);

		iBmpGc->Reset();

		iBmpGc->SetPenStyle(CGraphicsContext::ENullPen);

		iBmpGc->SetBrushColor(KRgbBlack);

		iBmpGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

		TPoint origin(0,0);

		TRect rect(origin, TSize(iData.windowWidth, iData.windowHeight));

		iBmpGc->DrawRect(rect);

		}

	iDifferenceBitmap = new (ELeave) CFbsBitmap;

	iDifferenceBitmap->Create(TSize(iData.windowWidth, iData.windowHeight), screenMode); //EColor16MU); //

	iDifferenceDevice = CFbsBitmapDevice::NewL(iDifferenceBitmap);

	iTimer = new(ELeave) COperationTimer(this);

	iTimer->ConstructL();

	CActiveScheduler::Add (iTimer);

	iTimer->After(iData.initPeriod);

	}

/**

 Simulate a Left key stroke

 */

void CComparison::Touch()

	{

	User::ResetInactivityTime();

	TRawEvent keyDown;  

	keyDown.Set(TRawEvent::EKeyDown,EStdKeyLeftArrow);

	Session().SimulateRawEvent(keyDown);

	TRawEvent keyUp;

	keyUp.Set(TRawEvent::EKeyUp,EStdKeyLeftArrow);

	Session().SimulateRawEvent(keyUp);

	}

/**

 Non leaving version of TickL that reports failures

 */

TInt CComparison::Tick()

	{

	TRAPD(err, TickL());

	if (err)

		{

		REPORT_EVENT( EFalse );

		}

	return err;

	}

/**

 Called periodically 

 */

void CComparison::TickL()

	{

	if (iMustConclude)

		{

		WriteLog();

		ConcludeNow();

		return;

		}

	if (0 == iTestNum % 100)

		{

		Touch();

		}

	DoStuffL();

	if (iStuffDone)

		{

		++iTestNum;

		}

	}

/**

 Dispatch work to selected operation by mode

 */

void CComparison::DoStuffL()

	{

	iStuffDone = EFalse;

	switch (iMode)

		{

		case EAct:

			ActL();

			break;

		case EMove:

			MoveL();

			break;

		case EResize:

			ResizeL();

			break;

		};

	if (iWasOk && iData.compareBitmaps && iStuffDone)

		{

		Session().Flush();

		// schedule a delayed compare, will take place after all updates to windows

		if (iOneShotCompare == NULL)

			{

			iOneShotCompare = CComparison::COneShotCompare::NewL(EPriorityMuchLess, *this);

			}

		iOneShotCompare->Call();

		}

	else

		{

		if (iTestNum > iData.maxRunCycles && iNumWindowsLeft == 0)

			{

			iMustConclude = ETrue;

			}

		iTimer->After(iData.period);

		}

	Session().Flush();

	Session().Finish(); 

	}

/**

 Performs a random operation on a random window

 Operation can be one of create, destroy, move, bring to front/back,

 resize, tick, toggle-visibility

 */

void CComparison::ActL()

	{

	TInt action = TRnd::rnd(EACount);

	if (iWindows.Count() == 0)

		{

		action = 0;

		}

	iBehaviour.iWin = RandomWindow();

	iAct = static_cast<TAct>(action);

	switch(iAct)

		{

		case EACreate:

			CreateWindowL();

			break;

		case EADestroy:

			DestroyWindow();

			break;

		case EAMove:

			MoveWindow();

			break;

		case EAFront:

			BringWindowToFrontL();

			break;

		case EABack:

			SendWindowToBackL();

			break;

		case EAResize:

			ResizeWindow();

			break;

		case EATick:

			TickWindowL();

			break;

		case EAToggleVisible:

			ToggleVisible();

			break;

		} //lint !e787 enum constant TAct::EACount not used within switch

	}

void CComparison::MoveL()

	{

	if (iBehaviour.iCount < 1)

		{

		iMode = EAct;

		}

	else

		{

		TPoint pos = iBehaviour.iWin->Pos() + iBehaviour.iPos;

		iBehaviour.iWin->SetPos(pos);

		--iBehaviour.iCount;

		iStuffDone = ETrue;

		}

	}

void CComparison::ResizeL()

	{

	if (iBehaviour.iCount < 1)

		{

		iMode = EAct;

		}

	else

		{

		TSize size = iBehaviour.iWin->Size();

		size.iWidth += iBehaviour.iPos.iX;

		size.iHeight += iBehaviour.iPos.iY;

		iBehaviour.iWin->SetSize(size);

		--iBehaviour.iCount;

		iStuffDone = ETrue;

		}

	}

/**

 Sets the position for a future window-move command, the actual move will be 

 done in the next step 

 */

void CComparison::MoveWindow()

	{

	__UHEAP_MARK;

	if (iBehaviour.iWin)

		{

		TPoint pos = TPoint(TRnd::rnd(KPosLimit), TRnd::rnd(KPosLimit));

		pos.iX -= iBehaviour.iWin->Size().iWidth / 2;

		pos.iY -= iBehaviour.iWin->Size().iHeight / 2;

		iBehaviour.iPos = pos - iBehaviour.iWin->Pos();

		iBehaviour.iCount = KSteps;

		iBehaviour.iPos.iX /= iBehaviour.iCount;

		iBehaviour.iPos.iY /= iBehaviour.iCount;

		iMode = EMove;

		}

	__UHEAP_MARKEND;

	}

/**

 Sets the size for a future window-resize command, the actual resize will be 

 done in the next step 

 */

void CComparison::ResizeWindow()

	{

	__UHEAP_MARK;

	if (iBehaviour.iWin)

		{

		TPoint newsize = TPoint(TRnd::rnd(KPosLimit), TRnd::rnd(KPosLimit));

		TPoint oldsize;

		oldsize.iX = iBehaviour.iWin->Size().iWidth;

		oldsize.iY = iBehaviour.iWin->Size().iHeight;

		iBehaviour.iPos = newsize - oldsize;

		iBehaviour.iCount = KSteps;

		iBehaviour.iPos.iX /= iBehaviour.iCount;

		iBehaviour.iPos.iY /= iBehaviour.iCount;

		iMode = EResize;

		}

	__UHEAP_MARKEND;

	}

void CComparison::BringWindowToFrontL()

	{

	__UHEAP_MARK;

	CCompWin* win = iBehaviour.iWin;

	if (win)

		{

		win->BringToFrontL();

		TInt pos = FindTopWindow(win);

		if (pos >= 0)

			{

			iWindows.Remove(pos);

			iWindows.Append(win);

			}

		iStuffDone = ETrue;

		}

	__UHEAP_MARKEND;

	}

void CComparison::SendWindowToBackL()

	{

	__UHEAP_MARK;

	TInt ord = iBackground->OrdinalPosition();

	if (ord > 0)

		{

		CCompWin* win = iBehaviour.iWin;

		if (win)

			{

			TInt pos = FindTopWindow(win);

			if (pos >= 0)

				{

				iWindows.Remove(pos);

				iWindows.Insert(win, 0);

				win->Window()->SetOrdinalPosition(ord - 1);

				}

			else

				{

				win->SendToBackL();

				}

			iStuffDone = ETrue;

			}

		}

	__UHEAP_MARKEND;

	}

TInt CComparison::FindTopWindow(CCompWin* win)

	{

	return iWindows.Find(win);

	}

/**

 Returns a random window (which may be a NULL window)

*/

CCompWin * CComparison::RandomWindow()

	{

	if (iWindows.Count() == 0)

		{

		return 0;

		}

	TInt num = TRnd::rnd(iWindows.Count() + 1);

	if (num == iWindows.Count())

		{

		return 0;

		}

	else

		{

		return iWindows[num]->RandomWindow();

		}

	}

void CComparison::CreateWindowL()

	{

	CCompWin* parent = iBehaviour.iWin;

	CCompWin* win = CCompWin::NewLC(Session(), iWinGroup, parent, WindowGc());

	iBehaviour.iWin = win;

	if (!parent)

		{

		iWindows.AppendL(win);

		}

	CleanupStack::Pop(win);

	if (iNumWindowsLeft > 0)	//decrement window count

		{

		--iNumWindowsLeft;

		}

	iStuffDone = ETrue;

	}	

void CComparison::DestroyWindow()

	{

	CCompWin* win = iBehaviour.iWin;

	if (win)

		{

		TInt num = iWindows.Find(win);

		if (num != KErrNotFound)

			{

			iWindows.Remove(num);

			}

		delete win;

		iBehaviour.iWin = 0; // rby added

		iStuffDone = ETrue;

		}

	}	

void CComparison::TickWindowL()

	{

	CCompWin* win = iBehaviour.iWin;

	if (win)

		{

		if (win->TickL())

			{

			iStuffDone = ETrue;

			}

		}

	}

void CComparison::ToggleVisible()

	{

	__UHEAP_MARK;

	CCompWin* win = iBehaviour.iWin;

	if (win)

		{

		win->ToggleVisible();

		iStuffDone = ETrue;

		}

	__UHEAP_MARKEND;

	}

void CComparison::HandleRedraw(TWsRedrawEvent &aEvent)

	{

	__UHEAP_MARK;

	if (aEvent.Handle() != reinterpret_cast<TUint32>(iBackground))

		{

		reinterpret_cast<CCompWin*>(aEvent.Handle())->HandleRedraw(aEvent);

		}

	Session().Flush();

	__UHEAP_MARKEND;

	}

void CComparison::HandleEvent(TWsEvent &/*aEvent*/)

	{	

	}

/**

 Compares two bitmaps. Comparison is done on a pixel-by-pixel basis.

 If the bitmaps are of different sizes, the smaller axis of each is used for

 comparison (top-left subregions).

 First different pixel is stored in internally.

 @return ETrue if bitmaps match, EFalse otherwise.

*/

TBool CComparison::BitmapsMatch(const CFbsBitmap * aBitmap1, const CFbsBitmap * aBitmap2)

	{

	TDisplayMode mode1 = aBitmap1->DisplayMode();

	TDisplayMode mode2 = aBitmap2->DisplayMode();

	TSize bmpSize = aBitmap1->SizeInPixels();

	TSize bmpSize2 = aBitmap2->SizeInPixels();

	if (bmpSize2.iWidth < bmpSize.iWidth)

		{

		bmpSize.iWidth = bmpSize2.iWidth;

		}

	if (bmpSize2.iHeight < bmpSize.iHeight)

		{

		bmpSize.iHeight = bmpSize2.iHeight;

		}

	TRgb c1;

	TRgb c2;

	for (TInt y=0; y < bmpSize.iHeight; y++)

		{

		for (TInt x=0; x < bmpSize.iWidth; x++)

			{

			TPoint point(x, y);

			aBitmap1->GetPixel(c1, point);

			aBitmap2->GetPixel(c2, point);

			if (c1 != c2)

       			{

       			iPixel1 = c1.Value();

       			iPixel2 = c2.Value();

       			iPixelPos = point;

				return EFalse;

				}

			}		

		}

	return ETrue;		

	}

void CComparison::Verify(CFbsBitmap * aServerBmp)

	{	

	//Copy the currentBmp to lastBmp

	TInt dataStride = iBitmap[iCurrentBmp]->DataStride();

	TInt sizeInByte = dataStride * iBitmap[iCurrentBmp]->SizeInPixels().iHeight;

	TUint32* bitmapAddressSource = iBitmap[iCurrentBmp]->DataAddress();

	TUint32* bitmapAddressTarget = iBitmap[iLastBmp]->DataAddress();

	memcpy(bitmapAddressTarget, bitmapAddressSource, sizeInByte);

	// This method is only used by the animation and sprite windows; ignores 

	// comparisons for times that are too close to the sprite change. But as the 

	// difference error drifts, there is no point relying on it.

	if (!WindowsReadyForVerification())

		{

		Tick();

		return;

		}

	if (iWasOk)

		{

		DrawBitmap();

		const TBool bmpMatch = BitmapsMatch(aServerBmp, iBitmap[iCurrentBmp]);

		REPORT_EVENT( bmpMatch );

#ifdef __WINSCW__		

		if ( !bmpMatch )

			{

			__DEBUGGER();

			}

#endif

		if (!iData.saveOnlyDifferent || !bmpMatch)

			{

			TBuf<128> fileName;

			fileName.Append(iData.loggingPath);

			fileName.Append(_L("Stresslet_Comparison_"));

			if (iData.saveOnlyDifferent)

				{

				fileName.AppendNumFixedWidthUC((TUint)iErrorNum, EDecimal, 3);

				}

			else

				{

				fileName.AppendNumFixedWidthUC((TUint)iTestNum, EDecimal, 3);

				}

			TInt baseLength = fileName.Length();

			//previous is saved only when saving different bitmaps 

			//otherwise it is always the same as the previous expected

			if (iData.saveOnlyDifferent)

				{

				fileName.Append(_L("_Previous.mbm"));

				__ASSERT_ALWAYS(KErrNone == iBitmap[iLastBmp]->Save(fileName), Panic(EPanic6));

				}

			fileName.SetLength(baseLength);

			fileName.Append(_L("_Expected.mbm"));

			__ASSERT_ALWAYS(KErrNone == iBitmap[iCurrentBmp]->Save(fileName), Panic(EPanic7));

			fileName.SetLength(baseLength);

			fileName.Append(_L("_Screen.mbm"));

			__ASSERT_ALWAYS(KErrNone == aServerBmp->Save(fileName), Panic(EPanic8));

			//store difference between expected and screen bitmaps (XOR image)

			if (iData.saveDifferenceBitmap)

				{

				iBmpGc->Activate(iDifferenceDevice);

				iBmpGc->Reset();

				iBmpGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

				iBmpGc->BitBlt(TPoint(0,0), iBitmap[iCurrentBmp]);

				iBmpGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);

				iBmpGc->BitBlt(TPoint(0,0), aServerBmp);

				iBmpGc->Reset();

				fileName.SetLength(baseLength);

				fileName.Append(_L("_Difference.mbm"));

				__ASSERT_ALWAYS(KErrNone == iDifferenceBitmap->Save(fileName), Panic(EPanic19));

				}

			fileName.SetLength(baseLength);

			fileName.Append(_L("_info.txt"));

			RFile file;

			TInt err = file.Create(iFs, fileName, EFileWrite);

			if (err != KErrNone)

				err = file.Replace(iFs, fileName, EFileWrite);

			if (err == KErrNone)

				{

				TBuf8<128> info;

				info.Append(_L8("Seed = "));

				info.AppendNum(iFirstSeed);

				info.Append(_L8("\n"));

				file.Write(info);

				info.SetLength(0);

				TTime now;

				now.UniversalTime();

				info.Append(_L8(" Runtime = "));

				info.AppendNum(now.MicroSecondsFrom(iStartTime).Int64() / 1000);

				info.Append(_L8(" ms\r\n"));

				file.Write(info);

				info.SetLength(0);

				info.Append(_L8("Action = ["));

				info.AppendNum((TInt64)iAct);

				info.Append(_L8("]   Mode = ["));

				info.AppendNum((TInt64)iMode);

				info.Append(_L8("]   Test = ["));

				info.AppendNum((TInt64)iTestNum);

				info.Append(_L8("]\r\n"));

				file.Write(info);

				info.SetLength(0);

				info.Append(_L8("Pixel at ["));

				info.AppendNum((TInt64)iPixelPos.iX);

				info.Append(_L8(","));

				info.AppendNum((TInt64)iPixelPos.iY);

				info.Append(_L8("] mismatch screen 0x"));

				info.AppendNum((TInt64)iPixel1, EHex);

				info.Append(_L8(" != bitmap 0x"));

				info.AppendNum((TInt64)iPixel2, EHex);

				info.Append(_L8("\r\n\r\n"));

				file.Write(info);

				TPoint zero(0,0);

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

					{

					iWindows[num]->Dump(file, zero, 0, iBehaviour.iWin);

					info.SetLength(0);

					info.Append(_L8("\r\n"));

					file.Write(info);

					}				

				file.Close();

				}

			else

				{

				//failed create logfile

				__ASSERT_ALWAYS(EFalse, Panic(EPanic9));

				}

			if (!bmpMatch)

				{

				++iErrorNum;

				}

			}

		}	

	if ((iTestNum > iData.maxRunCycles && iNumWindowsLeft == 0) || !iWasOk)

		{

		iMustConclude = ETrue;

		}

	iTimer->After(iData.period);

	}

/**

Write information(eg. seed, starttime, endtime and time elapse) to Stresslet_Log.txt file 

*/

void CComparison::WriteLog()

	{

	TBuf<128> fileName;

	fileName.Append(iData.loggingPath);

	fileName.Append(_L("Stresslet_Log.txt"));

	RFile file;

	TInt err = file.Create(iFs, fileName, EFileWrite);

	if (err != KErrNone)

		{

		err = file.Replace(iFs, fileName, EFileWrite);

		}

	if (err == KErrNone)

		{

		TBuf8<128> info;

		info.Append(_L8("Seed = "));

		info.AppendNum(iFirstSeed);

		info.Append(_L8("\r\n"));

		file.Write(info);

		info.SetLength(0);

		TBuf<40> dateTimeString;

	    _LIT(KFormat2,"%D%M%Y%/0%1%/1%2%/2%3%/3 %:0%H%:1%T%:2%S.%C%:3");

	    iStartTime.FormatL(dateTimeString,KFormat2);

		info.Append(_L8("StartTime = "));

		info.Append(dateTimeString);

		info.Append(_L8("\r\n"));

		TTime now;

		now.UniversalTime();

		now.FormatL(dateTimeString,KFormat2);

		info.Append(_L8("Endtime = "));

		info.Append(dateTimeString);

		info.Append(_L8("\r\n"));

		info.Append(_L8("Elapse = "));

		info.AppendNum(now.MicroSecondsFrom(iStartTime).Int64() / 1000);

		info.Append(_L8(" ms\r\n"));

		file.Write(info);

		file.Close();

		}

	}

/**

 Returns true if all visible windows are ready for verification

 */

TBool CComparison::WindowsReadyForVerification() const

	{

	TBool res = ETrue;

	TInt idx = 0;

	while ( idx < iWindows.Count() && res )

		{

		if ( iWindows[ idx ]->IsVisible() )

			{

			res = iWindows[ idx ]->QueryReadyForVerification();

			}

		idx++;

		}

	return res;

	}

/**

 Calls all windows to draw themselves on a bitmap

 */

void CComparison::DrawBitmap()

	{

	iBmpGc->Activate(iDevice[iCurrentBmp]);

	iBmpGc->Reset();

	// clear background area

	iBmpGc->SetPenStyle(CGraphicsContext::ENullPen);

	iBmpGc->SetBrushColor(KRgbBlack);

	iBmpGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	TPoint origin(0,0);

	TRect rect(origin, TSize(iData.windowWidth, iData.windowHeight));

	//create a region containing all screen, subtract all visible windows

	RRegion backClipping(rect);

	if (!iData.clearAllBackground)

		{

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

			{

			if (iWindows[num]->IsVisible())

				iWindows[num]->SubSelfFromRegion(backClipping, rect, origin);

			}

		}

	//clip drawing to background only & clear

	iBmpGc->SetClippingRegion(backClipping);

	iBmpGc->DrawRect(rect);

	//go back to no clipping

	iBmpGc->CancelClipping();

	backClipping.Close();

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

		{

		if (iWindows[num]->IsVisible())

			{

			iWindows[num]->ClearBitmapBackground(iBmpGc, rect, origin);

			iWindows[num]->DrawBitmap(iBmpGc, rect, origin);

			}

		}

	}

void CComparison::SetVerifyTick(TUint32 aTick)

	{

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

		{

		if (iWindows[num]->IsVisible())

			iWindows[num]->SetVerifyTick(aTick);

		}

	}

CComparison::~CComparison()

	{

	iFs.Close();

	if (iBackground)

		{

		iBackground->Close();

		delete iBackground;

		}	

	iWindows.ResetAndDestroy();

	if (iWinGroup)

		{

		iWinGroup->Close();

		delete iWinGroup;

		}

	delete iOneShotCompare; //delayed compare

	delete iDifferenceDevice;

	delete iDifferenceBitmap;

	for (TInt bmp = 0; bmp < 2; ++bmp)

		{

		delete iDevice[bmp];

		delete iBitmap[bmp];

		}

	delete iBmpGc;

	delete iTimer;

	delete iScreenBitmap;

	delete iScreen;

	}