// Copyright (c) 2003-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 "TTransptAnim.h"

 struct FrameSet

 	{

 	TRgb* iFrames;

 	const TInt iFrameCount;

 	FrameSet(TRgb* aFrames, const TInt aFrameCount)

 	: iFrames(aFrames),

 	iFrameCount(aFrameCount)

 		{

 		}

 	};

 TRgb FrameSequenceAlpha[]= 

 { TRgb(255, 0, 0, 50), TRgb(0, 255, 0, 70), TRgb(0, 0, 255, 100), TRgb(255, 255, 0, 150), TRgb(0, 255, 255, 200) };

 TRgb FrameSequenceNoAlpha[] =

 { TRgb(255, 0, 0), TRgb(0, 255, 0), TRgb(0, 0, 255), TRgb(255, 255, 0), TRgb(0, 255, 255) };

 FrameSet frameSetAlpha(FrameSequenceAlpha, 	sizeof(FrameSequenceAlpha)/sizeof(TRgb));

 FrameSet frameSetNoAlpha(FrameSequenceNoAlpha, sizeof(FrameSequenceNoAlpha)/sizeof(TRgb));

 FrameSet TestFrameSets[] =

 	{

 	frameSetAlpha, frameSetNoAlpha

 	};

 static const TInt 	FRAME_DELAY 			= 2000000;

 static const TInt 	DRAW_LINE_ANIMATION 	= 36;

 static const TBool 	ALPHATRANSPARENCY_ON 	= ETrue;

 static const TInt	ALPHA_FRAMESET 			= 0;

 //*****************************************************************************

 CTTestCase* CTTransparentAnim::CreateTestCaseL(CTTransparentAnim* aTransAnim, TInt aTestCaseId)

 	{

 	CTTestCase* testCase = aTransAnim->GetCurrent();

 	if (!testCase)

 		{

 		switch (aTestCaseId)

 			{

 		case GraphicsWServ0483 :

 			testCase =  CTGraphicsWServ0483::NewL();

 			break;

 			}

 		}

 	return testCase;

 	}

 //*****************************************************************************

 CTTransparentAnim::CTTransparentAnim(CTestStep* aStep)

 : CTWsGraphicsBase(aStep), iCurrentTestCase(NULL)

 	{}

 CTTransparentAnim::~CTTransparentAnim()

 	{

 	TheClient->iWs.SetAutoFlush(EFalse);

 	}

 void CTTransparentAnim::ConstructL()

 	{

 	TheClient->iWs.SetAutoFlush(ETrue);

 	}

 void CTTransparentAnim::RunTestCaseL(TInt)

 	{

 	((CTTransparentAnimStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0483"));

 	CTTestCase* testCase = CTTransparentAnim::CreateTestCaseL(this, iTest->iState);

 	if (!testCase)

 		{

 		TestComplete();

 		return ;

 		}

 	TInt err = KErrNone;

 	if (!testCase->IsAlreadyRunning())

 		{

 		SetCurrent(testCase);

 		iTest->LogSubTest(testCase->TestCaseName());

 		TRAP(err, testCase->StartL());

 		testCase->SetError(err);

 		}

 	if (testCase->IsComplete() || err != KErrNone)

 		{

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

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

 		if (testCase->HasFailed())

 			{

 			INFO_PRINTF3(_L("ErrorStatus  - Expected: %d, Actual: %d"), ETrue, EFalse);

 			}

 		++iTest->iState;

 		SetCurrent(NULL);

 		delete testCase;

 		}

 	else

 		{

 		// Prevent test harness from repeatedly running the test case too quickly.

 		User::After(TTimeIntervalMicroSeconds32(FRAME_DELAY));

 		}

 	}

 void CTTransparentAnim::SetCurrent(CTTestCase* aTestCase)

 	{

 	iCurrentTestCase = aTestCase;

 	}

 CTTestCase* CTTransparentAnim::GetCurrent()

 	{

 	return iCurrentTestCase;

 	}

 //*****************************************************************************

 CTTAnimation::CTTAnimation(CTWin* aWin, TInt aDrawArg)

 : iWin(aWin), iFrameCount(0), iCurrentFrameSet(0), iIsComplete(EFalse), iDrawArg(aDrawArg)

 	{

 	iAnimDll = RAnimDll(TheClient->iWs);

 	iAnimDll.Load(KAnimDLLName);

 	iDrawAnim = RTestAnim(iAnimDll);

 	iDrawAnim.Construct(*iWin->BaseWin(), EAnimTypeTrans, TPckgBuf<TRect>(aWin->Size()));

 	}

 CTTAnimation::~CTTAnimation()

 	{

 	iDrawAnim.Close();

 	iAnimDll.Close();

 	delete iWin;

 	}

 void CTTAnimation::StartL()

 	{

 	iAnimTimer.ConstructL();

 	iAnimTimer.Start(FRAME_DELAY, TCallBack(CTTAnimation::NextFrame,this));

 	}

 TBool CTTAnimation::IsComplete()

 	{

 	return iIsComplete;

 	}

 void CTTAnimation::SetCurrentFrameSet(TInt aFrameSet)

 	{

 	iCurrentFrameSet = aFrameSet;

 	}

 CTWin* CTTAnimation::GetWindow()

 	{

 	return iWin;

 	}

 void CTTAnimation::Attach(MAnimationObserver* aObserver)

 	{

 	iObserver = aObserver;

 	}

 TInt CTTAnimation::NextFrame(TAny* aAnim)

 	{

 	STATIC_CAST(CTTAnimation*,aAnim)->NextFrame();

 	return KErrNone;

 	}

 void CTTAnimation::NextFrame()

 	{

 	TRgb Color;

 	TPckgBuf<TFrameData> paramsPckg;

 	if (iFrameCount == TestFrameSets[iCurrentFrameSet].iFrameCount)

 		{

 		iIsComplete = ETrue;

 		iObserver->Update(this);

 		return ;

 		}

 	Color = TestFrameSets[iCurrentFrameSet].iFrames[iFrameCount++];

 	paramsPckg().draw = iDrawArg;

 	paramsPckg().color = Color;

 	iDrawAnim.Command(EADllNextFrame, paramsPckg);

 	iAnimTimer.Start(FRAME_DELAY, TCallBack(CTTAnimation::NextFrame,this));

 	}

 //*****************************************************************************

 CTransAnimTimer::CTransAnimTimer() 

 : CTimer(EPriorityStandard)

 	{}

 CTransAnimTimer::~CTransAnimTimer()

 	{}

 void CTransAnimTimer::ConstructL()

 	{

 	CTimer::ConstructL();

 	CActiveScheduler::Add(this);

 	}

 void CTransAnimTimer::RunL()

 	{

 	iCallBack.CallBack();

 	}

 void CTransAnimTimer::Start(TTimeIntervalMicroSeconds32 aInterval,TCallBack aCallBack)

 	{

 	iCallBack = aCallBack;

 	After(aInterval);

 	}

 //*****************************************************************************

 CTTestCase::CTTestCase()

 : iError(KErrNone), iIsComplete(EFalse), iIsRunning(EFalse)

 	{}

 TBool CTTestCase::IsAlreadyRunning()

 	{

 	return iIsRunning;

 	}

 void CTTestCase::Update(CTTAnimation* aAnim)

 	{

 	iIsComplete = aAnim->IsComplete();

 	}

 TBool CTTestCase::IsComplete()

 	{

 	return iIsComplete;

 	}

 void CTTestCase::StartL()

 	{

 	if (!iIsRunning)

 		{

 		RunTestCaseL();

 		iIsRunning = ETrue;

 		}

 	}

 TBool CTTestCase::HasFailed()

 	{

 	TBool ret = EFalse;

 	if (iError != KErrNone)

 		{

 		ret = ETrue;

 		}

 	return ret;

 	}

 void CTTestCase::SetIsCompleted(TBool aIsComplete)

 	{

 	iIsComplete = aIsComplete;

 	}

 void CTTestCase::SetError(TInt aError)

 	{

 	iError = aError;

 	}

 //*********************** New Test Case Classes go here************************

 /**

  * @SYMTestCaseID GRAPHICS-WSERV-0483

  *

  * @SYMTestCaseDesc There are two animations running, one attached to a transparent

  * window using SetTransparencyAlphaChannel and a second animation with a non-transparent

  * window. The animations draw a line and then change the color of the line in subsequent

  * frames. After the last frame the alpha channel for the first animation is set to

  * opaque and then compared with the second animation to make certain that no artifacts

  * are present.

  *

  * @SYMTestPriority High

  *

  * @SYMTestStatus Implemented

  *

  * @SYMTestActions An anim is attached with a Transparent window.

  * 	The anim draws several frames using WSERV's Anim animation functionality.

  *

  * @SYMTestExpectedResults Both animations draw a line and then change it's color, the first

  * animation doing it in a tranparent window and the second doing it in a non-transparent window.

  **/

 CTGraphicsWServ0483* CTGraphicsWServ0483::NewL()

 	{

 	CTGraphicsWServ0483* testCase = new(ELeave) CTGraphicsWServ0483();

 	CleanupStack::PushL(testCase);

 	testCase->ConstructL();

 	CleanupStack::Pop();

 	return testCase;

 	}

 CTGraphicsWServ0483::~CTGraphicsWServ0483()

 	{

 	delete iAnim;

 	delete iCheckAnim;

 	}

 void CTGraphicsWServ0483::ConstructL()

 	{

 	iAnim = new(ELeave) CTTAnimation(CTAnimWin<ALPHATRANSPARENCY_ON>::NewL(

 										BaseWin->GetBorderWin()->Position(),

 										BaseWin->GetBorderWin()->Size()), DRAW_LINE_ANIMATION);

 	iCheckAnim = new(ELeave) CTTAnimation(CTAnimWin<>::NewL(

 										TestWin->GetBorderWin()->Position(),

 										TestWin->GetBorderWin()->Size()), DRAW_LINE_ANIMATION);

 	TheClient->WaitForRedrawsToFinish();

 	}

 void CTGraphicsWServ0483::RunTestCaseL()

 	{

 	iAnim->Attach(this);

 	iCheckAnim->Attach(this);

 	iAnim->SetCurrentFrameSet(ALPHA_FRAMESET);

 	iAnim->StartL();

 	iCheckAnim->SetCurrentFrameSet(ALPHA_FRAMESET);

 	iCheckAnim->StartL();	

 	}

 void CTGraphicsWServ0483::Update(CTTAnimation*)

 	{

 	if (iAnim->IsComplete() && iCheckAnim->IsComplete())

 		{

 		TRgb bgColor(150, 150, 150, 255); 

 		iAnim->GetWindow()->Win()->SetBackgroundColor(bgColor);

 		iAnim->GetWindow()->Win()->Invalidate();

 		TheClient->iWs.Finish();

 		TheClient->WaitForRedrawsToFinish();

 		if (!DoCheckRect(iAnim->GetWindow(), iCheckAnim->GetWindow()))

 			{

 			SetError(KErrGeneral);

 			}

 		SetIsCompleted(ETrue);

 		}

 	}

 TPtrC CTGraphicsWServ0483::TestCaseName()

 	{

 	_LIT(KTransparentAlphaChannelAnimationTest, "Transparent Anim Test");

 	return TPtrC(KTransparentAlphaChannelAnimationTest);

 	}

 __WS_CONSTRUCT_STEP__(TransparentAnim)