// Copyright (c) 2006-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 <barsread.h>

#include <basched.h>

#include <coeaui.h>

#include <eikappui.h>

#include <eikapp.h>

#include <eikdoc.h>

#include <techview/eikdialg.h>

#include <techview/eikchlst.h>

#include <techview/eikchkbx.h>

#include <techview/eikmfne.h>

#include <techview/eikmenup.h>

#include <eikenv.h>

#include <ecom/ecom.h>

#include <tbmpanim.rsg>

#include <tbmpanim.mbg>

#include "Tanctl.h"

#include "TBMPAnim.hrh"

#include <bmpancli.h>

#include "TBmpAnimStep.h"

_LIT(resourceFileName,"z:\\resource\\apps\\tbmpanim\\tbmpanim.rsc");

const TInt KArrayGranularity = 5;

// Panics

void CTestContainer::Panic(TContainerPanic aPanic)

	{

	_LIT(KPanicCat,"TBmpAnim-Animation");

	User::Panic(KPanicCat, aPanic);

	}

TAnimationAttributes::TAnimationAttributes()

	: iNumberOfCycles(-1)

	{

	}

//

// CAnimationDlg

//

CAnimationDlg::CAnimationDlg(TFileName aFileName)

	: iFileName(aFileName)

	{

	}

CAnimationDlg::~CAnimationDlg()

	{

	if(iTimer)

		iTimer->Cancel();

	delete iTimer;

	}

void CAnimationDlg::PostLayoutDynInitL()

	{

	CAnimateFramesCtl* animationCtl = static_cast<CAnimateFramesCtl*>(Control(EBmpAnimationCtlId));

	animationCtl->StartAnimationL();

	TCallBack cb(Execute,this);

	iTimer = CPeriodic::NewL(EPriorityLow);

	iTimer->Start(TTimeIntervalMicroSeconds32(7000000), TTimeIntervalMicroSeconds32(1), cb);

	}

TInt CAnimationDlg::Execute(TAny* aDialog)

	{

	CAnimationDlg* theDialog = (CAnimationDlg*) aDialog;

	theDialog->iTimer->Cancel();

	delete theDialog->iTimer;

	theDialog->iTimer = 0;

	theDialog->TryExitL(-2);

	return 0;

	}

TBool CAnimationDlg::OkToExitL(TInt /*aControlId*/)

    {

	static_cast<CAnimateFramesCtl*>(Control(EBmpAnimationCtlId))->CancelAnimationL();

	return(ETrue);

    }

SEikControlInfo CAnimationDlg::CreateCustomControlL(TInt aControlType)

	{

	SEikControlInfo controlInfo;

	controlInfo.iControl = NULL;

	controlInfo.iTrailerTextId = 0;

	controlInfo.iFlags = 0;

	if (aControlType == EBmpAnimationCtlType)

		{

		controlInfo.iControl = CAnimateFramesCtl::NewL();

		static_cast<CAnimateFramesCtl*>(controlInfo.iControl)->SetFileName(iFileName);

		}

    return controlInfo;

	}

//

//

// class CAnimation

//

CAnimation::CAnimation()

	: iIndex(0),

	iType(ENoAnimation)

	{

	}

CAnimation::~CAnimation()

	{

	delete iAnimationCtl;

	}

void CAnimation::SetAnimationExtent()

	{

	TSize animSize = iAnimationCtl->MinimumSize();

	TPoint position(0, 0);

	switch (iType)

		{

	case EDefaultAnimation:

		position.SetXY(0, 0);

		break;

	case EDefaultAnimationSh:

		position.SetXY(100, 50);

		break;

	case EBallAnimation:

		position.SetXY(0, 100);

		break;

	case ERedPurpBallAnimationMaskedBackground:

		position.SetXY(0, 100);

		break;

	case ETBmpAnimBallAnimWindowCovering:

		position.SetXY(0, 100);

		break;

	default:

		return;

		}

	iAnimationCtl->SetExtent(position, animSize);

	}

void CAnimation::CopyAttributesFromClientData()

	{

	CBitmapAnimClientData* animClientData = iAnimationCtl->BitmapAnimData();

	if (animClientData)

		{

		iAttributes.iFrameIntervalInMilliSeconds = animClientData->FrameIntervalInMilliSeconds();

		iAttributes.iPlayMode = animClientData->PlayMode();

		}

	}

class CTestContainer;

//

//

// class CTestContainer

//

CTestContainer::CTestContainer()

	{

	}

