// 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 - Internal Symbian test code

*/

#include "tdrawresource.h"

#include <graphics/sgimage.h>

#include <graphics/sgutils.h>

#include <graphics/directgdidrawablesource.h>

#include <graphics/sgresourceinternal.h>

#include <graphics/wsdrawresource.h>

__WS_CONSTRUCT_STEP__(DrawResource);

#if defined(__X86GCC__)

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

	{

	return KErrNone;

	}

#endif

//

// class CTestWsGraphicsContext

//

CTestWsGraphicsContext* CTestWsGraphicsContext::NewL(RDirectGdiImageTarget& aTarget)

	{

	CTestWsGraphicsContext* self = new(ELeave) CTestWsGraphicsContext;

	CleanupStack::PushL(self);

	self->ConstructL(aTarget);

	CleanupStack::Pop(self);

	return self;

	}

void CTestWsGraphicsContext::ConstructL(RDirectGdiImageTarget& aTarget)

	{

	CDirectGdiDriver* driver = CDirectGdiDriver::Static();

	User::LeaveIfNull(driver);

	iContext = CDirectGdiContext::NewL(*driver);

	TInt err = iContext->Activate(aTarget);

	User::LeaveIfError(err);

	}

CTestWsGraphicsContext::~CTestWsGraphicsContext()

	{

	delete iContext;

	}

TAny* CTestWsGraphicsContext::ResolveObjectInterface(TUint aTypeId)

	{

	switch(aTypeId)

		{

	case MWsDrawableSourceProvider::EWsObjectInterfaceId:

		return static_cast<MWsDrawableSourceProvider*>(this);

		}

	return NULL;

	}

TInt CTestWsGraphicsContext::CreateDrawableSource(const TSgDrawableId& aDrawableId, TAny*& aSource)

	{

	TRAPD(err, DoCreateDrawableSourceL(aDrawableId, aSource));

	return err;

	}

void CTestWsGraphicsContext::DoCreateDrawableSourceL(const TSgDrawableId& aDrawableId, TAny*& aSource)

	{

	CDirectGdiDriver* driver = CDirectGdiDriver::Static();

	if (!driver)

		{

		User::Leave(KErrNotReady);

		}

	RDirectGdiDrawableSource* drawableSource = new(ELeave) RDirectGdiDrawableSource(*driver);

	CleanupStack::PushL(drawableSource);

	RSgDrawable drawable;

	User::LeaveIfError(drawable.Open(aDrawableId, ESgDoNotRestrictUsage));

	CleanupClosePushL(drawable);

	User::LeaveIfError(drawableSource->Create(drawable));

	CleanupStack::PopAndDestroy();

	CleanupStack::Pop(drawableSource);

	aSource = drawableSource;

	}

void CTestWsGraphicsContext::CloseDrawableSource(TAny* aSource)

	{

	RDirectGdiDrawableSource* drawableSource = static_cast<RDirectGdiDrawableSource*>(aSource);

	drawableSource->Close();

	delete drawableSource;

	}

void CTestWsGraphicsContext::DrawResource(const TAny* aSource, const TPoint& aPos, CWindowGc::TGraphicsRotation aRotation)

	{

	const RDirectGdiDrawableSource* drawableSource = static_cast<const RDirectGdiDrawableSource*>(aSource);

	iContext->DrawResource(aPos, *drawableSource, (DirectGdi::TGraphicsRotation)aRotation);

	iPos = aPos;

	iRotation = (DirectGdi::TGraphicsRotation)aRotation;

	}

void CTestWsGraphicsContext::DrawResource(const TAny* aSource, const TRect& aRect, CWindowGc::TGraphicsRotation aRotation)

	{

	const RDirectGdiDrawableSource* drawableSource = static_cast<const RDirectGdiDrawableSource*>(aSource);

	iContext->DrawResource(aRect, *drawableSource, (DirectGdi::TGraphicsRotation)aRotation);

	iDestRect = aRect;

	iRotation = (DirectGdi::TGraphicsRotation)aRotation;

	}

