// Copyright (c) 2004-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
	@internalTechnology */
#include "MngPlayer.h"
#include "MngPanic.h"
#include "MngRenderer.h"

#include "MngObjects.h"

/*virtual*/
void CMngObject::Reset()
	{
	}

/*virual*/
TBool CMngObject::IsSubFrame() const
	{
	return EFalse;
	}

/*virual*/
TBool CMngObject::IsLayer() const
	{
	return EFalse;
	}

/*virual*/
void CMngObject::OnAddToPlayerL(const CMngPlayer& /*aPlayer*/)
	{
	}

/*virual*/
TBool CMngLayer::IsLayer() const
	{
	return ETrue;
	}

/*static*/
CMngTermination* CMngTermination::NewL(TTermChunk*& aTermChunk, TBool aMngSubframesNoLoops)  //Subframes with No Loops
	{
	TTermChunk* pChunk=aTermChunk;
	CleanupDeletePushL(pChunk);
	aTermChunk = NULL;
	CMngTermination* self=new (ELeave) CMngTermination(*pChunk, aMngSubframesNoLoops); //Subframes with No Loops
	CleanupStack::PopAndDestroy(pChunk);
	return self;
	}

void CMngTermination::ExecuteL(CMngPlayer& aPlayer, TMngExecuteResult& aResult)
	{
	TMngTerminationAction Action=iPostIterationAction;
	
	//Subframes with No Loops
	if(iMngSubframesNoLoops)
		{
		iIterationCounter = 1;
		Action =EMngShowLastFrameIndef;	
		}

	ASSERT(iIterationCounter > -1);
	iIterationCounter -= (iIterationCounter>0 && iIterationCounter!=KMngInfinity);
	aResult.iDelayInTicks = iDelay;
	if (iIterationCounter)
		{
		Action=iTerminationAction;
		}
	switch (Action)
		{
		case EMngShowLastFrameIndef: 
			aResult.iCommand=ECmdTerminate;
			break;
		case EMngCeaseDisplAnything: 
			aResult.iCommand=ECmdTerminateClearOutput;
			break;
		case EMngShowFirstFrmAfterTerm:
			aResult.iCommand=ECmdTerminateAfter1stFrame;
			aPlayer.SetTerminationFrameNum(1);
			break;
		case EMngRepeatImmidiately:
			aResult.iCommand=ECmdStartFromBeginning;
			break;
		default:
			User::Leave(KErrCorrupt);
		}
	}

void CMngTermination::Reset()
	{
	iIterationCounter = iIterationMax;
	}

/*static*/
CMngObject* CMngKeyFrame::NewL(TMngChunk*& aFramChunk)
	{
	CleanupDeletePushL(aFramChunk);
	TFramChunk* FrameChunk=static_cast<TFramChunk*>(aFramChunk);
	aFramChunk=NULL;
	CMngKeyFrame* self=new (ELeave) CMngKeyFrame(FrameChunk);
	CleanupStack::Pop();
	return self;
	}

inline
CMngKeyFrame::CMngKeyFrame(TFramChunk* aFramChunk):iFramChunk(aFramChunk)
	{
	}

CMngKeyFrame::~CMngKeyFrame()
	{
	delete iFramChunk;
	}

void CMngKeyFrame::ExecuteL(CMngPlayer& aPlayer, TMngExecuteResult& /*aResult*/)
	{
	aPlayer.SetFramingMode(iFramChunk->iFramingMode);
	if (EMngFramDoNotChange != iFramChunk->iChangeInterFrmDelay)
		{
		aPlayer.SetInterFrameDelay(iFramChunk->iChangeInterFrmDelay, iFramChunk->iInterframeDelay);
		}

	if (EMngFramDoNotChange  != iFramChunk->iChangeClippingBoundaries)
		{
		aPlayer.SetLayerClipping(iFramChunk->iChangeClippingBoundaries, 
									TRect(iFramChunk->iLeftLayerClippingB, iFramChunk->iTopLayerClippingB,
										  iFramChunk->iRightLayerClippingB, iFramChunk->iBottomLayerClippingB),
									iFramChunk->iAddLayerClipping);
		}
	}

TBool CMngKeyFrame::IsSubFrame() const
	{
	return ETrue;
	}

/*static*/
CMngObject* CMngBackground::NewL(TMngChunk*& aBackChunk)
	{
	TBackChunk* BackChunk=static_cast<TBackChunk*>(aBackChunk);
	aBackChunk = NULL;
	CleanupDeletePushL(BackChunk);
	CMngBackground* self=new (ELeave) CMngBackground(*BackChunk);
	CleanupStack::PopAndDestroy(BackChunk);
	return self;
	}

void CMngBackground::ExecuteL(CMngPlayer& aPlayer, TMngExecuteResult& /*aResult*/)
	{
	aPlayer.Renderer()->SetBackground(iBackgroundColour, (iBgMandatory&EMngTermBgColorMandatoryImgAdvisory) );
	}

