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

 // 

 //

 #include <w32std.h>

 #include <e32std.h>

 #include "cwsgcecsc.h"

 #include "extendtef.h"

 #include "teflogextensions.h"

 #include "testscreencapture.h"

 #if defined(__X86GCC__)

 extern "C" TInt atexit(void (*function)(void))

 	{

 	return KErrNone;

 	}

 #endif

 void TefUnitFailLeaveL()

 	{

 	User::Leave(KErrTEFUnitFail);

 	}

 CWSGceCsc::CWSGceCsc()

 	{

 	}

 CWSGceCsc::~CWSGceCsc()

 	{

 	}

 /**

 Common set up code for all tests.

 Creates the session and window group for further windows, plus a simple white

 background to obscure any unwanted stuff behind the test. Sets up the surface

 update session and surface manager, to work with surfaces. Creates a screen

 device for use in the tests.

 */

 void CWSGceCsc::SetupL()

 	{

 	CWsGceCscBase::SetupL();

 	}

 /**

 Common tear down code for all tests.

 Windows, group and session created are closed. Screen device is destroyed.

 Surfaces, manager and update session are closed.

 */

 void CWSGceCsc::TearDownL()

 	{

 	CWsGceCscBase::TearDownL();

 	}

 CTestSuite* CWSGceCsc::CreateSuiteL( const TDesC& aName)

 	{

 	SUB_SUITE;

 	ADD_WSGCE_TEST_STEP(CWSGceCsc, GRAPHICS_WSERV_CSC_101L);

 	ADD_WSGCE_TEST_STEP(CWSGceCsc, GRAPHICS_WSERV_CSC_102L);

 	ADD_WSGCE_TEST_STEP(CWSGceCsc, GRAPHICS_WSERV_CSC_103L);

 	ADD_WSGCE_TEST_STEP(CWSGceCsc, GRAPHICS_WSERV_CSC_104L);

 	ADD_WSGCE_TEST_STEP(CWSGceCsc, GRAPHICS_WSERV_CSC_105L);

 	END_SUITE;

 	}

 /**

  @SYMTestCaseID			GRAPHICS_WSERV_CSC_101L

  @SYMTestCaseDesc		Compare the screen composition using the new and legacy API

  @SYMPREQ				CSC

  @SYMTestStatus			Implemented

  @SYMTestPriority		1

  @SYMTestPurpose		To check that the screen composition retrieved using the new and legacy APIs

  @SYMTestActions		Initialization.

 						Construct a background opaque window.

 						Create two bitmaps with the size equal with the composition.

 						Draw something on the screen.

 						Use legacy API CopyScreenToBitmap() to copy the screen to first bitmap.

 						Use the the new API to copy the composition of the screen.

 						Compare the results.

  @SYMTestExpectedResults  The bitmap should be identical	 

 */

 void CWSGceCsc::GRAPHICS_WSERV_CSC_101L()

 	{

 	TRect screen(iScreenDevice->SizeInPixels());

 	RWindow nonSurfacedWindow(iSession);

 	iTestName.Format(_L("GRAPHICS_WSERV_CSC_101L"));

 	INFO_PRINTF2(_L("%S"),&iTestName);

 	iDisplayMode = iScreenDevice->DisplayMode();	// Get default display mode

 	ConstructOpaqueWindowLC(nonSurfacedWindow, 

 			                iCyan, 

 		                    0, 

                             TPoint(0, 0),

                             screen.Size());

 	iSession.Flush();

 	Pause(1000);

 	MTestScreenCapture* csc = static_cast<MTestScreenCapture*> (iScreenDevice->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf));

     ASSERT_NOT_NULL(csc);

 	TSize compositionScreenSize;

 	User::LeaveIfError(csc->GetCompositedSize(compositionScreenSize));

     CFbsBitmap *bmp1 = new (ELeave) CFbsBitmap;

     CleanupStack::PushL(bmp1);

     User::LeaveIfError(bmp1->Create(compositionScreenSize, EColor16MU));

     CFbsBitmap *bmp2 = new (ELeave) CFbsBitmap;

     CleanupStack::PushL(bmp2);

 	User::LeaveIfError(bmp2->Create(compositionScreenSize, EColor16MU));

 	iSession.Flush();

 	Pause(200);

 	iScreenDevice->CopyScreenToBitmap(bmp1);

 	User::LeaveIfError(csc->ComposeScreen(*bmp2));

 	SetBackgroundColorWindow(nonSurfacedWindow, iRed);

 	iSession.Flush();

 	Pause(500);

 	iGc->Activate(nonSurfacedWindow);

 	iGc->BitBlt(TPoint(0, 0), bmp1);

 	iGc->Deactivate();

 	iSession.Flush();

 	Pause(500);

 	SetBackgroundColorWindow(nonSurfacedWindow, iWhite);

 	iSession.Flush();

 	Pause(500);

 	iGc->Activate(nonSurfacedWindow);

 	iGc->BitBlt(TPoint(0, 0), bmp2);

 	iGc->Deactivate();

 	iSession.Flush();

 	Pause(500);

     ASSERT_TRUE(Compare(*bmp1, *bmp2));    

 	if (GCEIsSupported())

 		{

 		iUtility->DestroyAll();

 		}

 	CleanupStack::PopAndDestroy(bmp2);

 	CleanupStack::PopAndDestroy(bmp1);

 	CleanupStack::PopAndDestroy(&nonSurfacedWindow);

 	iSession.Flush();

 	Pause(1000);

 	}

 void CWSGceCsc::DrawBasicPattern (RWindow& aWin)

     {

     TSize rectSize(100, 100);

     aWin.Invalidate();

     aWin.BeginRedraw();

     iGc->Activate(aWin);

     iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

     iGc->SetBrushColor(KRgbDarkRed);

     iGc->DrawRect(TRect(TPoint(35, 5), rectSize));

     iGc->SetBrushColor(KRgbBlack);

     iGc->DrawRect(TRect(TPoint(55, 15), rectSize));

     iGc->SetBrushColor(KRgbDarkBlue);

     iGc->DrawRect(TRect(TPoint(75, 35), rectSize));

     iGc->SetBrushColor(KRgbYellow);

     iGc->DrawRect(TRect(TPoint(95, 55), rectSize));

     iGc->Deactivate();

     aWin.EndRedraw();

     iSession.Flush();

     Pause(500);

     }

 /**

  @SYMTestCaseID			GRAPHICS_WSERV_CSC_102L

  @SYMTestCaseDesc		Compare the screen composition using the new and legacy API

  @SYMPREQ				CSC

  @SYMTestStatus			Implemented

  @SYMTestPriority		1

  @SYMTestPurpose		To check that the screen composition retrieved using the new and legacy APIs 

  @SYMTestActions		Initialization.

  						Draw a pattern on the screen

  						Retrieve to a bitmap the UI content using the legacy API

  						Blank the screen.

  						Display the retrieved content to a surface

  						Retrieve the composited content

  						Compare the UI content with the composited content

  						NOTE:assumes current screen mode is at 0 offset

  @SYMTestExpectedResults  The UI content should be identical with the composited content	 

 */

 void CWSGceCsc::GRAPHICS_WSERV_CSC_102L()

 	{

 	TRect screen(iScreenDevice->SizeInPixels());

 	RWindow testWindow(iSession);

 	RWindow surfacedTestWindow(iSession);

 	TSurfaceId surfaceID;

     MTestScreenCapture* csc = static_cast<MTestScreenCapture*> (iScreenDevice->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf));

     ASSERT_NOT_NULL(csc);

 	TSize compositionScreenSize;

 	User::LeaveIfError(csc->GetCompositedSize(compositionScreenSize));

 	iTestName.Format(_L("GRAPHICS_WSERV_CSC_102"));

 	INFO_PRINTF2(_L("%S"),&iTestName);

 	iDisplayMode = iScreenDevice->DisplayMode();

 	TRAPD(err, surfaceID = iUtility->CreateSurfaceL(compositionScreenSize, 

 			                                        KSurfaceFormat, 

 			                                        compositionScreenSize.iWidth * KBytesPerPixel));

 	ASSERT_EQUALS(err,KErrNone);

 	ConstructOpaqueWindowLC(testWindow, 

 			                iWhite, 

 		                    0, 

                             TPoint(0, 0),

                             compositionScreenSize);

 	iSession.Flush();

 	Pause(100);

 	CFbsBitmap *bmp1 = new (ELeave) CFbsBitmap;

 	CleanupStack::PushL(bmp1);

 	User::LeaveIfError(bmp1->Create(compositionScreenSize, EColor16MU));

 	CFbsBitmap *bmp2 = new (ELeave) CFbsBitmap;

 	CleanupStack::PushL(bmp2);

 	User::LeaveIfError(bmp2->Create(compositionScreenSize, EColor16MU));

 	iSession.Flush();

 	Pause(500);

 	SetBackgroundColorWindow(testWindow, iWhite);

 	DrawBasicPattern (testWindow);

 	iScreenDevice->CopyScreenToBitmap(bmp1);

 	iSession.Flush();

     Pause(100);

 	ConstructOpaqueSurfacedWindowLC(surfacedTestWindow, 

 			                        iRed,

 		                            0,

 		                            TPoint(0, 0),

 		                            compositionScreenSize,

 		                            surfaceID);

 	TRAP(err,iUtility->FillSurfaceL(surfaceID, iCyan));

 	ASSERT_EQUALS(err,KErrNone);

 	iSession.Flush();

     Pause(500);

 	TRAP(err, iUtility->CopyBitmapToSurfaceL(surfaceID, *bmp1));

 	ASSERT_EQUALS(err,KErrNone);

 	iSession.Flush();

     Pause(500);

 	User::LeaveIfError(csc->ComposeScreen(*bmp2));

     ASSERT_TRUE(Compare(*bmp1, *bmp2));    

 	iUtility->DestroyAll();

 	CleanupStack::PopAndDestroy(&surfacedTestWindow);

 	CleanupStack::PopAndDestroy(bmp2);

 	CleanupStack::PopAndDestroy(bmp1);

 	CleanupStack::PopAndDestroy(&testWindow);

 	iSession.Flush();

 	Pause(1000);

 	}

 /**

  @SYMTestCaseID			GRAPHICS_WSERV_CSC_103L

  @SYMTestCaseDesc		Test TranslateExtent

  @SYMPREQ				CSC

  @SYMTestStatus			Implemented

  @SYMTestPriority		1

  @SYMTestPurpose		To check that the correct translated extent is returned to the client 

  @SYMTestActions		Initialization

  						Change to app mode with offset and 90 degrees rotation

  						Translate a rectangle corresponding to the original app mode

  						Compare the expected rectangle with the translated rectangle

  @SYMTestExpectedResults  The translated rectangle should take into account the offset and rotation

 							and be equal to the expected rectangle

 */

 void CWSGceCsc::GRAPHICS_WSERV_CSC_103L()

 	{

 	TRect screen(iScreenDevice->SizeInPixels());

 	RWindow testWindow(iSession);

 	iTestName.Format(_L("GRAPHICS_WSERV_CSC_103L"));

 	INFO_PRINTF2(_L("%S"),&iTestName);

 	iDisplayMode = iScreenDevice->DisplayMode();

 	ConstructOpaqueWindowLC(testWindow, 

 			                iWhite, 

 		                    0, 

                             TPoint(0, 0),

                             screen.Size());

 	iSession.Flush();

 	Pause(1000);

 	// Get the screen modes

 	RArray<TInt> modeList;

 	TInt err = iScreenDevice->GetScreenSizeModeList(&modeList);

 	ASSERT_TRUE(err > 1);  //2 modes expected

 	ASSERT_TRUE(modeList.Count() > 1); //2 modes expected

 	// The initial extent and the expected translated extent

 	TRect initial(TPoint(10,10), TSize(20,30));

 	TRect extent(initial);

 	TRect expected(TPoint(15,15), TSize(20,30));

 	// Change app mode to 5 pixels offset

 	iScreenDevice->SetAppScreenMode(modeList[1]);

 	iScreenDevice->SetScreenMode(modeList[1]);

 	iSession.Flush();

 	Pause(100);

 	TPoint origin = iScreenDevice->GetCurrentScreenModeScaledOrigin();

 	if(origin != TPoint(0,0))

 		{

 		// Calculate the new extent

 	    MTestScreenCapture* csc = static_cast<MTestScreenCapture*> (iScreenDevice->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf));

 	    ASSERT_NOT_NULL(csc);

 		csc->TranslateExtent(initial, extent);	

 		ASSERT_TRUE(extent == expected); 

 		}

 	else

 		{

 		INFO_PRINTF1(_L("Non zero offset not supported"));

 		}

     // Change app mode

     iScreenDevice->SetAppScreenMode(modeList[0]);

     iScreenDevice->SetScreenMode(modeList[0]);

     iSession.Flush();

     Pause(100);

     modeList.Close();

 	CleanupStack::PopAndDestroy(&testWindow);

 	iSession.Flush();

 	Pause(1000);

 	}

 /**

  @SYMTestCaseID			GRAPHICS_WSERV_CSC_104L

  @SYMTestCaseDesc		Compare the screen composition using bitmaps with different display modes

  @SYMPREQ				CSC

  @SYMTestStatus			Implemented

  @SYMTestPriority		1

  @SYMTestPurpose		To check that bitmaps with different display modes  

  @SYMTestActions		Initialization.

  						Draw a pattern on the screen

  						Retrieve to a bitmap the UI content using the legacy API

  						Blank the screen.

  						Display the retrieved content to a surface

  						Retrieve the composited content to a 2nd bitmap

  						Compare the UI content with the composited content

  @SYMTestExpectedResults  The bitmaps format should not match and should return KErrArgument 

 */

 void CWSGceCsc::GRAPHICS_WSERV_CSC_104L()

 	{

 	TRect screen(iScreenDevice->SizeInPixels());

 	RWindow testWindow(iSession);

 	RWindow surfacedTestWindow(iSession);

 	TSurfaceId surfaceID;

     MTestScreenCapture* csc = static_cast<MTestScreenCapture*> (iScreenDevice->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf));

     ASSERT_NOT_NULL(csc);

 	TSize compositionScreenSize;

 	User::LeaveIfError(csc->GetCompositedSize(compositionScreenSize));

 	iTestName.Format(_L("GRAPHICS_WSERV_CSC_102"));

 	INFO_PRINTF2(_L("%S"),&iTestName);

 	iDisplayMode = iScreenDevice->DisplayMode();

 	TRAPD(err, surfaceID = iUtility->CreateSurfaceL(compositionScreenSize, 

 			                                        KSurfaceFormat, 

 			                                        compositionScreenSize.iWidth * KBytesPerPixel));

 	ASSERT_EQUALS(err,KErrNone);

 	ConstructOpaqueWindowLC(testWindow, 

 			                iWhite, 

 		                    0, 

                             TPoint(0, 0),

                             compositionScreenSize);

 	iSession.Flush();

 	Pause(100);

 	CFbsBitmap *bmp1 = new (ELeave) CFbsBitmap;

 	CleanupStack::PushL(bmp1);

 	User::LeaveIfError(bmp1->Create(compositionScreenSize, EColor16MU));

 	// Invalid bitmap display mode

 	CFbsBitmap *bmp2 = new (ELeave) CFbsBitmap;

 	CleanupStack::PushL(bmp2);

 	User::LeaveIfError(bmp2->Create(compositionScreenSize, EColor256));

 	iSession.Flush();

 	Pause(500);

 	// Draw a pattern using WServ

 	SetBackgroundColorWindow(testWindow, iWhite);

 	TSize rectSize(100, 100);

 	testWindow.Invalidate();

 	testWindow.BeginRedraw();

 	iGc->Activate(testWindow);

 	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

 	iGc->SetBrushColor(KRgbDarkRed);

 	iGc->DrawRect(TRect(TPoint(35, 5), rectSize));

 	iGc->SetBrushColor(KRgbBlack);

 	iGc->DrawRect(TRect(TPoint(55, 15), rectSize));

 	iGc->SetBrushColor(KRgbDarkBlue);

 	iGc->DrawRect(TRect(TPoint(75, 35), rectSize));

 	iGc->SetBrushColor(KRgbYellow);

 	iGc->DrawRect(TRect(TPoint(95, 55), rectSize));

 	iGc->Deactivate();

 	testWindow.EndRedraw();

 	iSession.Flush();

 	Pause(500);

 	iScreenDevice->CopyScreenToBitmap(bmp1);

 	iSession.Flush();

     Pause(100);

 	ConstructOpaqueSurfacedWindowLC(surfacedTestWindow, 

 			                        iRed,

 		                            0,

 		                            TPoint(0, 0),

 		                            compositionScreenSize,

 		                            surfaceID);

 	TRAP(err,iUtility->FillSurfaceL(surfaceID, iCyan));

 	ASSERT_EQUALS(err,KErrNone);

 	iSession.Flush();

     Pause(500);

 	TRAP(err, iUtility->CopyBitmapToSurfaceL(surfaceID, *bmp1));

 	ASSERT_EQUALS(err,KErrNone);

 	iSession.Flush();

     Pause(500);

     // negative test, it should fail wit KErrArgument

 	TInt ret = csc->ComposeScreen(*bmp2);

 	ASSERT_EQUALS(ret, KErrArgument);

 	iUtility->DestroyAll();

 	CleanupStack::PopAndDestroy(&surfacedTestWindow);

 	CleanupStack::PopAndDestroy(bmp2);

 	CleanupStack::PopAndDestroy(bmp1);

 	CleanupStack::PopAndDestroy(&testWindow);

 	iSession.Flush();

 	Pause(1000);

 	}

 /**

  @SYMTestCaseID         GRAPHICS_WSERV_CSC_105L

  @SYMTestCaseDesc       Correct bitmap size returned when in small screen mode

  @SYMDEF                DEF139191                   

  @SYMPREQ               CSC

  @SYMTestStatus         Implemented

  @SYMTestPriority       1

  @SYMTestPurpose        Checking GetCompositedSize is correct on gce & acceptable behaviour in non gce mode

  @SYMTestActions        For every available screen mode

                         Get size from GetCompositedSize

                         Draw some coloured rectangles on screen

                         If gce, do a full screen surface, and paste the coloured rectangles into the surface

                         ComposeScreen - bitmap 1 should be the same as bitmap 2

                         Note - non GCE mode - GetCompositedSize returns unrotated appmode size, so only

                             compares the intersection of that with actual screen size

                         Note - gce mode - GetCompositedSize returns actual rotated screen size, so 

                             does a complete screen comparison

  @SYMTestExpectedResults  All asserts should complete. Comparison should succeed!

 */

 void CWSGceCsc::GRAPHICS_WSERV_CSC_105L()

     {

     iTestName.Format(_L("GRAPHICS_WSERV_CSC_105"));

     INFO_PRINTF2(_L("%S"),&iTestName);

     TInt err;

     //get list of modes

     RArray<TInt> screenModes;

     err = iScreenDevice->GetScreenSizeModeList(&screenModes);

     ASSERT_TRUE (err > 0);

     //get first mode info

     TPixelsAndRotation firstModeInfo;

     iScreenDevice->GetScreenModeSizeAndRotation(screenModes[0],firstModeInfo);

     //make sure csc is available

     MTestScreenCapture* csc = static_cast<MTestScreenCapture*> (iScreenDevice->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf));

     ASSERT_NOT_NULL(csc);

     TBool differentSizes = EFalse;

     TSizeMode currentModeInfo;

     TSize compositionScreenSize;

     //for every screen mode

     for (TInt ii = 0; ii < screenModes.Count(); ++ii && !differentSizes)

         {

         //set mode

         iScreenDevice->SetAppScreenMode(screenModes[ii]);

         iScreenDevice->SetScreenMode(screenModes[ii]);

         iSession.Flush();

         Pause(100);

         //get mode info

         currentModeInfo = iScreenDevice->GetCurrentScreenModeAttributes();

         if (currentModeInfo.iScreenSize.iWidth != firstModeInfo.iPixelSize.iWidth ||

                 currentModeInfo.iScreenSize.iHeight != firstModeInfo.iPixelSize.iHeight ||

                 currentModeInfo.iRotation != firstModeInfo.iRotation)

             {   //note that we have modes of different sizes / rotations

             differentSizes = ETrue;

             }

         RWindow testWindow(iSession);

         RWindow surfacedTestWindow(iSession);

         TSurfaceId surfaceID;

         err = csc->GetCompositedSize(compositionScreenSize);

         ASSERT_EQUALS (err,KErrNone);

         iDisplayMode = iScreenDevice->DisplayMode();

         if (GCEIsSupported())

             {   //create a surface

             TRAP(err, surfaceID = iUtility->CreateSurfaceL(compositionScreenSize, 

                                                        KSurfaceFormat, 

                                                        compositionScreenSize.iWidth * KBytesPerPixel));

             ASSERT_EQUALS(err,KErrNone);

             }

         //create a basic window

         ConstructOpaqueWindowLC(testWindow, 

                 iWhite, 

                 0, 

                 -currentModeInfo.iOrigin,

                 compositionScreenSize);  //negative origin to ensure it fills screen, not app mode area

         iSession.Flush();

         Pause(100);

         //bitmap 1 to compare against

         CFbsBitmap *bmp1 = new (ELeave) CFbsBitmap;

         CleanupStack::PushL(bmp1);

         User::LeaveIfError(bmp1->Create(compositionScreenSize, EColor16MU));

         //bitmap 2 to pass into csc

         CFbsBitmap *bmp2 = new (ELeave) CFbsBitmap;

         CleanupStack::PushL(bmp2);

         User::LeaveIfError(bmp2->Create(compositionScreenSize, EColor16MU));

         //draw coloured rectangles in the test window

         SetBackgroundColorWindow(testWindow, iWhite);

         DrawBasicPattern (testWindow);

         //copy screen to bitmap 1

         err = iScreenDevice->CopyScreenToBitmap(bmp1);

         ASSERT_EQUALS (err,KErrNone);

         iSession.Flush();

         Pause(100);

         if (GCEIsSupported())

             {   //place a window with a surface into the screen

             ConstructOpaqueSurfacedWindowLC(surfacedTestWindow, 

                     iRed,

                     0,

                     -currentModeInfo.iOrigin,

                     compositionScreenSize,

                     surfaceID);  //negative origin to ensure it fills screen,not app mode area

             //make surface boring cyan

             TRAP(err,iUtility->FillSurfaceL(surfaceID, iCyan));

             ASSERT_EQUALS(err,KErrNone);

             iSession.Flush();

             Pause(300);

             //paste bitmap 1 contents into the surface

             TRAP(err, iUtility->CopyBitmapToSurfaceL(surfaceID, *bmp1));

             ASSERT_EQUALS(err,KErrNone);

             iSession.Flush();

             Pause(300);

             }

         //use csc to get a copy of the screen

         err = csc->ComposeScreen(*bmp2);

         ASSERT_EQUALS (err, KErrNone);

         //should match the original bitmap copy of the screen

         ASSERT_TRUE(Compare(*bmp1, *bmp2));    

         if (GCEIsSupported())

             {

             iUtility->DestroyAll();

             CleanupStack::PopAndDestroy(&surfacedTestWindow);

             }

         else

             {

             surfacedTestWindow.Close();

             }

         CleanupStack::PopAndDestroy(bmp2);

         CleanupStack::PopAndDestroy(bmp1);

         CleanupStack::PopAndDestroy(&testWindow);

         iSession.Flush();

         Pause(300);

         }

     if (!differentSizes)

         {

         INFO_PRINTF1(_L("Didn't find screen modes of different sizes - test inconclusive"));

         }

     iScreenDevice->SetAppScreenMode(screenModes[0]);

     iScreenDevice->SetScreenMode(screenModes[0]);

     screenModes.Close();

     }