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

const TInt KAnimationGranularity = 5;

// times

const TInt KMilliToMicroSecondsFactor = 1000;

//

// CBitmapAnimFrameData

//

/** 

 Creates a new empty frame object.

@return A pointer to the new empty frame object.

*/

CBitmapAnimFrameData* CBitmapAnimFrameData::NewL()

	{

	CBitmapAnimFrameData* self = CBitmapAnimFrameData::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

/** 

 Constructs a new bitmap animation frame data object,and puts a pointer to it onto the cleanup stack.

@return A pointer to the new empty frame data object or NULL if the disk is full.

*/

CBitmapAnimFrameData* CBitmapAnimFrameData::NewLC()

	{

	CBitmapAnimFrameData* self = new (ELeave) CBitmapAnimFrameData;

	CleanupStack::PushL(self);

	return self;

	}

/**

 Empty default constructor.

 */

CBitmapAnimFrameData::CBitmapAnimFrameData()

	{

	}

/**

 Frees resources owned by the object prior to deletion.

*/ 

CBitmapAnimFrameData::~CBitmapAnimFrameData()

 	{

	if( iBitmap && (iBitmap != iMaskBitmap) )

		{	

		delete iBitmap;

		}

	if( iMaskBitmap )

		{	

		delete iMaskBitmap;

		}

	}

/** 

 Initialization of CBitmapAnimFrameData data members to NULL.

*/

void CBitmapAnimFrameData::InitialiseMembers()

	{

	if( iBitmap && (iBitmap != iMaskBitmap) )

		{

		delete iBitmap;

		iBitmap = NULL;	

		}

	if( iMaskBitmap )

		{

		delete iMaskBitmap;

		iMaskBitmap = NULL;	

		iBitmap = NULL;

		}

	iPosition.SetXY( 0, 0 );

	iInterval = 0;	

	}

/** 

 Creates bitmaps if they are not created earlier.

*/

void CBitmapAnimFrameData::CheckAndCreateBitmapsL()

	{

	if (iBitmap == NULL)

		{

		iBitmap = new(ELeave) CFbsBitmap();

		}

	if (iMaskBitmap == NULL)

		{

		iMaskBitmap = new(ELeave) CFbsBitmap();

		}

	}

/**

 Un-packs the frame data arguments, aFrameDataArg, and uses this information to fill the frame

 data with two bitmaps, a position and a time interval.

*/

void CBitmapAnimFrameData::FillFrameDataL( const TFrameData& aFrameDataArg )

	{

// Create the icon by using the bitmap handles

	if ( aFrameDataArg.iBitmapHandle )	// Null member of sequence, time is only valid field in member data

		{

		iBitmap = new(ELeave) CFbsBitmap();

		User::LeaveIfError(iBitmap->Duplicate(aFrameDataArg.iBitmapHandle));

		if (aFrameDataArg.iMaskBitmapHandle)

			{

			iMaskBitmap = new(ELeave) CFbsBitmap();

			User::LeaveIfError(iMaskBitmap->Duplicate(aFrameDataArg.iMaskBitmapHandle));

			}

		iPosition = aFrameDataArg.iPosition;

		iInterval = (TTimeIntervalMicroSeconds32) ( aFrameDataArg.iIntervalInMilliSeconds * KMilliToMicroSecondsFactor );

		}

	else

		{

		InitialiseMembers();

		}

	}

/**

 class CBitmapAnim

*/

/**

 Constructs a new bitmap animation object.

*/

CBitmapAnim::CBitmapAnim() :

	iBitmapAnimFrameDataArray(KAnimationGranularity),

	iFlags(ENoBitmapWindowRestoring),

	iIndex(-1),

	iNumberOfCycles(-1),

	iPosition(0,0)

	{

	}

/**

 Frees resources owned by the object prior to deletion.

*/

CBitmapAnim::~CBitmapAnim()

	{

	StopAnimation();

	delete iAnimTimer;

	delete iFlashTimer;

	iBitmapAnimFrameDataArray.ResetAndDestroy();

	iBitmapAnimFrameDataArray.Close();

	delete iBackgroundFrame;

	}

/**

 Creates a new empty bitmap animation object.

@return A pointer to the new empty bitmap animation object.

*/

CBitmapAnim* CBitmapAnim::NewL()

	{

	CBitmapAnim* self = new (ELeave) CBitmapAnim();

	return self;

	}

/**

 Pure virtual function from CAnim it creates the animation timer object.

*/

void CBitmapAnim::ConstructL(TAny* /*aArgs*/, TBool /*aHasFocus*/)

	{

	iAnimTimer = CBitmapAnimTimer::NewL(this);

	}

void CBitmapAnim::Animate(TDateTime* /*aDateTime*/)

	{

	}

/**

 Stops animation and resets animation frame data array.

*/

void CBitmapAnim::ResetFrameArray()

	{

	StopAnimation();

	iBitmapAnimFrameDataArray.ResetAndDestroy();

	}

/**

 Appends a new frame, aFrame, to the frame array.

*/

void CBitmapAnim::AppendFrameL(const TFrameData& aFrameDataArg)

	{

	CBitmapAnimFrameData* dataFrame = CBitmapAnimFrameData::NewLC();

	dataFrame->FillFrameDataL(aFrameDataArg);

	User::LeaveIfError(iBitmapAnimFrameDataArray.Append(dataFrame));

	CleanupStack::Pop(dataFrame);

	}

/**

 Pure virtual function from CAnim.

*/

void CBitmapAnim::Command(TInt aOpcode, TAny* aArgs)

	{

	switch (aOpcode)

		{

	case EBitmapAnimCommandClearDataFrames:

  		ClearFrameData();

  		break;

	case EBitmapAnimCommandSetFlash:

		SetFlash(*(TBmpAnimAttributes*)aArgs);

		break;

	case EBitmapAnimCommandSetFrameIndex:

		SetIndexFrame(*(SBitmapAnimIndexFrame*)aArgs);

		break;

	case EBitmapAnimCommandSetFrameInterval:

		SetFrameInterval(*(TBmpAnimAttributes*)aArgs);

		break;

	case EBitmapAnimCommandSetNumberOfCycles:

		SetNumberOfCycles(*(SBitmapAnimNumberOfCycles*)aArgs);

		break;

	case EBitmapAnimCommandSetPlayMode:

		SetPlayMode(*(TBmpAnimAttributes*)aArgs);

		break;

	case EBitmapAnimCommandSetPosition:

		SetPosition(*(SBitmapAnimNewPosition*)aArgs);

		break;

		}

	}

/**

 Pure virtual function from CAnim it handles the command received by the relative client.

 aOpcode determines the action that has to be taken while aArgs contains the information

 packed by the client. It returns KErrNone if no problem has occurred.

*/

TInt CBitmapAnim::CommandReplyL(TInt aOpcode, TAny* aArgs)

	{

	TInt error = KErrNone;

	switch (aOpcode)

		{

	case EBitmapAnimCommandClearDataFrames:

  	    ClearFrameData();

  	    break;

	case EBitmapAnimCommandStartAnimation:

		StartAnimationL();

		break;

	case EBitmapAnimCommandStopAnimation:

		StopAnimation();

		break;

	case EBitmapAnimCommandSetBackgroundFrame:

		SetBackgroundFrameL(*(TFrameData*)aArgs);

		break;

	case EBitmapAnimCommandSetDataFrame:

		AppendFrameL(*(TFrameData*)aArgs);

		break;

	case EBitmapAnimCommandSetFlash:

		SetFlash(*(TBmpAnimAttributes*)aArgs);

		break;

	case EBitmapAnimCommandSetFrameIndex:

		error = SetIndexFrame(*(SBitmapAnimIndexFrame*)aArgs);

		break;

	case EBitmapAnimCommandSetFrameInterval:

		SetFrameInterval(*(TBmpAnimAttributes*)aArgs);

		break;

	case EBitmapAnimCommandSetNumberOfCycles:

		SetNumberOfCycles(*(SBitmapAnimNumberOfCycles*)aArgs);

		break;

	case EBitmapAnimCommandSetPlayMode:

		SetPlayMode(*(TBmpAnimAttributes*)aArgs);

		break;

	case EBitmapAnimCommandSetPosition:

		SetPosition(*(SBitmapAnimNewPosition*)aArgs);

		break;

	case EBitmapAnimCommandStartAnimationAndKeepLastFrame:

		iFlags |= EDisplayLastFrameWhenFinished;

		StartAnimationL();

		break;

	case EBitmapAnimCommandResetFrameArray:

		ResetFrameArray();

		break;

	default:

		error = KErrNotSupported;

		}

	return error;

	}

/**

 Clears Frame data by stopping animation and resetting frame data array.

*/

void CBitmapAnim::ClearFrameData()

 	{

 	StopAnimation();

 	iBitmapAnimFrameDataArray.ResetAndDestroy();

 	iIndex = -1;

 	}

/**

 Pure virtual function from MAnimationTimer it is used to draw the next frame. It first updates

 the index frame, checks if the frame is displayable and if so it draws the frame otherwise it

 stops the animation.

*/

void CBitmapAnim::DisplayNextFrameL()

	{

	if (!IsRunning())

		{

		return;

		}

	const TInt previousIndex = iIndex;

	UpdateCurrentIndex();

	if (IsFrameDisplayable())

		{

		if (!IsFrozen())

			{

			DisplayFrame(previousIndex);

			}

		}

	else

		{

		iIndex = previousIndex;

		StopAnimation();

		}

	}

/**

 Draws the current frame in a particular position.

 */

void CBitmapAnim::DrawBitmap(TInt /*aPreviousIndex*/, TBool aRedraw)

	{

	__ASSERT_ALWAYS((iIndex>=0 && iIndex < Count()), Panic(EAnimationServerPanicIndexOutOfRange));

	CBitmapAnimFrameData* frameData = iBitmapAnimFrameDataArray[iIndex];

	if (frameData->iBitmap)

		{

		if (!aRedraw)

			{

			iWindowFunctions->ActivateGc();

			}

		const TPoint framePosition = frameData->iPosition + iPosition;

		RenderFrameBackground(iIndex);

		if (frameData->iMaskBitmap)

			{

			iGc->BitBltMasked(framePosition, frameData->iBitmap, frameData->iBitmap->SizeInPixels(), frameData->iMaskBitmap, ETrue);

			}

		else

			{

			iGc->BitBlt(framePosition, frameData->iBitmap);

			}

		MAnimFreeTimerWindowFunctions* windowFunctions = WindowFunctions();

		if (!aRedraw)

			{

			windowFunctions->DeactivateGc();

			}

		windowFunctions->Update();

		}

	}

/**

 Sets the next call-back of the timer and draws the new frame.

 */

void CBitmapAnim::DisplayFrame(TInt aPreviousIndex)

	{

	TTimeIntervalMicroSeconds32 time = iBitmapAnimFrameDataArray[iIndex]->iInterval;

	if (time.Int() < 0)

		{

		time = iFrameInterval;

		}

    // Limits frame interval time

    const TTimeIntervalMicroSeconds32 KAnimationMinimumFrameInterval = 30 * KMilliToMicroSecondsFactor;

	__ASSERT_DEBUG(time >= KAnimationMinimumFrameInterval, RDebug::Print(_L("CBitmapAnim: frame interval was %d reset to %d."), time.Int(), KAnimationMinimumFrameInterval.Int()));

	time = Max(time, KAnimationMinimumFrameInterval);

	iAnimTimer->Cancel();

	iAnimTimer->After(time);

	DrawBitmap(aPreviousIndex);

	}

/**

 Flashes and draws the current frame.

@param aFlash ETrue for the animation to flash, otherwise EFalse.

*/

void CBitmapAnim::FlashFrame(TBool aFlash)

	{

	const TTimeIntervalMicroSeconds32 KFlashInterval = 1000;

	if (aFlash)

		{

		iFlags |= EFlashing;

		}

	else

		{

		iFlags &= ~EFlashing;

		}

	iFlashTimer->After(KFlashInterval);

	DrawBitmap();

	}

/**

 Notifies change of focus.

Overridden from virtual method CWindowAnim::FocusChanged(TBool aState).

@param aState Indicates whether the focus has or has not changed.

@see CWindowAnim::FocusChanged(TBool aState)

*/

void CBitmapAnim::FocusChanged(TBool aState)

	{

	if (aState)

		{

		iFlags &= ~EFrozen;

		if (IsRunning())

			{

			TRAP_IGNORE(DisplayNextFrameL());

			}

		}

	else

		{

		iFlags |= EFrozen;

		}

	}

/** Handles raw events.

Overridden from virtual method MEventHandler::OfferRawEvent().

This function does not handle the incoming events.

@param aRawEvent The raw event to be processed

@return ETrue if the raw event is handled by this function, EFalse if the function

chooses not to process it.

@see MEventHandler

*/

TBool CBitmapAnim::OfferRawEvent(const TRawEvent& /*aRawEvent*/)

	{

	return EFalse;

	}

/**

 Redraws the current animation frame and the background bitmap.

Overridden from virtual method CWindowAnim::Redraw().

@see CWindowAnim

*/

void CBitmapAnim::Redraw()

	{

	TWindowInfo parameter;

	WindowFunctions()->Parameters(parameter);

	const TRegion* redrawRegion;

	const TRegion* redrawShadowRegion;

	parameter.GetRedrawRegionAndRedrawShadowRegion(redrawRegion, redrawShadowRegion);

	// redraw the current animation frame if needed

	if (IsFrameDisplayable())

		{

		// redraw frame unless we're absolutely sure it doesn't need doing

		TRect currentFrameScreenRect = CalcFrameRect(iIndex);

		currentFrameScreenRect.Move(parameter.iScreenPos.iTl);

		if (FrameNeedsRedrawing(redrawRegion, currentFrameScreenRect) || FrameNeedsRedrawing(redrawShadowRegion, currentFrameScreenRect))

			{

			DrawBitmap(-1, ETrue);

			}

		}

	}

/**

 Resets the animation to be in a valid state every time a stop request occurs.

*/

void CBitmapAnim::ResetAnimation()

	{

	iIndex = -1;

	iNumberOfCycles = -1;

	iFlags &= ~(ERunning|EPlayForwards|EPlayBackwards);

	iFlags |= ENoBitmapWindowRestoring;

	}