// 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 "SpriteAnimation.h"

#include <w32std.h>

#include <coecntrl.h>

#include "AnimationDataProvider.h"

#include "AnimationConfig.h"

#include "SpriteAnimationClient.h"

#include "AnimationEvents.h"

#include "spriteanimationext.h"

_LIT(KAnimationServerDll, "AnimationServer.dll");

/**

Two stage constructor.

This creates and returns a new sprite animation.

@param aDataProvider The data provider from which the animation contents will

be obtained.  The animation takes ownership of this object

@param aPoint The starting position of the sprite in the window

@param aWsSession A session with the window server

@param aWindow The window in which to draw the animation

@param aObserver An optional receiver of animation events (such as errors)

@return The new object

*/

EXPORT_C CSpriteAnimation* CSpriteAnimation::NewL(CAnimationDataProvider* aDataProvider, const TPoint& aPoint, RWsSession& aWsSession, RWindow& aWindow, MAnimationObserver* aObserver)

	{

	return CSpriteAnimation::NewL(aDataProvider, aPoint, aWsSession, aWindow, aDataProvider->DataType(), aObserver);

	}

/**

Two stage constructor.

This is identical to the other NewL except that it allows an alternative data

type to be specified.  Unless you are trying to use a custom animator class

the other form of constructor should be used.

@param aDataProvider The data provider from which the animation contents will

be obtained.  The animation takes ownership of this object

@param aPoint The starting position of the sprite in the window

@param aWsSession A session with the window server

@param aWindow The window in which to draw the animation

@param aDataType Overrides the data type specified by the data provider

@param aObserver An optional receiver of animation events (such as errors)

@return The new object

*/

EXPORT_C CSpriteAnimation* CSpriteAnimation::NewL(CAnimationDataProvider* aDataProvider, const TPoint& aPoint, RWsSession& aWsSession, RWindow& aWindow, const TDesC8& aDataType, MAnimationObserver* aObserver)

	{

	CleanupStack::PushL(aDataProvider);

	CSpriteAnimation* self = new (ELeave) CSpriteAnimation(aDataProvider, aWsSession);

	CleanupStack::Pop(aDataProvider);

	CleanupStack::PushL(self);

	self->ConstructL(aPoint, aWindow, aDataType, aObserver);

	CleanupStack::Pop(self);

	return self;

	}

/**

Two stage constructor.

This creates and returns a new sprite animation.

@param aDataProvider The data provider from which the animation contents will

be obtained.  The animation takes ownership of this object

@param aPoint The starting position of the sprite in the window

@param aWsSession A session with the window server

@param aWindow The window in which to draw the animation

@param aObserver An optional receiver of animation events (such as errors)

@return The new object

*/

EXPORT_C CSpriteAnimation* CSpriteAnimation::NewL(CAnimationDataProvider* aDataProvider, const TPoint& aPoint, MAnimationObserver* aObserver, const CCoeControl* aHost)

	{

	return CSpriteAnimation::NewL(aDataProvider, aPoint, aDataProvider->DataType(), aObserver, aHost);

	}

/**

Two stage constructor.

This is identical to the other NewL except that it allows an alternative data

type to be specified.  Unless you are trying to use a custom animator class

the other form of constructor should be used.

@param aDataProvider The data provider from which the animation contents will

be obtained.  The animation takes ownership of this object

@param aPoint The starting position of the sprite in the window

@param aWsSession A session with the window server

@param aWindow The window in which to draw the animation

@param aDataType Overrides the data type specified by the data provider

@param aObserver An optional receiver of animation events (such as errors)

@return The new object

*/

EXPORT_C CSpriteAnimation* CSpriteAnimation::NewL(CAnimationDataProvider* aDataProvider, const TPoint& aPoint, const TDesC8& aDataType, MAnimationObserver* aObserver, const CCoeControl* aHost)

	{

	CleanupStack::PushL(aDataProvider);

	CSpriteAnimation* self = new (ELeave) CSpriteAnimation(aDataProvider, aObserver, aHost);

	CleanupStack::Pop(aDataProvider);

	CleanupStack::PushL(self);

	self->ConstructL(aPoint, aDataType);

	CleanupStack::Pop(self);

	return self;

	}

/** Destructor.*/

EXPORT_C CSpriteAnimation::~CSpriteAnimation()

	{

	delete iDataProvider;

	iDataProvider = NULL;

	if (iWsSprite)

		{

		iWsSprite->Close();

		delete iWsSprite;

		iWsSprite = NULL;

		}

		iAnimDll.Close();

	if (iClient)

		{

		delete iClient;

		iClient = NULL;

		}

	if(iSpriteAnimationExt)

		{

		delete iSpriteAnimationExt;

		iSpriteAnimationExt = NULL;

		}

	iObserver = NULL;	

	iWsSession = NULL;

	iHost = NULL;	

	}