CTestContainer::~CTestContainer()

	{

	if (iAnimationsArray)

		iAnimationsArray->ResetAndDestroy();

	delete iAnimationsArray;

	// Delete window used in test cases.

	delete iCoveringWindowControl;

	}

//

//

void CTestContainer::ConstructL()

	{

	iColor = KRgbBlack;

	CreateWindowL();

	RWindow window = Window();

	window.SetTransparencyAlphaChannel();

	window.SetBackgroundColor(TRgb(150,150,150,150));

	iAnimationsArray=new(ELeave) CArrayPtrFlat<CAnimation>(KArrayGranularity);

	//Set the background of the container window to the default. 

	iBackgroundType = EBackgroundBlackRedGreenYellowStripes;

	ActivateL();

	//Construct a window that can be used in test cases.

	iCoveringWindowControl = new (ELeave) CTestWindowControl;	

	iCoveringWindowControl->ConstructL();

	}

//

//

void CTestContainer::StartAnimationL(TInt aIndex)

	{

	TInt count = iAnimationsArray->Count();

	__ASSERT_ALWAYS(iAnimationsArray, Panic(TContainerPanicNoArray));

	__ASSERT_ALWAYS((aIndex >= 0 && (aIndex < count || aIndex == EAllAnimations)), Panic(TInvalidIndex));

	TInt startIndex = 0;

	if (aIndex != EAllAnimations)

		{

		count = aIndex;

		startIndex = aIndex;

		}

	else

		count -= 1;

	for (TInt i=startIndex; i<=count; i++)

		{

		CAnimation* singleAnimationCtl = iAnimationsArray->At(i);

		if (singleAnimationCtl->iAttributes.iOnOff)

			{

			singleAnimationCtl->iAnimationCtl->StartAnimationL();

			}

		}

	}

void CTestContainer::CancelAnimationL(TInt aIndex)

	{

	TInt count = iAnimationsArray->Count();

	__ASSERT_ALWAYS(iAnimationsArray, Panic(TContainerPanicNoArray));

	__ASSERT_ALWAYS((aIndex >= 0 && (aIndex < count || aIndex == EAllAnimations)), Panic(TInvalidIndex));

	TInt startIndex = 0;

	if (aIndex != EAllAnimations)

		{

		count = aIndex + 1;

		startIndex = aIndex;

		}

	for (TInt i=startIndex; i<count; i++)

		iAnimationsArray->At(i)->iAnimationCtl->CancelAnimationL();

	}

void CTestContainer::ShowAnimationL(TAnimationFlag aAnimationType)

	{

	TInt index = FindAnimation(aAnimationType);

	if (index == KErrNotFound)

		return;

	else

		StartAnimationL(index);

	}

TInt CTestContainer::FindAnimation(TAnimationFlag aAnimationType)

	{

	TInt count = iAnimationsArray->Count();

	__ASSERT_ALWAYS(iAnimationsArray, Panic(TContainerPanicNoArray));

	TInt index = 0;

	for(index=0; index<count; index++)

		if (iAnimationsArray->At(index)->iType == aAnimationType)

			return index;

	return KErrNotFound;

	}

CAnimation* CTestContainer::CreateAnimationByTypeL(TAnimationFlag aAnimationType)

	{

	__ASSERT_ALWAYS(iAnimationsArray, Panic(TContainerPanicNoArray));

	TInt count = iAnimationsArray->Count();

	CAnimation* singleAnimationCtl = new (ELeave) CAnimation;

	CleanupStack::PushL(singleAnimationCtl);

	singleAnimationCtl->iIndex = count;

	singleAnimationCtl->iType = aAnimationType;

	CAnimateFramesCtl* animationCtl = NULL;

	TRAPD(error, animationCtl = CAnimateFramesCtl::NewL());

	if (error != KErrNone)

		User::Panic(_L("New Animation"), error);

	singleAnimationCtl->iAnimationCtl = animationCtl;

	animationCtl->SetFileName(iFileName);

	TInt resourceReaderId = 0;

	switch (aAnimationType)

		{

	case EDefaultAnimation:

		resourceReaderId = R_TBMPANIM_IMAGE1;

		break;

	case EDefaultAnimationSh:

		resourceReaderId = R_TBMPANIM_IMAGE1;

		break;

	case EBallAnimation:

		resourceReaderId = R_TBMPANIM_IMAGE3;

		break;

	case ERedPurpBallAnimationMaskedBackground:

		resourceReaderId = R_TBMPANIM_IMAGE4;

		break;

	case ETBmpAnimBallAnimWindowCovering:

		resourceReaderId = R_TBMPANIM_IMAGE5;

		break;

	default:

		delete singleAnimationCtl;

		return NULL;

		}

	TResourceReader reader;

	iCoeEnv->CreateResourceReaderLC(reader,resourceReaderId);

	animationCtl->ConstructFromResourceL(reader);

	CleanupStack::PopAndDestroy(); // reader

	singleAnimationCtl->SetAnimationExtent();

	singleAnimationCtl->CopyAttributesFromClientData();

	iAnimationsArray->AppendL(singleAnimationCtl);

	CleanupStack::Pop(); // singleAnimationCtl

	return singleAnimationCtl;

	}

