// Copyright (c) 1995-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 <w32stdgraphic.h>

#include <imageconversion.h>

#include "testbase.h"

#include "testbase.h"

// Bitmap to load for tests

#define MY_TEST_BITMAP _L("Z:\\WSTEST\\MYTEST.MBM")

// Animation to load for tests

_LIT(KSymBallFile, "Z:\\WSTEST\\symball.gif");

// Executables for different sharing of graphic tests

_LIT(KTestExe1, "TWSGRAPHICSHARETEST.exe");

_LIT(KTestExe2, "TWSGRAPHICSHAREGLOBALTEST.exe");

_LIT(KTestExe3, "TWSGRAPHICUNSHAREGLOBALTEST.exe");

_LIT(KTestExe4, "TWSGRAPHICSHARESECURETEST.exe");

_LIT(KTestExe5, "TWSGRAPHICUNSHARESECURETEST.exe");

// Graphic is shared or not in executeable

_LIT(KShare, " true");

_LIT(KNoShare, " false");

TUid KUidTestAnimation = {0x87654321};

const TInt KDummyGraphicId = 99;

const TInt KMaxLogLength = 256;

const TInt KAnimationRunTime = 5000000; // 5 seconds max time to run a single animation loop

// Animation loader

class CIclLoader: public CActive

	{

public:

	CIclLoader();

	~CIclLoader();

	void ConstructL(const TDesC& aFileName, TBool aUseUID, TBool aReplace);

	const TWsGraphicId GetId();	

	inline TInt FrameCount() const {return iTotalFrames;};

	inline TBool Ok() const {return !iFailed;};

protected:

	void RunL();

	TInt RunError(TInt aError);

	void DoCancel();

private:

	void TestL(TInt aCondition);

	CImageDecoder* iDecoder;

	CWsGraphicBitmapAnimation* iTestAnimation;

	TLogMessageText iTestLog;

	TBool iUseUID;

	TBool iReplace;

	RPointerArray<CWsGraphicBitmapAnimation::CFrame> iFrames;

	TInt iTotalFrames;

	void NextL();

	RFs iFs;

	TBool iFailed;

	};

CIclLoader::CIclLoader():

	CActive(CActive::EPriorityLow)

	{

	CActiveScheduler::Add(this);

	}

CIclLoader::~CIclLoader()

	{

	if (iTestAnimation)

		{

		delete iTestAnimation;

		iTestAnimation = NULL;

		}

	if (iDecoder)

		{

		delete iDecoder;

		iDecoder = NULL;

		}

	iFrames.ResetAndDestroy();

	iFs.Close();

	}

const TWsGraphicId CIclLoader::GetId()

	{

	if (iTestAnimation)

		{

		return iTestAnimation->Id();

		}

	else

		{

		TWsGraphicId id(KDummyGraphicId);

		return id;

		}

	}

void CIclLoader::TestL(TInt aCondition)

	{

	if(!aCondition)

		{

		RWsSession rWs;

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

		TBuf<KMaxLogLength> buf;

		_LIT(Fail,"AUTO Failed in WsGraphics Test : CIclLoader");

		buf.Append(Fail);

		buf.Append(iTestLog);

		rWs.LogMessage(buf);

		rWs.Flush();

		rWs.Close();

		User::Leave(KErrGeneral);

		}

	}

void CIclLoader::ConstructL(const TDesC& aFileName, TBool aUseUID,TBool aReplace)

	{

	iUseUID = aUseUID;

	iReplace = aReplace;

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

	iDecoder = CImageDecoder::FileNewL(iFs,aFileName);

	if(!iDecoder->IsImageHeaderProcessingComplete()) 

		{

		User::Leave(KErrGeneral);

		}

	NextL();

	}