/*static*/
CMngObject* CMngRawChunkHolder::NewL(TMngChunk*& aChunk)
	{
	TMngRawChunk* RawChunk=static_cast<TMngRawChunk*>(aChunk);
	aChunk = NULL;
	CleanupDeletePushL(RawChunk);
	CMngRawChunkHolder* self=new (ELeave) CMngRawChunkHolder(RawChunk);
	CleanupStack::Pop(RawChunk);
	return self;
	}

void CMngRawChunkHolder::ExecuteL(CMngPlayer& aPlayer, TMngExecuteResult& /*aResult*/)
	{
	aPlayer.AddUniqueChunkProviderL(iChunk->iHeader.iChunkId, *this);
	}

TInt CMngRawChunkHolder::GetChunkData(const TText8* aChunkId, const TUint8*& aDataPtr, TInt& aSizeInBites)
	{
	TInt res=KErrNone;
	if (iChunk->iHeader.iChunkId == TPtrC8(aChunkId, sizeof(TChunkId)) )
		{
		aDataPtr = iChunk->Data();
		aSizeInBites = iChunk->iHeader.iLength;
		}
	else
		{
		res = KErrNotFound;
		aSizeInBites = 0;
		aDataPtr = NULL;
		}
	return res;
	}

CMngRawChunkHolder::~CMngRawChunkHolder()
	{
	delete iChunk;
	}

/*static*/
CMngObject* CMngImageDefinition::NewL(TMngChunk*& aDefiChunk)
	{
	TDefiChunk* DefiChunk=static_cast<TDefiChunk*>(aDefiChunk);
	aDefiChunk = NULL;
	CleanupDeletePushL(DefiChunk);
	CMngImageDefinition* self = new (ELeave) CMngImageDefinition(*DefiChunk);
	CleanupStack::PopAndDestroy(DefiChunk);
	return self;
	}

void CMngImageDefinition::ExecuteL(CMngPlayer& aPlayer, TMngExecuteResult& /*aResult*/)
	{
	CMngRenderer* Renderer = aPlayer.Renderer();
	Renderer->SetOutputEnabled(!iDoNotShow);
	Renderer->SetImageOrigin(iOrigin);
	Renderer->SetImageClipRect(iClippingRect);
	}

void CMngImageDefinition::OnAddToPlayerL(const CMngPlayer& aPlayer)
	{
	if (iClippingRect.iBr.iX==-1 && iClippingRect.iTl.iX==0)
		{
		iClippingRect.iBr.iX= 0;
		iClippingRect.iBr	= aPlayer.FrameSize().AsPoint();
		}
	}

/*static*/
CMngObject* CMngLoopEntry::NewL(TMngChunk*& aLoopChunk)
	{
	TLoopChunk* LoopChunk=static_cast<TLoopChunk*>(aLoopChunk);
	aLoopChunk = NULL;
	CleanupDeletePushL(LoopChunk);
	CMngLoopEntry* self = new (ELeave) CMngLoopEntry(*LoopChunk);
	CleanupStack::PopAndDestroy(LoopChunk);
	return self;
	}

void CMngLoopEntry::ExecuteL(CMngPlayer& aPlayer, TMngExecuteResult& /*aResult*/)
	{
	ASSERT(iIterationsLeft>-1);
	TLoopStackItem item;
	item.iLoopObjectLabel		= ObjectLabel();
	item.iNestLevel				= iNestLevel;
	if (iIterationsLeft > 0)
		{
		--iIterationsLeft;
		}
	if (iIterationsLeft > 0)
		{
		item.iMoreIterationsNeeded = ETrue;
		}
	else
		{
		iIterationsLeft = iIterationCount;
		item.iMoreIterationsNeeded = EFalse;
		}
	aPlayer.LoopStack().PushL(item);
	}

void CMngLoopEntry::Reset()
	{
	iIterationsLeft = iIterationCount;
	}

/*static*/
CMngObject* CMngLoopEnd::NewL(TMngChunk*& aEndlChunk)
	{
	TEndlChunk* EndlChunk=static_cast<TEndlChunk*>(aEndlChunk);
	aEndlChunk = NULL;
	CleanupDeletePushL(EndlChunk);
	CMngLoopEnd* self = new (ELeave) CMngLoopEnd(*EndlChunk);
	CleanupStack::PopAndDestroy(EndlChunk);
	return self;
	}

void CMngLoopEnd::ExecuteL(CMngPlayer& aPlayer, TMngExecuteResult& aResult)
	{
	TLoopStackItem item;
	if (KErrNone != aPlayer.LoopStack().Pop(item))
		{
		User::Leave(KErrCorrupt);
		}
	if (item.iNestLevel != iNestLevel)
		{
		User::Leave(KErrCorrupt);
		}
	if (item.iMoreIterationsNeeded)
		{
		aResult.iCommand	= ECmdJumpToObject;
		aResult.iObjectLabel= item.iLoopObjectLabel;
		}
	}