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

#include <gdi.h>
#include <fbs.h>

#include "BitmapAnimator.h"
#include "AnimationFrame.h"
#include "AnimationConfig.h"
#include "AnimationEvents.h"
#include "AnimationTicker.h"

/**
Two stage constructor.

Animators should not be constructed directly.  They are loaded as required
by the ECOM plugin framework, using this interface.

@see CAnimator
@param aRenderer A pointer to an MAnimationDrawer
@return The newly constructed animator
*/
CBitmapAnimator* CBitmapAnimator::NewL(TAny* aRenderer)
	{
	MAnimationDrawer* renderer = static_cast<MAnimationDrawer*>(aRenderer);
	CBitmapAnimator* self = new (ELeave) CBitmapAnimator(renderer);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	
	return self;
	}

/** Destructor.*/
CBitmapAnimator::~CBitmapAnimator()
	{
	Stop();
	iFrameArray.ResetAndDestroy();
	iFrameArray.Close();
	}

void CBitmapAnimator::Start(const TAnimationConfig& aConfig)
/**
Implements CAnimator::Start.

This function ignores the EStartImmediately flag in the config argument, and
always delays starting untill all frames of the animation have been loaded.
*/
	{
	Stop();
	
	if (aConfig.iFlags & TAnimationConfig::ECountFrames)
		iFlags |= ECountFrames;
	else
		iFlags &= ~ECountFrames;
		
	if (aConfig.iFlags & TAnimationConfig::EEndOnLastFrame)
		iFlags |= EEndOnLastFrame;
	else
		iFlags &= ~EEndOnLastFrame;
	
	if (aConfig.iFlags & TAnimationConfig::ELoop)
		iLoop = aConfig.iData;
	else
		iLoop = 1;
	
	iFlags &= ~ERunMask;

	if (iFrameArray.Count() > 0 && (iFlags & ECompleteData || aConfig.iFlags & TAnimationConfig::EStartImmediately))
		{
		iFlags |= ERunning;
		iTicksLeft = 0;
		// Add can fail, but if it does there isn't much we can do about it, we just won't animate.
		iRenderer->AnimatorTicker().Add(this);
		}
	else
		{
		iFlags |= EPending;
		}
	}
	
/** Implements CAnimator::Stop.*/
void CBitmapAnimator::Stop()
	{
	if (iFlags & ERunning)
		{
		if (!(iFlags & EPaused))
			iRenderer->AnimatorTicker().Remove(this);
		iFlags &= ~ERunMask;
		iNextFrame = 0;
		iCurrentFrame = 0;
		}
	}
	
/** Implements CAnimator::Pause.*/
void CBitmapAnimator::Pause()
	{
	if (iFlags & ERunning && !(iFlags & EPaused))
		{
		iFlags |= EPaused;
		iRenderer->AnimatorTicker().Remove(this);
		}
	}
	
/** Implements CAnimator::Resume.*/
void CBitmapAnimator::Resume()
	{
	if (iFlags & EPaused)
		{
		iFlags &= ~EPaused;
		// Add can fail, but if it does there isn't much we can do about it, we just won't animate.
		iRenderer->AnimatorTicker().Add(this);
		}
	}

/** Implements CAnimator::Hold.*/
void CBitmapAnimator::Hold()
	{
	if (!(iFlags & EHeld))
		{
		iFlags |= EHeld;
		}
	}

/** Implements CAnimator::Unhold.*/
void CBitmapAnimator::Unhold()
	{
	// It isn't possible to jump straight to the current frame, because it will depend on the ones
	// before.
	// It may be possible, some of the time, to use the frame we drew last to skip some of the while
	// loop - this is a possible optimization for the future.
	if (iFlags & EHeld)
		{
		iFlags &= ~EHeld;
		TInt oldCurrent = iCurrentFrame;
		iCurrentFrame = 0;
		iNextFrame = 0;
		while (iCurrentFrame < oldCurrent)
			{
			iRenderer->AnimatorDraw();
			iCurrentFrame = iNextFrame;
			iNextFrame = (iNextFrame + 1) % iFrameArray.Count();
			}
		}
	}