void CIclLoader::NextL()

	{

	// Load a frame from the animation

	if (iDecoder && (iDecoder->FrameCount() > iFrames.Count()))

		{

		const TFrameInfo& info = iDecoder->FrameInfo(iFrames.Count());

		CWsGraphicBitmapAnimation::CFrame* frame = CWsGraphicBitmapAnimation::CFrame::NewL();

		CleanupStack::PushL(frame);

		iFrames.AppendL(frame);

		CleanupStack::Pop(frame);

		frame->SetFrameInfo(info);

		TFrameInfo copiedInfo = frame->FrameInfo();

		TestL(info.iFlags==copiedInfo.iFlags);

		TSize bmpSize(info.iFrameCoordsInPixels.Size());

		CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

		frame->SetBitmap(bitmap); //takes ownership

		User::LeaveIfError(bitmap->Create(bmpSize,info.iFrameDisplayMode));

		TDisplayMode maskDispMode;

		CFbsBitmap* mask = new(ELeave) CFbsBitmap;

		frame->SetMask(mask); //takes ownership

		if((TFrameInfo::EAlphaChannel|TFrameInfo::ETransparencyPossible) & info.iFlags)

			{

			maskDispMode = EGray256;

			}

		else

			{

			maskDispMode = EGray2;

			}

		User::LeaveIfError(mask->Create(info.iFrameCoordsInPixels.Size(),maskDispMode));

		iDecoder->Convert(&iStatus,*bitmap,*mask,iFrames.Count()-1);

		SetActive();

		}

	// if a frame loaded

	else if(iFrames.Count())

		{

		_LIT_SECURE_ID(KTestSecId,0x12345678);

		// The extra code around the NewL is checking that no heap failures occur when 

		// creating the CWsGraphicBitmapAnimation

		TInt failRate = 1;

		const TInt KMaxIteration = 1000;

		for (;failRate < KMaxIteration; failRate++)

		    {

		    __UHEAP_RESET;

		    __UHEAP_SETFAIL(RHeap::EDeterministic,failRate);

		    __UHEAP_MARK;

		    TInt err = KErrGeneral;

			if (iUseUID)

				{// creating animation using UID

				TRAP(err, iTestAnimation = CWsGraphicBitmapAnimation::NewL(KUidTestAnimation,iFrames.Array()););

				}

			else

				{// creating using transient ID allocated by wserv

				TRAP(err, iTestAnimation = CWsGraphicBitmapAnimation::NewL(iFrames.Array()););

				}

			TestL((err==KErrNone || err==KErrNoMemory));

			if (err != KErrNone)

		        {

		        __UHEAP_MARKEND;

		        TestL(iTestAnimation == NULL);

		        }

		    else

		        {

		        break;

		        }

			}

		__UHEAP_RESET;

		TestL(iTestAnimation != NULL); 

		TestL(failRate > 1); //Ensure the udeb version of euser.dll is available (i.e. that the rom was build with the -D_DEBUG option)

		RDebug::Printf("TWSGraphicTest.CPP: Heapfailure loop completed after %d allocs.", failRate-1);

		// if testing that a created animation can be replaced	

		if (iReplace)

			{	

			// replace the animation just created with another

			TWsGraphicId testId = iTestAnimation->Id();

			TInt testInt = testId.Id();  

	   		CWsGraphicBitmapAnimation* testReplacement = CWsGraphicBitmapAnimation::NewL(testId,iFrames.Array());

			delete iTestAnimation;

			iTestAnimation = testReplacement;

			TestL(iTestAnimation->Id().Id()==testInt); 

			}

		delete iDecoder;

		iDecoder = NULL;

		iTotalFrames = iFrames.Count();

		iFrames.ResetAndDestroy();

		// test that the animation methods can be used without error

		TestL(iTestAnimation->ShareGlobally()==KErrNone);

		TestL(iTestAnimation->UnShareGlobally()==KErrNone);

		TestL(iTestAnimation->Share(KTestSecId)==KErrNone);

		TestL(iTestAnimation->UnShare(KTestSecId)==KErrNone);

		TestL(iTestAnimation->UnShare(KTestSecId)==KErrNotFound);	

		}

	}

void CIclLoader::RunL()

	{

	if (iStatus == KErrNone)

		{

		NextL();

		}

	else

		{

		TestL(EFalse); // kill the test

		}

	}

TInt CIclLoader::RunError(TInt aError)

	{

	RDebug::Printf("CIclLoader::RunError, aError %d", aError);

	iFailed = ETrue;

	return KErrNone;

	}

void CIclLoader::DoCancel()

	{

	if(iDecoder)

		{

		iDecoder->Cancel();

		}

	}

// Class for testing CWsGraphics

class CActiveWait;

class CRedrawAO;

class CWsGraphicBase : public CBase

	{

public:

	CWsGraphicBase();

	CWsGraphicBase(TInt aScreenNumber);

	~CWsGraphicBase();

	void ConstructL();

	void DoTestL(TInt aTestNo);

	void RedrawMe(TRect aRedrawRect, TInt aFrame);

	enum TTestCases

		{

		ETestCreateGraphicUID,

		ETestCreateGraphicID,

		ETestUpdateGraphic,

		ETestDeleteGraphic,

		ETestDrawInvalideBitmapID,

		ETestDrawGraphic,

		ETestDrawGraphicID,

		ETestDrawGraphicCompare,

		ETestDrawGraphicSessionHandle,

		ETestDrawAnimatedGraphicUID,

		ETestDrawAnimatedGraphicID,

		ETestCreateMsgGraphicMsgBuf,

		ETestDrawReplaceGraphicID,

		ETestDrawInvalidAnimationID,

		ETestDrawSharedGraphic,

		// additional cases to be added here, before ETestMaxNumberOfTests

		ETestMaxNumberOfTests

		};

private :

	void PrepGc();

	void RetireGc();

	void RunAnimation(TInt aFrameCount);

	void LaunchNewProcessL(const TDesC& aExecutable, TBool aShare);

	inline void TestForIdenticalBitmaps(){Test(iScreen->RectCompare(iPosition1,iPosition2));};

	inline void TestForDifferentBitmaps(){Test(!iScreen->RectCompare(iPosition1,iPosition2));};

	void Test(TInt aCondition);

	void DoTestCreateGraphicUidL();	

	void DoTestCreateGraphicIdL();

	void DoTestUpdateGraphicL();

	void DoTestDrawSharedGraphicL();

	void DoTestDeleteGraphicL();

	void DoTestDrawGraphicL();

	void DoTestDrawGraphicIDL();

	void DoTestDrawGraphicCompareL();

	void DoTestDrawAnimatedGraphicUIDL();

	void DoTestDrawAnimatedGraphicIDL();

	void DoTestDrawGraphicSessionHandleL();

	void DoTestCreateMsgGraphicMsgBufL();

	void DoTestDrawReplaceGraphicIDL();

	void DoTestDrawInvalidBitmapIDL();

	void DoTestDrawInvalidAnimationIDL();

private :

	TInt iScreenNumber;

	CWindowGc *iGc;

	RWsSession iWs;

	RWindowGroup *iGroupWin;

	CWsScreenDevice *iScreen;

	RWindow *iWin;	

	TLogMessageText iTestLog;

	TRect iPosition1;

	TRect iPosition2;

	CActiveWait* iTimer;

	CRedrawAO* iRedrawListener;

	TWsGraphicId iAnimId;

	TWsGraphicAnimation iAnimData;

	};