EXPORT_C void CSpriteAnimation::SetHostL(const CCoeControl* aHost)

	{

	if (iHost)

		{

		Reset();

		}

	iHost = aHost;

	if (iHost)

		{

		InitializeL();

		}

	}

/** Implements CAnimation::Start.

@param aConfig Specifies run time attributes of the animation */

void CSpriteAnimation::Start(const TAnimationConfig& aConfig)

	{

	if (iFlags & EAnimationInitialized)

		{

		iClient->Start(aConfig);

		iWsSession->Flush();

		}

	}

/** Implements CAnimation::Stop.*/

void CSpriteAnimation::Stop()

	{

	if (iFlags & EAnimationInitialized)

		{

		iClient->Stop();

		iWsSession->Flush();

		}

	}

/** Implements CAnimation::Pause.*/

void CSpriteAnimation::Pause()

	{

	if (iFlags & EAnimationInitialized)

		{

		iClient->Pause();

		iWsSession->Flush();

		}

	}

/** Implements CAnimation::Resume.*/

void CSpriteAnimation::Resume()

	{

	if (iFlags & EAnimationInitialized)

		{

		iClient->Resume();

		iWsSession->Flush();

		}

	}

/** Implements CAnimation::Hold.*/

void CSpriteAnimation::Hold()

	{

	if (iFlags & EAnimationInitialized)

		{

		iClient->Hold();

		iWsSession->Flush();

		}

	}

/** Implements CAnimation::Unhold.*/

void CSpriteAnimation::Unhold()

	{

	if (iFlags & EAnimationInitialized)

		{

		iClient->Unhold();

		iWsSession->Flush();

		}

	}

/** Implements CAnimation::SetPosition.

@param aPoint The new coordinates of the animation (usually the top left corner) */

void CSpriteAnimation::SetPosition(const TPoint& aPoint)

	{

	if (iFlags & EAnimationInitialized)

		{

		iWsSprite->SetPosition(aPoint);

		iWsSession->Flush();

		}

	}

/** Implements CAnimation::Size */

EXPORT_C TSize CSpriteAnimation::Size() const

	{

	return (iFlags & EAnimationInitialized) ? iClient->Size() : TSize(0,0);

	}

/** Implements CAnimation::Freeze.*/

void CSpriteAnimation::Freeze()

	{

	if (iFlags & EAnimationInitialized)

		{

		iClient->Freeze();

		iWsSession->Flush();

		}

	}

/** Implements CAnimation::Unfreeze.*/

void CSpriteAnimation::Unfreeze()

	{

	if (iFlags & EAnimationInitialized)

		{

		iClient->Unfreeze();

		iWsSession->Flush();

		}

	}

CSpriteAnimation::CSpriteAnimation(CAnimationDataProvider* aDataProvider, MAnimationObserver* aObserver, const CCoeControl* aHost):

	iObserver(aObserver), 

	iDataProvider(aDataProvider),

	iHost(aHost), 

	iFlags(0)

	{

	}

// ConstructL called by the NewL functions that take a host argument		

void CSpriteAnimation::ConstructL(const TPoint& aPoint, const TDesC8& aDataType)

	{

	if (iHost)

		{

		iSpriteAnimationExt = CSpriteAnimationExt::NewL(aPoint,aDataType);

		InitializeL();

		}	

	}

void CSpriteAnimation::InitializeL()

	{

	CCoeEnv* controlEnv = iHost->ControlEnv();

	iWsSession = &controlEnv->WsSession();

	iWsSprite = new (ELeave) RWsSprite(*iWsSession);

	iAnimDll = RAnimDll(*iWsSession);

	iClient = new (ELeave) RSpriteAnimationClient(iAnimDll);

	User::LeaveIfError(iAnimDll.Load(KAnimationServerDll()));

	User::LeaveIfError(iWsSprite->Construct(*iHost->DrawableWindow(), iSpriteAnimationExt->iPoint, ESpriteNoChildClip|ESpriteNoShadows));

	TSpriteMember spriteMember;

	spriteMember.iBitmap = new (ELeave) CFbsBitmap();

	CleanupStack::PushL(spriteMember.iBitmap);

	TDisplayMode displayMode = controlEnv->ScreenDevice()->DisplayMode();

	User::LeaveIfError(spriteMember.iBitmap->Create(TSize(0,0), displayMode));

	spriteMember.iMaskBitmap = new (ELeave) CFbsBitmap();

	CleanupStack::PushL(spriteMember.iMaskBitmap);

	User::LeaveIfError(spriteMember.iMaskBitmap->Create(TSize(0,0), EGray256));

	iWsSprite->AppendMember(spriteMember);

	// We have a TDesC8 and we need to pass a TDesC8, but unfortunately the windows server is going

	// to be helpful by unpackaging the one we pass to it.  Packaging a variable length object seems

	// to require jumping through one or two hoops...

	// First, make a descriptor with a known type, instead of a reference to 'something':

	HBufC8* data = HBufC8::NewLC(iSpriteAnimationExt->iDataType.Length());

	*data = iSpriteAnimationExt->iDataType;

	// Second, make another descriptor large enough to hold the first one:

	TInt size = data->Size() + sizeof(HBufC8) - sizeof(TText8);

	HBufC8* datadesc = HBufC8::NewLC(size);

	datadesc->Des().Copy(static_cast<TUint8*>(static_cast<TAny*>(data)), size);

	// Finally, pass the outer descriptor to the server:

	iClient->ConstructL(*iWsSprite, datadesc->Des(), reinterpret_cast<TInt>(iObserver));

	CleanupStack::PopAndDestroy(2, data); // the data descriptors.

	CleanupStack::PopAndDestroy(2, spriteMember.iBitmap); //bitmap and mask

	iDataProvider->SetObserver(this);

	iDataProvider->StartL();

	iFlags |= EAnimationInitialized;

	}

