// 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();

    }