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