void CSpriteAnimation::Reset()

	{

	iFlags |= (~EAnimationInitialized);

	iWsSession = NULL;

	if (iWsSprite)

		{

		iWsSprite->Close();

		delete iWsSprite;

		iWsSprite = NULL;

		}

		iAnimDll.Close();

	if (iClient)

		{

		iClient->Close();

		delete iClient;

		iClient = NULL;

		}

	if(iSpriteAnimationExt)

		{

		delete iSpriteAnimationExt;

		iSpriteAnimationExt = NULL;

		}

	}

void CSpriteAnimation::DataProviderEventL(TInt aEvent, TAny* aData, TInt aDataSize)

	{

	if (!(aEvent & ~EAnimationReservedEvents))

		{

		switch(aEvent)

			{

			case EAnimationDataChanged:

				iDataProvider->StartL();

				break;

			case EAnimationDataProviderError:

				if (iObserver)

					{

					iObserver->AnimationEvent(*this, MAnimationObserver::EDataProviderError, aData);

					}

				break;

			default:

				User::Leave(KErrNotSupported);

			}

		}

	iClient->SendEventL(aEvent, aData, aDataSize);

	}

CSpriteAnimation::CSpriteAnimation(CAnimationDataProvider* aDataProvider, RWsSession& aWsSession) :

iWsSession(&aWsSession),

iAnimDll(aWsSession)

	{

	iDataProvider = aDataProvider;

	}

// ConstructL called by the NewL functions that don't take a host argument

void CSpriteAnimation::ConstructL(const TPoint& aPoint, RWindow& aWindow, const TDesC8& aDataType, MAnimationObserver* aObserver)

	{

	iWsSprite = new (ELeave) RWsSprite(*iWsSession);

	iClient = new (ELeave) RSpriteAnimationClient(iAnimDll);

	User::LeaveIfError(iAnimDll.Load(KAnimationServerDll()));

	User::LeaveIfError(iWsSprite->Construct(aWindow, aPoint, ESpriteNoChildClip|ESpriteNoShadows));

	iObserver = aObserver;

	TSpriteMember spriteMember;

	spriteMember.iBitmap = new (ELeave) CFbsBitmap();

	CleanupStack::PushL(spriteMember.iBitmap);

	User::LeaveIfError(spriteMember.iBitmap->Create(TSize(0,0), aWindow.DisplayMode()));

	spriteMember.iMaskBitmap = new (ELeave) CFbsBitmap();

	CleanupStack::PushL(spriteMember.iMaskBitmap);

	User::LeaveIfError(spriteMember.iMaskBitmap->Create(TSize(0,0), EGray256));

	iWsSprite->AppendMember(spriteMember);

	// We have a TDesC8 and we need to pass a TDesC8, but unfortunately the windows server is going

	// to be helpful by unpackaging the one we pass to it.  Packaging a variable length object seems

	// to require jumping through one or two hoops...

	// First, make a descriptor with a known type, instead of a reference to 'something':

	HBufC8* data = HBufC8::NewLC(aDataType.Length());

	*data = aDataType;

	// Second, make another descriptor large enough to hold the first one:

	TInt size = data->Size() + sizeof(HBufC8) - sizeof(TText8);

	HBufC8* datadesc = HBufC8::NewLC(size);

	datadesc->Des().Copy(static_cast<TUint8*>(static_cast<TAny*>(data)), size);

	// Finally, pass the outer descriptor to the server:

	iClient->ConstructL(*iWsSprite, datadesc->Des());

	CleanupStack::PopAndDestroy(2, data); // the data descriptors.

	CleanupStack::PopAndDestroy(2, spriteMember.iBitmap); //bitmap and mask

	iDataProvider->SetObserver(this);

	iDataProvider->StartL();

	iFlags |= EAnimationInitialized;

	}

/** Reserved for future use */

EXPORT_C void CSpriteAnimation::CSpriteAnimation_Reserved2()

	{

	}