// 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 "SpriteAnimationServer.h"
#include "AnimationCmd.h"
#include "Animator.h"
#include "AnimationConfig.h"
#include "AnimationTls.h"
#include "AnimationTicker.h"

// Creates a CSpriteAnimationServer and returns a pointer to the object.
CSpriteAnimationServer* CSpriteAnimationServer::NewL()
	{
	CSpriteAnimationServer* self = new (ELeave) CSpriteAnimationServer();
	return self;
	}

CSpriteAnimationServer::~CSpriteAnimationServer()
	{
	iFunctions->GetRawEvents(EFalse);
	while (iFreezeCount > 0)
		{
		--iFreezeCount;
		iTls->Ticker()->Unfreeze();
		}
	delete iAnimator;
	delete iSpriteGc;
	delete iBitmapDevice;
	delete iMaskDevice;
	delete iDataType;
	if (iTls)
		iTls->Close();
	}

CSpriteAnimationServer::CSpriteAnimationServer()
	{
	}

void CSpriteAnimationServer::ConstructL(TAny* aArgs)
	{
	iTls = CAnimationTls::NewL();
	HBufC8* data = static_cast<HBufC8*>(aArgs);
	iDataType = HBufC8::NewL(data->Length());
	*iDataType = *data;
	iSpriteGc = CFbsBitGc::NewL();
	iAnimator = CAnimator::NewL(this);
	}

// Pure virtual function from CAnim.
void CSpriteAnimationServer::Command(TInt aOpcode, TAny* aArgs)
	{
	switch (aOpcode)
		{
		case EAnimationCmdStart:
			iAnimator->Start(*(static_cast<TAnimationConfig*>(aArgs)));
			break;
		case EAnimationCmdStop:
			iAnimator->Stop();
			break;
		case EAnimationCmdPause:
			iAnimator->Pause();
			break;
		case EAnimationCmdResume:
			iAnimator->Resume();
			break;
		case EAnimationCmdHold:
			iAnimator->Hold();
			break;
		case EAnimationCmdUnhold:
			iAnimator->Unhold();
			break;
		case EAnimationCmdFreeze:
			++iFreezeCount;
			iTls->Ticker()->Freeze();
			break;
		case EAnimationCmdUnfreeze:
			--iFreezeCount;
			iTls->Ticker()->Unfreeze();
			break;
		case EAnimationCmdHostHandle:
			iHostHandle = *(static_cast<TInt*>(aArgs));
			break;
		}
	}

// Pure virtual function from CAnim it handles the command received by the related 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 CSpriteAnimationServer::CommandReplyL(TInt aOpcode, TAny* aArgs)
	{
	TInt error = KErrNone;
	switch (aOpcode)
		{
		case EAnimationCmdDataEvent:
			ReceiveEventL(aArgs);
			break;
		case EAnimationCmdSize:
			error = ((iSize.iWidth & ((1 << 15)-1)) << 16) | (iSize.iHeight & ((1 << 15)-1));
			break;
		default:
			error = KErrNotSupported;
		}
	return error;
	}

void CSpriteAnimationServer::ReceiveEventL(TAny* aArgs)
	{
	TInt aEvent;
	TAny* aData;
	TInt aDataLength;
	aEvent = *(TInt*)aArgs;
	aDataLength = *(((TInt*)aArgs) + 1);
	aData = (((TInt*)aArgs) + 2);
	iAnimator->DataEventL(aEvent, aData, aDataLength);
	}

void CSpriteAnimationServer::Animate(TDateTime* /*aDateTime*/)
	{ // Empty implementation
	}

TBool CSpriteAnimationServer::OfferRawEvent(const TRawEvent& /*aRawEvent*/)
	{
	return EFalse;
	}

void CSpriteAnimationServer::PostHostEvent()
	{
	const TInt KUiqDummyKeyCode = 0xBABE;
	TKeyEvent event;
	event.iCode = KUiqDummyKeyCode ;
	event.iScanCode = KUiqDummyKeyCode ;
	event.iModifiers = 0;
	event.iRepeats = 0;
	iFunctions->PostKeyEvent(event);
	}


void CSpriteAnimationServer::AnimatorDraw()
	{
	if(iSpriteFunctions->SpriteCanBeSeen())
		{
		if(iFlags & EVirtualHold)
			{
			iFlags &= ~EVirtualHold;
			iAnimator->Hold();
			iAnimator->Unhold();
			}
		else
			{
			iSpriteGc->Activate(iBitmapDevice);
			iAnimator->Draw(*iSpriteGc);
			iSpriteGc->Activate(iMaskDevice);
			iAnimator->DrawMask(*iSpriteGc);

			iSpriteFunctions->UpdateMember(0, iSize, ETrue);
			}
		}
	else
		{
		// Virtual hold exists because if we actually hold the animator, we would no longer receive
		// calls to AnimatorDraw, and so we would never unhold it.
		iFlags |= EVirtualHold;
		}
	}

void CSpriteAnimationServer::AnimatorInitialisedL(const TSize& aSize)
	{
	iSize = aSize;
	TSpriteMember& spriteMember = *iSpriteFunctions->GetSpriteMember(0);
	spriteMember.iBitmap->Resize(iSize);
	spriteMember.iMaskBitmap->Resize(iSize);
	iSpriteFunctions->SizeChangedL();

	delete iBitmapDevice;
	iBitmapDevice = NULL;
	delete iMaskDevice;
	iMaskDevice = NULL;
	iBitmapDevice = CFbsBitmapDevice::NewL(spriteMember.iBitmap);
	iMaskDevice = CFbsBitmapDevice::NewL(spriteMember.iMaskBitmap);

	iSpriteGc->Activate(iMaskDevice);
	iSpriteGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	iSpriteGc->SetBrushColor(KRgbBlack);
	iSpriteGc->DrawRect(iSize);
	iSpriteFunctions->UpdateMember(0, iSize, ETrue);

	iFunctions->GetRawEvents(ETrue);
	iSpriteFunctions->Activate(ETrue);
	
	PostHostEvent();
	}
	
void CSpriteAnimationServer::AnimatorResetL()
	{
	iSize.iWidth = 0;
	iSize.iHeight = 0;

	TSpriteMember& spriteMember = *iSpriteFunctions->GetSpriteMember(0);
	spriteMember.iBitmap->Resize(iSize);
	spriteMember.iMaskBitmap->Resize(iSize);
	iSpriteFunctions->SizeChangedL();
	
	iSpriteFunctions->Activate(EFalse);
	iFunctions->GetRawEvents(EFalse);
	delete iBitmapDevice;
	iBitmapDevice = NULL;
	delete iMaskDevice;
	iMaskDevice = NULL;
	iFlags = 0;
	}
	
const TPtrC8 CSpriteAnimationServer::AnimatorDataType() const
	{
	return *iDataType;
	}

CAnimationTicker& CSpriteAnimationServer::AnimatorTicker()
	{
	return *iTls->Ticker();
	}