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

//

#include <e32std.h>

#include <hal.h>

#include <u32hal.h>

#include <limits.h>

#include <e32const.h>

#include <graphics/surfaceupdateclient.h>

#include <graphics/suerror.h>

#include <graphics/wstestscreencapture.h>

#include <graphics/testscreencapture.h>

#include "surfaceupdatetest.h"

#include "tsurfaceupdateinteg.h"

#include "twindows.h"

#include "tredrawhandler.h"

#include "tsurfacehelper.h"

const TSize windowSize(160, 100);

const TSize windowHalfSize(windowSize.iWidth / 2, 100);

const TPoint windowTopLeft(10,10);

const TPoint windowTopMiddle(windowTopLeft.iX + windowSize.iWidth / 2, windowTopLeft.iY);

CTSurfaceUpdateInteg::CTSurfaceUpdateInteg(CTestStep* aStep) :

	CTGraphicsBase(aStep)

	{

	}

CTSurfaceUpdateInteg::~CTSurfaceUpdateInteg()

	{

	iWindows.ResetAndDestroy();

	iGroups.ResetAndDestroy();

	iWsDevs.ResetAndDestroy();

	iGcs.ResetAndDestroy();

	delete iRedrawHandler;

	iSurfaceUpdate.Close();

	delete iSurfaceHelper;

	iBitmaps.ResetAndDestroy();

	delete iGraphicsContext;

	delete iBitmapDevice;

	delete iRefBitmap;

	iWs.Close();

	}

/**

 * Create a screen device, drawing context and a window for each screen.

 * Create surfaces, open connection to the SUS.

 */