// 

// class CRedrawAO

// request & listen for redraw events from wserv

// if a redraw event is received, notify the observing class

// 

class CRedrawAO : public CActive

	{

public:

	static CRedrawAO* NewL(RWsSession* aWs);

	~CRedrawAO();

	// from CActive:

	void RunL();

	void DoCancel();	

	TInt RunError(TInt aError);

	void RequestRedraw();

	inline void SetFrameCount(TInt aCount){iFrameCount = aCount;};

	inline TInt GetFrameCount() const {return iFrameCount;};

private:

	CRedrawAO(RWsSession* aWs);

	void ConstructL();

private:

	RWsSession* iWs;

	TInt iFrameCount;

	};

CRedrawAO* CRedrawAO::NewL(RWsSession* aWs)

	{

	CRedrawAO* self = new (ELeave) CRedrawAO(aWs);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self; 

	}

CRedrawAO::CRedrawAO(RWsSession* aWs):

CActive(CActive::EPriorityHigh), iWs(aWs)

	{

	CActiveScheduler::Add(this);

	}

CRedrawAO::~CRedrawAO()

	{

	// cleanup 

	Cancel();

	}

void CRedrawAO::ConstructL()

	{

	// nothing to construct 

	}

void CRedrawAO::RunL()

	{

	// leave if status is not ok. RunError will process this result

	User::LeaveIfError(iStatus.Int());

	TWsRedrawEvent redraw;

	iWs->GetRedraw(redraw);

	TUint redrawHandle = redraw.Handle();

	if (redrawHandle == ENullWsHandle)

		{

		User::Leave(KErrBadHandle); // sanity check the client handle isn't a dummy 

		}

	else if (redrawHandle)

		{

		--iFrameCount;

		(reinterpret_cast<CWsGraphicBase *>(redrawHandle))->RedrawMe(redraw.Rect(), iFrameCount); // handle the redraw signal

		}

	if (iFrameCount > 0) 

		{

		RequestRedraw();

		}

	}

TInt CRedrawAO::RunError(TInt aError)

	{

	if (aError != KErrBadHandle)

		{

		RequestRedraw();

		}

	return KErrNone;

	}

void CRedrawAO::DoCancel()

	{

	// kill all outstanding asynch. wserv requests

	iWs->RedrawReadyCancel();

	iFrameCount = KErrNone;	

	}

void CRedrawAO::RequestRedraw()

	{

	if (!IsActive())

		{

		iWs->RedrawReady(&iStatus);

		SetActive();

		}

	}

//

class CActiveWait : public CActive

	{

public:

	static CActiveWait* NewL();

	~CActiveWait();

	void Wait(TInt aDelay);

	// From CActive:

	void RunL();

	void DoCancel();

	TInt RunError(TInt aError);

protected:

	CActiveWait();

	void ConstructL();

protected:

	RTimer iTimer;

	TTime iFromTime;

	};

CActiveWait* CActiveWait::NewL()

	{

	CActiveWait* self = new (ELeave) CActiveWait;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CActiveWait::ConstructL()

	{

	User::LeaveIfError(iTimer.CreateLocal());

	CActiveScheduler::Add(this);

	}

CActiveWait::CActiveWait() : CActive(CActive::EPriorityStandard)

	{

	iFromTime.HomeTime();

	}

CActiveWait::~CActiveWait()

	{

	Cancel();

	iTimer.Close();

	}

void CActiveWait::DoCancel()

	{

	iTimer.Cancel();

	CActiveScheduler::Stop();

	}

void CActiveWait::RunL()

	{

	CActiveScheduler::Stop();

	}

TInt CActiveWait::RunError(TInt aError)

	{

	return aError; // exists so a break point can be placed on it.

	}

void CActiveWait::Wait(TInt aDelay)

	{

	iTimer.After(iStatus, aDelay);

	SetActive();

	CActiveScheduler::Start();

	}

//

CWsGraphicBase::CWsGraphicBase(TInt aScreenNumber) : iScreenNumber(aScreenNumber), iAnimId(KDummyGraphicId)

	{

	}