void CTestWsGraphicsContext::DrawResource(const TAny* aSource, const TRect& aRectDest, const TRect& aRectSrc, CWindowGc::TGraphicsRotation aRotation)

	{

	const RDirectGdiDrawableSource* drawableSource = static_cast<const RDirectGdiDrawableSource*>(aSource);

	iContext->DrawResource(aRectDest, *drawableSource, aRectSrc, (DirectGdi::TGraphicsRotation)aRotation);

	iDestRect = aRectDest;

	iSrcRect = aRectSrc;

	iRotation = (DirectGdi::TGraphicsRotation)aRotation;

	}

void CTestWsGraphicsContext::DrawResource(const TAny* aSource, const TRect& aRect, const TDesC8& aParam)

	{

	const RDirectGdiDrawableSource* drawableSource = static_cast<const RDirectGdiDrawableSource*>(aSource);

	iContext->DrawResource(aRect, *drawableSource, aParam);

	iDestRect = aRect;

	}

void CTestWsGraphicsContext::Clear()

	{

	iContext->Clear();

	}

//

// class CTDrawResource

//

CTDrawResource::CTDrawResource(CTestStep* aStep)

	: CTWsGraphicsBase(aStep)

	{

	}

CTDrawResource::~CTDrawResource()

	{

	iWindow.Close();

	delete iRefBitmap;

	delete iRotatedRefBitmap;

	delete iScaledBitmap;

	delete iScaledCroppedBitmap;

	delete iCopyBitmap;

	delete iBitmapWrongScreenNumber;

	delete iWsGrapicResolver;

	delete iGraphicsCon;

	iWsDrawableSource.Close();

	iImage.Close();

	iImageTarget.Close();

	iImageCollection.Close();

	CDirectGdiDriver* dGdiDriver = CDirectGdiDriver::Static();

	if(dGdiDriver)

		{

		dGdiDriver->Close();

		}

	SgDriver::Close();

	}

void CTDrawResource::ConstructL()

	{

	//Constrcut and setup window to be drawn to

	iWindow = RWindow(TheClient->iWs);

    User::LeaveIfError(iWindow.Construct(*TheClient->iGroup->GroupWin(),ENullWsHandle));

    TSize iWinSize=TSize(TheClient->iScreen->SizeInPixels());

    iWindow.SetExtent(TPoint(0,0),iWinSize);

	iWindow.Activate();

	iWindow.BeginRedraw();

	iWindow.EndRedraw();

	//Creates all reference and copy bitmaps required for all tests

	CreateReferenceAndCopyBitmapsL();

	TInt err = CDirectGdiDriver::Open();

	User::LeaveIfError(err);

	err = SgDriver::Open();

	User::LeaveIfError(err);

	//create image target

	CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static();

	if(!theDGdiDriver)

		{

		User::Leave(KErrNotReady);

		}

	TSgImageInfo info;

	info.iUsage = ESgUsageDirectGdiTarget | ESgUsageDirectGdiSource | ESgUsageCompositionSource;

	info.iPixelFormat = EUidPixelFormatRGB_565;

	info.iSizeInPixels = TSize(200, 200);

	info.iShareable = ETrue;

	const TInt KImageCount = 1;

	err = iImageCollection.Create(info, KImageCount);

	User::LeaveIfError(err);

	err = iImageCollection.OpenImage(0, iImage);

	User::LeaveIfError(err);

	iImageTarget = RDirectGdiImageTarget(*theDGdiDriver);

	err = iImageTarget.Create(iImage);

	User::LeaveIfError(err);

	// construction of image source

	RSgImage sgImage;

	CreateSgImageFromBitmapL(sgImage);

	CleanupClosePushL(sgImage);

	iWsDrawableSource = RWsDrawableSource(TheClient->iWs);

	User::LeaveIfError(iWsDrawableSource.Create(sgImage, TheClient->iScreen->GetScreenNumber()));

    //Create dummy MWsGraphicResolver - required RemoteGc testing

	iWsGrapicResolver = new (ELeave) CWSGraphicsRes();

	//Create dummy MWsGraphicsContext - required RemoteGc testing

	iGraphicsCon =  CTestWsGraphicsContext::NewL(iImageTarget);

	CleanupStack::PopAndDestroy(&sgImage);

	}