void CTSurfaceUpdateInteg::ConstructL()

	{

	INFO_PRINTF1(_L("Test case construction"));

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

	iNumOfScreens = iWs.NumberOfScreens();

	iSurfaceHelper = CSurfaceHelper::NewL();

	const TInt stride = windowSize.iWidth * 4;

	const TInt stride1 = windowHalfSize.iWidth * 4;

	iSurface = iSurfaceHelper->CreateSurfaceL(windowSize, EUidPixelFormatXRGB_8888, stride,1);

	iSurfaceDoubleBuffered = iSurfaceHelper->CreateSurfaceL(windowSize, EUidPixelFormatXRGB_8888, stride,2);

	iSurfaceAbove = iSurfaceHelper->CreateSurfaceL(windowHalfSize, EUidPixelFormatXRGB_8888, stride1, 1);

	iSurfaceAbove1 = iSurfaceHelper->CreateSurfaceL(windowSize, EUidPixelFormatXRGB_8888, stride, 1);

	INFO_PRINTF1(_L("The surfaces have been created"));

	iRefBitmap = new (ELeave)CFbsBitmap();

	User::LeaveIfError(iRefBitmap->Create(windowSize,EColor16MU));

	iBitmapDevice = CFbsBitmapDevice::NewL(iRefBitmap);

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

	//fill the whole surfaces with different color

	iSurfaceHelper->FillRectangleL(iSurfaceAbove, TPoint(), windowHalfSize, KRgbYellow);

	iSurfaceHelper->FillRectangleL(iSurfaceAbove1, TPoint(), windowSize, KRgbYellow);

	iSurfaceHelper->FillRectangleL(iSurface, TPoint(), windowSize, KRgbGreen);

	iSurfaceHelper->FillRectangleL(iSurfaceDoubleBuffered, TPoint(), windowSize, KRgbCyan);

	FillRefBitmap(KRgbGreen);

	INFO_PRINTF1(_L("The surfaces and a reference bitmap have been filled with color"));

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

	iRedrawHandler = new (ELeave) CTRedrawHandler(iWs); //will deal with all redrawing command

	iRedrawHandler->Start();

	//create windows and assign surfaces to them

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

		{

		CWsScreenDevice* wsDev = new (ELeave) CWsScreenDevice(iWs);

		iWsDevs.AppendL(wsDev);

		User::LeaveIfError(wsDev->Construct(ii));

		CWindowGc* gc = NULL;

		User::LeaveIfError(wsDev->CreateContext(gc));

		iGcs.AppendL(gc);

		CTWindowGroup* defaultGroup = CreateGroupL(wsDev);

		CTWindow* windowSingle = CTWindow::NewL(iWs, *defaultGroup, *gc);

		RegisterWindowL(windowSingle);

		windowSingle->Window()->SetExtent(windowTopLeft, windowSize);

		windowSingle->Window()->SetBackgroundSurface(iSurface);

		windowSingle->Window()->Activate();

		CTWindow* windowDouble = CTWindow::NewL(iWs, *defaultGroup, *gc);

		RegisterWindowL(windowDouble);

		windowDouble->Window()->SetExtent(windowTopLeft, windowSize);

		windowDouble->Window()->SetBackgroundSurface(iSurfaceDoubleBuffered);

		windowDouble->Window()->SetVisible(EFalse);

		windowDouble->Window()->Activate();

		CTWindow* windowAbove = CTWindow::NewL(iWs, *iGroups[ii], *iGcs[ii]);

		RegisterWindowL(windowAbove);

		windowAbove->Window()->SetExtent(windowTopLeft, windowHalfSize);

		windowAbove->Window()->SetBackgroundSurface(iSurfaceAbove);

		windowAbove->Window()->SetVisible(EFalse);

		windowAbove->Window()->Activate();

		if(ii == 0)

			{

			iWindowAbove11 = CTWindow::NewL(iWs, *iGroups[ii], *iGcs[ii]);

			RegisterWindowL(iWindowAbove11);

			iWindowAbove11->Window()->SetExtent(windowTopLeft, windowSize);

			iWindowAbove11->Window()->SetBackgroundSurface(iSurfaceAbove1);

			iWindowAbove11->Window()->SetVisible(EFalse);

			iWindowAbove11->Window()->Activate();

			iWindowAbove1 = windowAbove;

			iWindowSingleBuffured1 = windowSingle;

			iWindowDoubleBuffured1 = windowDouble;

			}

		else

			{

			iWindowAbove2 = windowAbove;

			iWindowSingleBuffured2 = windowSingle;

			iWindowDoubleBuffured2 = windowDouble;

			}

	    TPixelsTwipsAndRotation sizeAndRotation;

	    iWsDevs[ii]->GetDefaultScreenSizeAndRotation(sizeAndRotation);

	    CFbsBitmap* bitmap = new (ELeave)CFbsBitmap();

	    iBitmaps.AppendL(bitmap);

	    User::LeaveIfError(bitmap->Create(sizeAndRotation.iPixelSize, EColor16MU));

        INFO_PRINTF4(_L("Bitmap with size: %d, %d was created to match the size of the screen %d"), sizeAndRotation.iPixelSize.iWidth, sizeAndRotation.iPixelSize.iHeight, ii);

		}

	INFO_PRINTF1(_L("The windows have been created"));

	iWs.Finish();

	}

/**

 * Create the window group for the given screen device and put it into the list.

 */

CTWindowGroup* CTSurfaceUpdateInteg::CreateGroupL(CWsScreenDevice* aScreenDevice)

	{

	CTWindowGroup* group = CTWindowGroup::NewL(iWs, aScreenDevice);

	CleanupStack::PushL(group);

	iGroups.AppendL(group);

	CleanupStack::Pop();

	return group;

	}

/**

 * Append a window into the list for retrawing it and destroying in the future.

 */

void CTSurfaceUpdateInteg::RegisterWindowL(CTWindowTreeNode* aWindow)

	{

	CleanupStack::PushL(aWindow);

	iWindows.AppendL(aWindow);

	CleanupStack::Pop(aWindow);

	}

/**

 * Go through all screens and compare the whole surface area with the reference bitmap.

 * 

 * @return ETrue, if the surface is exactly the same as the reference bitmap or EFalse otherwise. 

 */

TBool CTSurfaceUpdateInteg::CompareAllScreens()

	{

	TBool res = ETrue;

	TRect rc(windowTopLeft, windowSize);

	for(TInt ii = 0; (ii < iNumOfScreens) && res; ii++)

		{

		res = Compare(ii, rc, iRefBitmap);

		}

	return res;

	}

/**

 * Compare part of the screen with the reference bitmap.

 * 

 * @param aScreenNumber Screen number.

 * @param aRectSrc The area of the screen to be compared.

 * @param aRefBitmap Bitmap for comparison.

 * @return ETrue, if given part of the screen is exactly the same as the reference bitmap or EFalse otherwise. 

 */