void CBitmapAnimator::InitialisedL()
	{
	iCurrentFrame = iNextFrame = 0;
	iFlags |= ECompleteData;
	iRenderer->AnimatorInitialisedL(iMaxSize);
	if (!(iFlags & EHeld))
		iRenderer->AnimatorDraw();
	if (iFlags & EPending)
		{
		iFlags |= ERunning;
		iFlags &= ~EPending;
		iTicksLeft = 0;
		// Add can fail, but if it does there isn't much we can do about it, we just won't animate.
		iRenderer->AnimatorTicker().Add(this);
		}
	}

void CBitmapAnimator::ResetL()
	{
	Stop();
	iFlags = 0;
	iMaxSize.iWidth = iMaxSize.iHeight = 0;
	iFrameArray.ResetAndDestroy();
	iRenderer->AnimatorResetL();
	}
	
/** Implements CAnimator::DataEventL.*/
void CBitmapAnimator::DataEventL(TInt aEvent, TAny* aData, TInt aDataLength)
	{
	switch (aEvent)
		{
		case EBitmapAnimationNewFrame:
			__ASSERT_ALWAYS(aDataLength==sizeof(CAnimationFrame::THandles),User::Leave(KErrArgument));
			AppendFrameL(*static_cast<CAnimationFrame::THandles*>(aData));
			break;
		case EBitmapAnimationComplete:
			InitialisedL();
			break;
		case EAnimationDataChanged:
			ResetL();
			break;
		default:
			break;
		}
	}
	
/** Implements CAnimator::Draw.*/
void CBitmapAnimator::Draw(CBitmapContext& aBitmapContext) const
	{
	const TUint32 frameFlags = iFrameArray[iCurrentFrame]->FrameInfo().iFlags;
	
	if (frameFlags&TFrameInfo::ERestoreToPrevious)
		RestoreToPrevious(aBitmapContext, EFalse);
	Render(aBitmapContext, iNextFrame);
	}

/** Implements CAnimator::DrawMask.*/
void CBitmapAnimator::DrawMask(CBitmapContext& aBitmapContext) const
	{
	const TUint32 frameFlags = iFrameArray[iCurrentFrame]->FrameInfo().iFlags;

	if (frameFlags&TFrameInfo::ERestoreToPrevious)
		RestoreToPrevious(aBitmapContext, ETrue);
	RenderMask(aBitmapContext, iNextFrame);
	}
	
void CBitmapAnimator::AppendFrameL(CAnimationFrame::THandles& aAnimationFrame)
	{
	CAnimationFrame* frame = CAnimationFrame::NewL(aAnimationFrame);
    CleanupStack::PushL(frame);
    iFrameArray.AppendL(frame);
    CleanupStack::Pop(frame);

    const TSize& size(frame->FrameInfo().iOverallSizeInPixels);
    if (size.iHeight > iMaxSize.iHeight)
        {
        iMaxSize.iHeight = size.iHeight;
        }
    if (size.iWidth > iMaxSize.iWidth)
        {
        iMaxSize.iWidth = size.iWidth;
        }
	}

CBitmapAnimator::CBitmapAnimator(MAnimationDrawer* aRenderer) :
iRenderer(aRenderer)
	{
	}
	
void CBitmapAnimator::ConstructL()
	{ // nothing to do
	}

void CBitmapAnimator::Tick()
	{
	--iTicksLeft;
	if (iTicksLeft < 1)
		{
		iTicksLeft = iFrameArray[iNextFrame]->FrameInfo().iDelay.Int64() / iRenderer->AnimatorTicker().TickLength().Int();
		DoUpdateFrame();
		}
	}