void CTDrawResource::RunTestCaseL(TInt aCurTestCase)

	{	

	((CTDrawResourceStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(aCurTestCase)

		{

	case 1:		

		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0001"));

		INFO_PRINTF1(_L("DrawResourcePos Test"));		

		TestDrawResourcePos();

		break;

	case 2:

		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0002"));

		INFO_PRINTF1(_L("DrawResourceRect Test"));	

		TestDrawResourceRect();

		break;

	case 3:

		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0003"));

		INFO_PRINTF1(_L("DrawResourceScale Test"));		

		TestDrawResourceScale();

		break;

	case 4:

		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0004"));

		INFO_PRINTF1(_L("RWsDrawableSource Reference Counting Test"));		

		TestRWsDrawableSourceReferenceCountingL();

		break;	

	case 5:

		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0005"));

		INFO_PRINTF1(_L("RemoteGcDrawResourcePos Test"));	

		TestRemoteGcDrawResourcePosL();

		break;

	case 6:

		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0006"));

		INFO_PRINTF1(_L("RemoteGcDrawResourceRect Test"));	

		TestRemoteGcDrawResourceRectL();

		break;

	case 7:

		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0007"));

		INFO_PRINTF1(_L("RemoteGcDrawResourceScale Test"));	

		TestRemoteGcDrawResourceScaleL();

		break;

	case 8:

		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0008"));

		INFO_PRINTF1(_L("DrawResourceScreens Test"));	

		TestDrawResourceScreensL();

		break;

	case 9:

		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-TestCopyScreenToBitmapWithDifferentDisplayModes-0001"));

		INFO_PRINTF1(_L("CopyScreenToBitmapWithDifferentDisplayModes Test\n"));

		TestCopyScreenToBitmapWithDifferentDisplayModesL();

		break;

	case 10:

		((CTDrawResourceStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		((CTDrawResourceStep*)iStep)->CloseTMSGraphicsStep();

		INFO_PRINTF1(_L("Test complete\n"));

		TestComplete();

		break;

		}

	((CTDrawResourceStep*)iStep)->RecordTestResultL();

	}

/**

@SYMTestCaseID           GRAPHICS-WSERV-DRAWRESOURCE-0001

@SYMPREQ                 PREQ2095

@SYMTestPriority         High

@SYMTestCaseDesc         Draw RSgImage using DrawResource(const TPoint&, const RWsDrawableSource&, TGraphicsRotation)

@SYMTestActions          Draw to position (0,0) with default rotation (none)

						 Draw to position (10,10) with 90 degrees rotation 

@SYMTestExpectedResults  Drawn images should match reference CFbsBitmap

*/

void CTDrawResource::TestDrawResourcePos()

	{

	// Draw to TPoint(0,0) with EGraphicsRotationNone

	iWindow.BeginRedraw();

	TheGc->Activate(iWindow);

	TheGc->Clear();

	MWsDrawResource* dr = static_cast<MWsDrawResource*>(TheGc->Interface(KMWsDrawResourceInterfaceUid));

	TEST(dr != NULL);

	dr->DrawResource(KDestPoint, iWsDrawableSource, CWindowGc::EGraphicsRotationNone);

	TheGc->Deactivate();

	iWindow.EndRedraw();

	TheClient->iWs.Finish();  

	TheClient->WaitForRedrawsToFinish();

	//Copy the screen to the copy bitmap

	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);

	//Compare the bitmaps

	INFO_PRINTF1(_L("Draw to TPoint(0,0) with EGraphicsRotationNone"));

	TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iRefBitmap);

	TEST(compRes);

	/*** Draw to position (10,10) with 90 degrees rotation ***/

	TPoint const KDestPoint2(10,10);

	iWindow.BeginRedraw();

	TheGc->Activate(iWindow);

    TheGc->Clear();

	dr->DrawResource(KDestPoint2, iWsDrawableSource, KTestRotation);

    TheGc->Deactivate();

	iWindow.EndRedraw();

	TheClient->iWs.Finish(); 

	TheClient->WaitForRedrawsToFinish();

	//Copy the screen to the copy bitmap

	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, TRect(KDestPoint2, KSourceSize));

	//Compare the bitmaps

	INFO_PRINTF1(_L("Draw to position (10,10) with 90 degrees rotation"));

	compRes = CompareBitmapsByPixel(iCopyBitmap, iRotatedRefBitmap);

	TEST(compRes);

	}

/**

@SYMTestCaseID           GRAPHICS-WSERV-DRAWRESOURCE-0002

@SYMPREQ                 PREQ2095

@SYMTestPriority         High

@SYMTestCaseDesc         Draw RSgImage using DrawResource(const TRect& , const RWsDrawableSource&, TGraphicsRotation aRotation)

@SYMTestActions          Draw to rect pos (10,10), rect size (60,60) with 90 degrees rotation

@SYMTestExpectedResults  Drawn images should match the reference CFbsBitmap

*/

void CTDrawResource::TestDrawResourceRect()

	{

	//Use DrawResource

	iWindow.BeginRedraw();

	TheGc->Activate(iWindow);

	TheGc->Clear();

	MWsDrawResource* dr = static_cast<MWsDrawResource*>(TheGc->Interface(KMWsDrawResourceInterfaceUid));

	TEST(dr != NULL);

	dr->DrawResource(KDestRect, iWsDrawableSource, KTestRotation);

	TheGc->Deactivate();

	iWindow.EndRedraw();

	TheClient->iWs.Finish();  

	TheClient->WaitForRedrawsToFinish();

	//Copy the screen to the copy bitmap

	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);

	//Compare the bitmaps

	INFO_PRINTF1(_L("Draw to rect pos (10,10), rect size (60,60) with 90 degrees rotation"));

	TInt compRes = CompareBitmapsByPixel(iCopyBitmap, iScaledBitmap);

	TEST(compRes);

	}