void CTestContainer::SizeChanged()

	{

	TInt count = 0;

	TRect rect = Rect();

	if(iAnimationsArray)

		count = iAnimationsArray->Count();

	for (TInt index = 0; index < count; index++)

		iAnimationsArray->At(index)->iAnimationCtl->SetRect(rect);

	}

TInt CTestContainer::CountComponentControls() const

	{

	return iAnimationsArray->Count();;

	}

void CTestContainer::Draw(const TRect& /*aRect*/) const

	{

	switch(iBackgroundType)

		{	

	case EBackgroundBlackRedGreenYellowStripes:

		{

		const TRect rect=Rect();

		CWindowGc& gc=SystemGc();

		gc.SetPenStyle(CGraphicsContext::ENullPen);

		gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

		gc.SetBrushColor(iColor);

		TInt yOffset = rect.Height() / 4;

		TRect portionRect(rect.iTl.iX, rect.iTl.iY, rect.iBr.iX, rect.iTl.iY + yOffset);

		gc.DrawRect(portionRect);

		gc.SetBrushColor(KRgbRed);

		portionRect.iTl.iY = portionRect.iBr.iY;

		portionRect.iBr.iY += yOffset;

		gc.DrawRect(portionRect);

		gc.SetBrushColor(KRgbGreen);

		portionRect.iTl.iY = portionRect.iBr.iY;

		portionRect.iBr.iY += yOffset;

		gc.DrawRect(portionRect);

		gc.SetBrushColor(KRgbYellow);

		portionRect.iTl.iY = portionRect.iBr.iY;

		portionRect.iBr.iY = rect.iBr.iY;

		gc.DrawRect(portionRect);

		gc.SetBrushColor(KRgbWhite);

		}

		break;

	case EBackgroundYellow:

		{

		const TRect rect=Rect();

		CWindowGc& gc=SystemGc();

		gc.SetPenStyle(CGraphicsContext::ENullPen);

		gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

		gc.SetBrushColor(KRgbYellow);

		gc.DrawRect(rect);

		}

		break;

	case EBackgroundBlue:

		{

		const TRect rect=Rect();

		CWindowGc& gc=SystemGc();

		gc.SetPenStyle(CGraphicsContext::ENullPen);

		gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

		gc.SetBrushColor(KRgbBlue);

		gc.DrawRect(rect);

		}

		break;

	default:

		break;

		}

	}

CCoeControl* CTestContainer::ComponentControl(TInt aIndex) const

	{

	return iAnimationsArray->At(aIndex)->iAnimationCtl;

	}

void CTestContainer::SetAppFileName(TDesC& aAppFileName)

	{

	iFileName = aAppFileName;

	}

void CTestContainer::CreateAndRunAnimationL()

	{

	CAnimateFramesCtl* animationCtl = CAnimateFramesCtl::NewL();

	CleanupStack::PushL(animationCtl);

	animationCtl->SetContainerWindowL(*this);

	animationCtl->SetFileName(iFileName);

	TResourceReader reader;

	iCoeEnv->CreateResourceReaderLC(reader, R_TBMPANIM_IMAGE3);

	animationCtl->ConstructFromResourceL(reader);

	CleanupStack::PopAndDestroy(); // reader

	animationCtl->StartAnimationL();	

	User::After(1000000);

	animationCtl->CancelAnimationL();

	animationCtl->SetFrameIndexL(4);

	User::After(1000000);

	animationCtl->StartAnimationL();

	User::After(1000000);

	animationCtl->SetPosition(TPoint(100, 100));

	User::After(1000000);

	animationCtl->SetFrameIndexL(1);

	User::After(1000000);

	animationCtl->SetFrameIndexL(4);

	User::After(1000000);

	animationCtl->SetFrameIntervalL(100);

	User::After(1000000);

	CleanupStack::PopAndDestroy(); // animationCtl

	}