void CBitmapAnimator::DoUpdateFrame()
	{
	if (!((iLoop == 0 && iFlags & EEndOnLastFrame) || iFlags & EHeld))
		iRenderer->AnimatorDraw();

	if (iLoop != 0)
		{
		iCurrentFrame = iNextFrame;
		++iNextFrame;

		if (iLoop > 0 && iFlags & ECountFrames)
			--iLoop;
			
		if (iNextFrame >= iFrameArray.Count())
			{
			iNextFrame = 0;

			if (iLoop > 0 && !(iFlags & ECountFrames))
				--iLoop;
			}
		}
	else
		{
		Stop();
		}
	}

void CBitmapAnimator::Render(CBitmapContext& aBitmapContext, TInt aFrame) const
	{
	aBitmapContext.Reset();

	const CAnimationFrame& nextFrame = *iFrameArray[aFrame];
	const TBool useMask = nextFrame.FrameInfo().iFlags&TFrameInfo::ETransparencyPossible || nextFrame.FrameInfo().iFlags&TFrameInfo::EAlphaChannel;
	
	if (useMask)
		{
		aBitmapContext.BitBltMasked(nextFrame.FrameInfo().iFrameCoordsInPixels.iTl, nextFrame.Bitmap(), nextFrame.FrameInfo().iOverallSizeInPixels, nextFrame.Mask(), EFalse);
		}
	else
		{
		aBitmapContext.BitBlt(nextFrame.FrameInfo().iFrameCoordsInPixels.iTl, nextFrame.Bitmap(), nextFrame.FrameInfo().iOverallSizeInPixels);
		}
	}

void CBitmapAnimator::RenderMask(CBitmapContext& aBitmapContext, TInt aFrame) const
	{
	aBitmapContext.Reset();
	
	const CAnimationFrame& nextFrame = *iFrameArray[aFrame];

	if (aFrame == 0)
		{
		aBitmapContext.SetBrushColor(KRgbBlack);
		aBitmapContext.Clear(iMaxSize);		
		}
	else
		{
		const CAnimationFrame& currentFrame = *iFrameArray[aFrame - 1];
		if (currentFrame.FrameInfo().iFlags & TFrameInfo::ERestoreToBackground)
			{
			aBitmapContext.SetBrushColor(KRgbBlack);
			aBitmapContext.Clear(currentFrame.FrameInfo().iFrameCoordsInPixels);
			}
		}
	const TBool useMask = nextFrame.FrameInfo().iFlags&TFrameInfo::ETransparencyPossible || nextFrame.FrameInfo().iFlags&TFrameInfo::EAlphaChannel;
	if (useMask)
		{
		aBitmapContext.SetDrawMode(CGraphicsContext::EDrawModeOR);
		aBitmapContext.BitBlt(nextFrame.FrameInfo().iFrameCoordsInPixels.iTl, nextFrame.Mask(), nextFrame.FrameInfo().iOverallSizeInPixels);
		}
	else
		{
		aBitmapContext.SetBrushColor(KRgbWhite);
		if (nextFrame.FrameInfo().iOverallSizeInPixels != nextFrame.FrameInfo().iFrameSizeInPixels)
			{
			// If the frame size smaller than the overall size, the mask shall not take effect later in CBasicAnimation::Draw().
			aBitmapContext.Clear(nextFrame.FrameInfo().iOverallSizeInPixels);
			}
		else
			{
			aBitmapContext.Clear(nextFrame.FrameInfo().iFrameCoordsInPixels);
			}
		}
	}

void CBitmapAnimator::RestoreToPrevious(CBitmapContext& aBitmapContext, TBool aMask) const
	{
	TInt frame = 0;
	while (frame < iCurrentFrame)
		{
		if (!(iFrameArray[frame]->FrameInfo().iFlags&TFrameInfo::ERestoreToPrevious))
			{
			if (aMask)
				RenderMask(aBitmapContext, frame);
			else
				Render(aBitmapContext, frame);
			}
		++frame;
		}
	}