TBool CTSurfaceUpdateInteg::Compare(TInt aScreenNumber, const TRect& aRectSrc, CFbsBitmap* aRefBitmap)

	{

	MTestScreenCapture* csc = static_cast<MTestScreenCapture*> (iWsDevs[aScreenNumber]->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf));

	if(!csc) //shouldn't happen, as we have checked this before

		{

		return EFalse;

		}

	TBool res = ETrue;

	TInt ret = csc->ComposeScreen(*(iBitmaps[aScreenNumber]));

	if(ret != KErrNone)

		{

		INFO_PRINTF2(_L("Composition screen failure, err = %d"), ret);

		res = EFalse;

		}

	//Go through all pixels in screen bitmap for specified area and check that they are 

	//identical to corresponding pixels in reference bitmap

	for(TInt ii = 0; (ii < aRectSrc.Height()) && res; ii++)

		{

		for(TInt jj = 0; (jj < aRectSrc.Width()) && res; jj++)

			{

			TRgb refCol;

			aRefBitmap->GetPixel(refCol, TPoint(jj, ii));

			TRgb col;

			(iBitmaps[aScreenNumber])->GetPixel(col, TPoint(jj, ii) + aRectSrc.iTl);

			if(refCol != col)

				{

				res = EFalse;

				}

			}

		}

	//useful for debugging

#ifdef TEST_COMPARE_PARTLY_UPDATED_SCREEN 	

	if(!res)

		{

		iBitmap->Save(_L("c:\\bitmap.mbm"));

		aRefBitmap->Save(_L("c:\\ref.mbm"));

		}

#endif

	return res;

	}

/**

 * Fill reference bitmap with color specified.

 * 

 */

void CTSurfaceUpdateInteg::FillRefBitmap(TRgb aColor)

	{

	TRect rect = TRect(iRefBitmap->SizeInPixels());

	iGraphicsContext->SetBrushColor(aColor);

	iGraphicsContext->SetPenColor(aColor);

	iGraphicsContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iGraphicsContext->DrawRect(rect);

	}

/**

  @SYMTestCaseID  GRAPHIC-SURFACEUPDATE-0026

  @SYMCR CR1650

  @SYMREQ REQ11596

  @SYMTestCaseDesc 

  	SubmitUpdate() to cope with Global Updates with surface on various 

  	screens when the dirty region to update may not be visible on all screens

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions The test consists of a single surface, visible on 

  screens A (master), B.

	1.	Submit a global update for the surface, passing a null dirty region.

	2.	Submit a global update for the surface, passing a dirty region 

	that is only visible on screens A  (that particular region for the 

	surface is not visible on B).

	3.	Submit a global update for the surface, passing a dirty region 

	that is only visible on screens B (that particular region for the 

	surface is not visible on A).

	4.	Submit a global update for the surface, passing a dirty 

	region that is not visible on any of the screens.

  @SYMTestExpectedResults 

  	1.	TRequestStatus signals KErrNone in all cases. Timestamps must 

  	be valid. The surface gets updated on all screens.

	2.	TRequestStatus signals KErrNone in all cases. Timestamps must 

	be valid. The surface gets updated only on screens A. Screen B is unchanged.

	3.	TRequestStatus signals KErrNone in all cases. Timestamps must 

	be valid. The surface gets updated only on screens B. 

	Screen A is unchanged.

	4.	SubmitUpdate() returns KErrNone.

*/