/**

@SYMTestCaseID           GRAPHICS-WSERV-DRAWRESOURCE-0003

@SYMPREQ                 PREQ2095

@SYMTestPriority         High

@SYMTestCaseDesc         Draw RSgImage using DrawResource(const TRect& , const RWsDrawableSource&, const TRect&, TGraphicsRotation aRotation)

@SYMTestActions          Draw the part of the source image (rect Pos (0,0), rect size(50,50))

						 to rect pos(10,10), rect size(60,60) and and 90 degrees rotation

@SYMTestExpectedResults  Drawn images should match the reference CFbsBitmap

*/

void CTDrawResource::TestDrawResourceScale()

	{

	//Use DrawResource

	iWindow.BeginRedraw();

	TheGc->Activate(iWindow);

	TheGc->Clear();

	MWsDrawResource* dr = static_cast<MWsDrawResource*>(TheGc->Interface(KMWsDrawResourceInterfaceUid));

	TEST(dr != NULL);

	dr->DrawResource(KDestRect, iWsDrawableSource, KSourceRect, KTestRotation);

	TheGc->Deactivate();

	iWindow.EndRedraw();

	TheClient->iWs.Finish();  

	TheClient->WaitForRedrawsToFinish();

	//Copy the screen to the copy bitmap

	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);

	//Compare the bitmaps

	INFO_PRINTF1(_L("Draw the part of the source image to rect pos(10,10), rect size(60,60) and and 90 degrees rotation"));

	TInt compRes = CompareBitmapsByPixel(iCopyBitmap, iScaledCroppedBitmap);

	TEST(compRes);

	}

/**

@SYMTestCaseID           GRAPHICS-WSERV-DRAWRESOURCE-0004

@SYMPREQ                 PREQ2095

@SYMTestPriority         High

@SYMTestCaseDesc         Draw RSgImage using DrawResource(const TPoint&, const RWsDrawableSource&, TGraphicsRotation) after closing the image source

@SYMTestActions          Draw to position (0,0) with default rotation (none) after closing the image source

@SYMTestExpectedResults  Drawn image should match reference CFbsBitmap

*/

void CTDrawResource::TestRWsDrawableSourceReferenceCountingL()

	{	

	// construction of image source

	RSgImage sgImage;

	CreateSgImageFromBitmapL(sgImage);

	CleanupClosePushL(sgImage);

	RWsDrawableSource drawableSource(TheClient->iWs);

	CleanupClosePushL(drawableSource);

	User::LeaveIfError(drawableSource.Create(sgImage, TheClient->iScreen->GetScreenNumber())); 

	//Draw using DrawResource

	iWindow.BeginRedraw();

	TheGc->Activate(iWindow);

	TheGc->Clear();

	MWsDrawResource* dr = static_cast<MWsDrawResource*>(TheGc->Interface(KMWsDrawResourceInterfaceUid));

	TEST(dr != NULL);

	dr->DrawResource(KDestPoint, drawableSource, CWindowGc::EGraphicsRotationNone);

	TheGc->Deactivate();

	iWindow.EndRedraw();

	//Close the image source but this should not stop the source from being drawn 

	drawableSource.Close();

	TheClient->iWs.Finish();

	TheClient->WaitForRedrawsToFinish();

	//Copy the screen to the copy bitmap

	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);

	//Compare the bitmaps

	INFO_PRINTF1(_L("Draw to TPoint(0,0) with EGraphicsRotationNone"));

	TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iRefBitmap);

	TEST(compRes);

	CleanupStack::PopAndDestroy(2, &sgImage);

	}