void CTestContainer::SetAnimationAttributesL(TAnimationFlag aAnimationType)

	{

//	CCoeEnv* coeEnv = CCoeEnv::Static();

//	CSimpleAppUi* theApplication = (CSimpleAppUi*) (coeEnv->AppUi());

	CAnimation* animation = NULL;

	TInt animationIndex = FindAnimation(aAnimationType);

	TBool notFound = (animationIndex == KErrNotFound ? ETrue : EFalse);

	if (notFound)

		{

		animation = CreateAnimationByTypeL(aAnimationType);

		if (animation)

			animationIndex = animation->iIndex;

		else

			return;

		}

	else

		animation = iAnimationsArray->At(animationIndex);

	animation->iAttributes.iOnOff=ETrue;

	if (notFound)

		{

		CAnimateFramesCtl* animationCtl = iAnimationsArray->At(animationIndex)->iAnimationCtl;

		animationCtl->SetAnimationCtlWindowL(this);

		animationCtl->SetExtent(animationCtl->Position(), animationCtl->MinimumSize());

		animationCtl->ActivateL();

		animationCtl->DrawNow();

		}

	ShowAnimationL(aAnimationType);

	}

/*

 * INC 133854, DEF136660

 * 

 * Tests that the background frame is drawn

 * 

 * Actions:

 * 1. Create background frame

 * 2. Create another frame (atleast one frame is required to enter into the animation loop)

 * 3. Start the animation which displays both the frames on the screen

 * 4. Create a bitmap and blit into it the part of the screen where frame with background was displayed

 * 5. Create a bitmap and blit into it the background and frame bitmaps

 * 6. Compare the 2 bitmaps from step 4 and 5 (test fails if the 2 bitmaps dont match)

 * 

 * Expected Result: The background bitmap is drawn and test passes    

 */

TBool CTestContainer::TestRenderBackgroundFrameL()

	{

	TPoint pos(0,0);

	CAnimateFramesCtl* animationCtl = CAnimateFramesCtl::NewL();

	CleanupStack::PushL(animationCtl);

	animationCtl->SetAnimationCtlWindowL(this);

	animationCtl->BitmapAnimData()->SetPlayMode(CBitmapAnimClientData::ECycle);	

	animationCtl->ActivateL();

	// set backgroud frame

	CFbsBitmap* backgroundBitmap = iEikonEnv->CreateBitmapL(KTBmpAnimMBMFilePath, EMbmTbmpanimTextured);

	CleanupStack::PushL(backgroundBitmap);

	CBitmapFrameData* backgroundFrame = CBitmapFrameData::NewL(backgroundBitmap);	

	CleanupStack::PushL(backgroundFrame);

	animationCtl->BitmapAnimData()->SetBackgroundFrame(backgroundFrame);

	CleanupStack::Pop(2,backgroundBitmap);

	// set frame 1

	CFbsBitmap* frame1Bitmap = iEikonEnv->CreateBitmapL(KTBmpAnimMBMFilePath, EMbmTbmpanimLink0);

	CleanupStack::PushL(frame1Bitmap);

	CFbsBitmap* frame1BitmapMask = iEikonEnv->CreateBitmapL(KTBmpAnimMBMFilePath, EMbmTbmpanimLink0m);

	CleanupStack::PushL(frame1BitmapMask);	

	CBitmapFrameData* frame1 = CBitmapFrameData::NewL(frame1Bitmap,frame1BitmapMask);	

	CleanupStack::PushL(frame1);

	animationCtl->BitmapAnimData()->AppendFrameL(frame1);

	CleanupStack::Pop(3,frame1Bitmap);	//frame1, frame1BitmapMask, frame1Bitmap

	animationCtl->CompleteAnimationInitialisationL();

	animationCtl->Animation()->StartL();

	User::After(1000000);

	TBool ret=CompareScreenContentWithTestBitmapL(*backgroundFrame,*frame1, pos);

	animationCtl->Animation()->StopL();		

	CleanupStack::PopAndDestroy();	// animationCtl 		

	return ret;

	}

TBool CTestContainer::CompareScreenContentWithTestBitmapL(const CBitmapFrameData& aBkgdFrame, const CBitmapFrameData& aFrame1, const TPoint& aPos)

	{

	TSize size = aFrame1.Bitmap()->SizeInPixels();