void CTSurfaceUpdateInteg::TestCase1L()

	{

	INFO_PRINTF1(_L("Global Submit Update with/without update region supplied"));

	const TInt bufferNumber = 0; 

	TRequestStatus status = KRequestPending;

	TRequestStatus status1 = KRequestPending;

	TRequestStatus status2 = KRequestPending;

	TUint64 timestampComposition = 0;

	TTimeStamp timeStamp; 

	//Fill the surface to different colour, submit update for the whole surface 

	//and check that screen is updated correctly

	INFO_PRINTF1(_L("Fill the surface with the blue color"));

	iSurfaceHelper->FillRectangleL(iSurface, TPoint(), windowSize, KRgbBlue);

	FillRefBitmap(KRgbBlue);

	INFO_PRINTF1(_L("Updating the whole area of the surface"));

	TUint64 timestampBefore = User::FastCounter();

	iSurfaceUpdate.NotifyWhenAvailable(status);	

	iSurfaceUpdate.NotifyWhenDisplayed(status1, timeStamp);	

	iSurfaceUpdate.NotifyWhenDisplayedXTimes(10, status2);

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber);

	User::WaitForRequest(status);

	User::WaitForRequest(status1);

	User::WaitForRequest(status2);

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	TUint64 timestampAfter = User::FastCounter();

	if(timestampAfter < timestampBefore)

		{

		timestampAfter += UINT_MAX;

		}

	timestampComposition = timeStamp();

	if(timestampComposition < timestampBefore)

		{

		timestampComposition += UINT_MAX;

		}

	TEST(status == KErrNone);

	TEST(status1 == KErrNone);

	TEST(status2 == KErrNone);

	TEST(timestampComposition != 0);

	TEST(timestampAfter >= timestampComposition);

	TEST(timestampBefore <= timestampComposition);

	TEST(CompareAllScreens());

	//Fill the surface to different colour; hide the part of the surface on 

	//the screen which is not a master, submit update for the area of the surface 

	//which is only visible on the master. Check that only master screen gets updated.

	INFO_PRINTF1(_L("Hide the part of the surface on the second screen"));

	iWindowAbove1->Window()->SetVisible(EFalse);

	iWindowAbove2->Window()->SetVisible(ETrue);

	iWs.Finish();

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber);

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	INFO_PRINTF1(_L("Fill the surface with the green color"));

	iSurfaceHelper->FillRectangleL(iSurface, TPoint(), windowSize, KRgbGreen);

	TRect rc(windowHalfSize);

	rc.Shrink(10, 10);

	RRegion region(1, &rc); //this area is hidden if the window above is visible

	timestampBefore = User::FastCounter();

	iSurfaceUpdate.NotifyWhenAvailable(status);	

	iSurfaceUpdate.NotifyWhenDisplayed(status1, timeStamp);	

	iSurfaceUpdate.NotifyWhenDisplayedXTimes(10, status2);

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber, &region);

	User::WaitForRequest(status);

	User::WaitForRequest(status1);

	User::WaitForRequest(status2);

	User::After(TTimeIntervalMicroSeconds32(1000000)); //useful for visual checking

	timestampAfter = User::FastCounter();

	if(timestampAfter < timestampBefore)

		{

		timestampAfter += UINT_MAX;

		}

	timestampComposition = timeStamp();

	if(timestampComposition < timestampBefore)

		{

		timestampComposition += UINT_MAX;

		}

	TEST(status == KErrNone);

	TEST(status1 == KErrNone);

	TEST(status2 == KErrNone);

	TEST(timestampComposition != 0);

	TEST(timestampAfter >= timestampComposition);

	TEST(timestampBefore <= timestampComposition);

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	//first screen should be updated, as the surface is visible here

	TRect rectSrc = rc;

	rectSrc.Move(windowTopLeft);

	FillRefBitmap(KRgbGreen);

	TEST(Compare(0, rectSrc, iRefBitmap));

	//check that second screen doesn't update visible part of the surface 

	FillRefBitmap(KRgbYellow);

	TEST(Compare(1, rectSrc, iRefBitmap));

	//Fill the surface to different colour; hide the part of the surface 

	//on the master screen, submit update for the area of the surface 

	//which is only visible on non-master. Check that only non-master screen gets updated.

	INFO_PRINTF1(_L("Hide the part of the surface on the first screen"));

	iWindowAbove1->Window()->SetVisible(ETrue);

	iWindowAbove2->Window()->SetVisible(EFalse);

	iWs.Finish();

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	INFO_PRINTF1(_L("Fill the surface with the blue color"));

	iSurfaceHelper->FillRectangleL(iSurface, TPoint(), windowSize, KRgbBlue);

	timestampBefore = User::FastCounter();

	iSurfaceUpdate.NotifyWhenAvailable(status);	

	iSurfaceUpdate.NotifyWhenDisplayed(status1, timeStamp);	

	iSurfaceUpdate.NotifyWhenDisplayedXTimes(10, status2);

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber, &region);

	User::WaitForRequest(status);

	User::WaitForRequest(status1);

	User::WaitForRequest(status2);

	User::After(TTimeIntervalMicroSeconds32(1000000)); //useful for visual checking

	timestampAfter = User::FastCounter();

	if(timestampAfter < timestampBefore)

		{

		timestampAfter += UINT_MAX;

		}

	timestampComposition = timeStamp();

	if(timestampComposition < timestampBefore)

		{

		timestampComposition += UINT_MAX;

		}

	TEST(status == KErrNone);

	TEST(status1 == KErrNone);

	TEST(status2 == KErrNone);

	TEST(timestampComposition != 0);

	TEST(timestampAfter >= timestampComposition);

	TEST(timestampBefore <= timestampComposition);

	//check that first screen doesn't update visible part of the surface 

	FillRefBitmap(KRgbYellow);

	TEST(Compare(0, rectSrc, iRefBitmap));

	//second screen should be updated, as the surface is visible here

	FillRefBitmap(KRgbBlue);

	TEST(Compare(1, rectSrc, iRefBitmap));

	//Fill the surface to different colour; hide the part of the surface on the master screen, 

	//submit update for the area of the surface which is not visible on any screen. 

	//Check that all screens have not been updated.

	INFO_PRINTF1(_L("Hide partly the surface on two screens"));

	iWindowAbove1->Window()->SetVisible(ETrue);

	iWindowAbove2->Window()->SetVisible(ETrue);

	iWs.Finish();

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber);

	User::After(TTimeIntervalMicroSeconds32(1000000)); //useful for visual checking

	INFO_PRINTF1(_L("Fill the surface with the green color"));

	iSurfaceHelper->FillRectangleL(iSurface, TPoint(), windowSize, KRgbGreen);

	FillRefBitmap(KRgbGreen);

	timestampBefore = User::FastCounter();

	iSurfaceUpdate.NotifyWhenAvailable(status);	

	iSurfaceUpdate.NotifyWhenDisplayed(status1, timeStamp);	

	iSurfaceUpdate.NotifyWhenDisplayedXTimes(10, status2);

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber, &region);

	User::WaitForRequest(status);

	User::WaitForRequest(status1);

	User::WaitForRequest(status2);

	User::After(TTimeIntervalMicroSeconds32(1000000)); //useful for visual checking

	timestampAfter = User::FastCounter();

	if(timestampAfter < timestampBefore)

		{

		timestampAfter += UINT_MAX;

		}

	timestampComposition = timeStamp();

	if(timestampComposition < timestampBefore)

		{

		timestampComposition += UINT_MAX;

		}

	TEST(status == KErrNone);

	TEST(status1 == KErrNone);

	TEST(status2 == KErrNone);

	TEST(timestampComposition != 0);

	TEST(timestampAfter >= timestampComposition);

	TEST(timestampBefore <= timestampComposition);

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	//both first and second screen shouldn't be updated, as the surface is not visible here

	FillRefBitmap(KRgbYellow);

	TEST(Compare(0, rectSrc, iRefBitmap));

	TEST(Compare(1, rectSrc, iRefBitmap));

	INFO_PRINTF1(_L("Return to the initial state"));

	iWindowAbove1->Window()->SetVisible(EFalse);

	iWindowAbove2->Window()->SetVisible(EFalse);

	iWs.Finish();

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber);

	User::After(TTimeIntervalMicroSeconds32(1000000)); //useful for visual checking

	FillRefBitmap(KRgbGreen);

	TEST(CompareAllScreens());

	}

/**

  @SYMTestCaseID GRAPHIC-SURFACEUPDATE-0031

  @SYMCR CR1650

  @SYMREQ REQ11598

  @SYMTestCaseDesc NotifyWhenAvailable() to deal with global updates and be signalled 

 	correctly when screen is unplugged.

  @SYMTestPriority 	High

  @SYMTestStatus Implemented

  @SYMTestActions 

 	The test consists of a double-buffered surface, visible on screens A 

 	(master) and B,

	1	Make global submit update with notify when available for the buffer 1.

	2	Unplug screen A (notification is still in a progress )

	3	Make global submit update with notify when available for the 

	buffer 2 to trigger notification.

	4	Make global submit update with notify when available for the 

	buffer 1.