/**

@SYMTestCaseID           GRAPHICS-WSERV-DRAWRESOURCE-0005

@SYMPREQ                 PREQ2095

@SYMTestPriority         High

@SYMTestCaseDesc         Draw RSgImage using RemotGc->DrawResource(const TPoint&, const RWsDrawableSource&, TGraphicsRotation)

@SYMTestActions          Record the draw resource commands using CRemoteGc and play the recorded commands on a window using

 						 Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&) and then play the recorded commands using . 

						 Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&).

@SYMTestExpectedResults  Drawn images should match reference CFbsBitmap and also values received by MWsGraphicsContext should 

 						 match what was originally sent to DrawResource.

*/

void CTDrawResource::TestRemoteGcDrawResourcePosL()

	{

	const TRect KRemotGcSourceRect(0, 0, iWindow.Size().iWidth, iWindow.Size().iHeight);

	const TRegionFix<1> KClippingRegion(KRemotGcSourceRect);

	CWindowGc::TGraphicsRotation testRotation= CWindowGc::EGraphicsRotationNone;

	//Create remote gc - required RemoteGc testing

	CRemoteGc* remoteGc = CRemoteGc::NewL(TheClient->iScreen);

	CleanupStack::PushL(remoteGc);

	//Record draw messages

	remoteGc->ResetCommandBuffer();

	remoteGc->BeginDraw(KRemotGcSourceRect);

	MWsDrawResource* dr = static_cast<MWsDrawResource*>(remoteGc->Interface(KMWsDrawResourceInterfaceUid));

	TEST(dr != NULL);

	dr->DrawResource(KDestPoint, iWsDrawableSource, CWindowGc::EGraphicsRotationNone);

	remoteGc->EndDraw();

	RWsGraphicMsgBuf msgBuf;

	CleanupClosePushL(msgBuf);

	//Externalize the captured commands from remote gc in to a buffer

	remoteGc->ExternalizeL(msgBuf, ETrue);

	//Create command buffer - required RemoteGc testing

	CCommandBuffer* cmdBuffer = CCommandBuffer::NewL();

	CleanupStack::PushL(cmdBuffer);

	//Internalize the buffer with captured commands (from CRemoteGC) in to CCommandBuffer

	cmdBuffer->InternalizeL(msgBuf.Pckg());

	// Play stored commands using Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&) 

	remoteGc->ResetCommandBuffer();

	iWindow.Invalidate();

	iWindow.BeginRedraw();

	TheGc->Activate(iWindow);

	TheGc->Clear();

	cmdBuffer->Play(KPlayOffset, &KClippingRegion, KRemotGcSourceRect, TheClient->iWs, *TheGc);

	TheGc->Deactivate();

	iWindow.EndRedraw();

	TheClient->iWs.Finish();

	TheClient->WaitForRedrawsToFinish();

	//Copy the screen to the copy bitmap

	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);

	//Compare the bitmaps

	INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&)"));

	TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iRefBitmap);

	TEST(compRes);

	// Play stored commands using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&) 

	remoteGc->ResetCommandBuffer();

	iWindow.Invalidate();

	iWindow.BeginRedraw();

	TheGc->Activate(iWindow);

	TheGc->Clear();

	cmdBuffer->Play(KPlayOffset,&KClippingRegion,KRemotGcSourceRect,*iWsGrapicResolver,*iGraphicsCon);

	TheGc->Deactivate();

	iWindow.EndRedraw();

	TheClient->iWs.Finish();

	//Compare the values received by CTestWsGraphicsContext and the values sent to it

	INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&)"));

	TBool valuesSame = EFalse;

	CFbsBitmap* bmp;

	BitmapLC(bmp);