// Copyright (c) 1995-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:

// Interface code for animated DLL's

// 

//

#include <e32std.h>

#include "server.h"

#include "gc.h"

#include "rootwin.h"

#include "windowgroup.h"

#include "ANIM.H"

#include "wstop.h"

#include "EVENT.H"

#include "ScrDev.H"

#include "offscreenbitmap.h"

#include "panics.h"

#include "wsfont.h"

GLREF_D CDebugLogBase *wsDebugLog;

static const TInt64 KFlashOnTime(700000);

static const TInt64 KFlashOffTime(300000);

static const TInt64 KOneSecond(1000000);

static const TInt64 KOneMinute(60 * KOneSecond);

static const TInt64 KOneDay(24 * 60 * 60 * KOneSecond);

static const TInt64 KOneHalfSecond(500000);

enum {EWindowUpdate=0x0001};

// Anim DLL code //

CWsAnimGc *CWsAnim::WsAnimGc=NULL;

void CWsAnim::InitStaticsL()

	{

	WsAnimGc=new (ELeave) CWsAnimGc();

	}

void CWsAnim::DeleteStatics()

	{

	delete WsAnimGc;

	WsAnimGc=NULL;

	}

CWsAnim::CWsAnim(CWsAnimDll *aDll) : iClient(aDll->WsOwner()), iAnimAddedInHandler(EFalse), iLastFrame(-1), iFlashOn(ETrue)

	{

	__DECLARE_NAME(_S("CWsAnim"));

	}

void CWsAnim::WindowClosing(CWsAnim *aWsAnim)

	{

	CWsAnim *anim=aWsAnim;

	CWsAnim *next;

	while(anim)

		{

		next=anim->iNextWin;

		CloseAnim(anim);

		anim=next;

		}

	}

void CWsAnim::CloseAnim(CWsAnim *aWsAnim)

	{

	TInt handle=aWsAnim->iAnimDll->AnimObjectHandle(aWsAnim);

	if (handle<0)

		delete aWsAnim;

	else

		aWsAnim->iAnimDll->Remove(handle);

	}

CWsAnim::~CWsAnim()

	{

	WsAnimGc->AnimDeleted(this);

	if (iWindow)	// In case it never got linked

		{

		CWsAnim **pAnim;

		for(pAnim= &iWindow->iAnimList;(*pAnim)!=this;pAnim= &(*pAnim)->iNextWin)

			{}

		*pAnim=iNextWin;

		}

	else if (iSprite)

		iSprite->iAnim=NULL;

	// force the anim for the event handler list.

	TWindowServerEvent::RemoveEventHandler(iAnim);

	TWindowServerEvent::RemoveNotificationHandler(iAnim);

	delete iAnim;

	TWindowServerEvent::PotentialEventHandlerL(-1);		//PotentialEventHandler cannot leave when passed a negative parameter.

	}

void CWsAnim::Connect(CWsClientWindow *aWindow)

	{

	if (iSprite)

		Panic();

	iWindow=aWindow;

	iNextWin=aWindow->iAnimList;

	aWindow->iAnimList=this;

	}

void CWsAnim::Connect(CWsSprite *aSprite)

	{

	if (iWindow)

		Panic();

	iSprite=aSprite;

	iSprite->iAnim=this;

	}

LOCAL_C void HandleLeaveInCWsAnimConstructL(TAny* aAnim)

	{

	STATIC_CAST(CWsAnim*,aAnim)->SetMessage(NULL);

	CWsAnim::UserDeactivateAnimGc();

	}

void CWsAnim::ConstructL(CAnim *aAnim, TAny *aArgs, CWsAnimDll *aAnimDll, TBool aIsWindow)

	{

	TBool isFocused=(iSprite!=NULL);

	if (!isFocused)

		isFocused=CWsTop::FocusWindowGroup()==iWindow->WinGroup();

	iAnimDll=aAnimDll;

	iAnimSync=ESyncNone;

	iAnim=aAnim;

	iAnim->iFunctions=this;

	SetMessage(&iClient->ClientMessage());

	CleanupStack::PushL(TCleanupItem(HandleLeaveInCWsAnimConstructL,this));

	if (aIsWindow)

		{

		CWindowAnim* windowAnim=WindowAnim();

		windowAnim->iWindowFunctions=this;

		windowAnim->iGc=WsAnimGc;

		windowAnim->ConstructL(aArgs, isFocused);

		}

	else

		{

		CSpriteAnim* spriteAnim=STATIC_CAST(CSpriteAnim*,iAnim);

		spriteAnim->iSpriteFunctions=this;

		spriteAnim->ConstructL(aArgs);

		}

	CleanupStack::PopAndDestroy(this); // doesn't really destroy "this" - it actually calls HandleLeaveInCWsAnimConstructL

	}

void CWsAnim::Redraw(CFbsBitGc * aGc, const TRegion *aRegion)

	{

	WS_ASSERT_DEBUG(iWindow,EWsPanicAnimHasNoWindow);

	if (!iWindow)

		return;

	TWindowInfo::TRegionPair regionPair;

	regionPair.iRegion1 = aRegion;

	regionPair.iRegion2 = NULL;

	iRedrawRegionPair = &regionPair;

	// We don't attempt to make use of iRect because it often isn't set up by the client code.

	// Work out which frame we are in:

	TTime now = iWindow->Screen()->Now();

	if (iLastFrame < 0)

		iStartTime = now;

	TInt64 elapsed = now.Int64() - iStartTime.Int64();

	TInt64 adjustedStart = iStartTime.Int64();

	TInt frame = 0;

	switch (iAnimSync)

		{

		case ESyncNone:

			if (iInterval > 0)

				{

				frame = elapsed / iInterval.Int64();

				}

				else

				{

				frame = -1;

				}

			break;

		case ESyncFlash:

			{

			TInt64 fraction = elapsed % (KFlashOnTime + KFlashOffTime);

			frame = (elapsed - fraction) / (KFlashOnTime + KFlashOffTime) * 2;

			if (fraction > KFlashOnTime)

				{

				frame = frame + 1;

				iFlashOn = EFalse;

				}

			else

				{

				iFlashOn = ETrue;

				}

			}

			break;

		case ESyncSecond:

			adjustedStart = iStartTime.Int64() - (iStartTime.Int64() % KOneSecond);

			elapsed = now.Int64() - adjustedStart;

			frame = elapsed / KOneSecond;

			break;

		case ESyncMinute:

			adjustedStart = iStartTime.Int64() - (iStartTime.Int64() % KOneMinute);

			elapsed = now.Int64() - adjustedStart;

			frame = elapsed / KOneMinute;

			break;

		case ESyncDay:

			adjustedStart = iStartTime.Int64() - (iStartTime.Int64() % KOneDay);

			elapsed = now.Int64() - adjustedStart;

			frame = elapsed / KOneDay;

			break;

		}

	// If the frame has changed, animate:

	if (frame != iLastFrame && frame != -1)

		{

		if (frame == iLastFrame + 1 && iLastFrame != -1)

			{

			Animate(NULL);

			}

		else

			{

			TDateTime dt = now.DateTime();

			Animate(&dt);

			}

		iLastFrame = frame;

		}

	// Regardless of whether we animated or not, redraw:

	WsAnimGc->Activate(iWindow, this, aRegion, aGc);	

	WindowAnim()->Redraw();

	WsAnimGc->Deactivate();

	// Schedule ourselves again (we usually only have to do this when we animate,

	// but it is possible for our scheduled rectangle to get lost in a redraw):

	TInt64 timeToNextFrame = 0;

	switch (iAnimSync)

		{

		case ESyncNone:

			if (iInterval > 0)

				{

				timeToNextFrame = iStartTime.Int64() + iInterval.Int64() * (frame + 1) - iWindow->Screen()->Now().Int64();

				}

			break;

		case ESyncFlash:

			if (iFlashOn)

				{

				timeToNextFrame = iStartTime.Int64() + (KFlashOnTime + KFlashOffTime) * frame / 2 + KFlashOnTime - iWindow->Screen()->Now().Int64();

				}

			else

				{

				timeToNextFrame = iStartTime.Int64() + (KFlashOnTime + KFlashOffTime) * (frame + 1 ) / 2 - iWindow->Screen()->Now().Int64();

				}

			break;

		case ESyncSecond:

			timeToNextFrame = adjustedStart + KOneSecond * (frame + 1) - iWindow->Screen()->Now().Int64();

			break;

		case ESyncMinute:

			timeToNextFrame = adjustedStart + KOneMinute * (frame + 1) - iWindow->Screen()->Now().Int64();

			break;

		case ESyncDay:

			timeToNextFrame = adjustedStart + KOneDay * (frame + 1) - iWindow->Screen()->Now().Int64();

			break;

		}

	if (iAnimSync != ESyncNone || iInterval > 0)

		{

		iWindow->Screen()->ScheduleAnimation(BestRect(), timeToNextFrame, 0, 0);

		}

	iRedrawRegionPair = NULL;				

	}

void CWsAnim::FocusChanged(TBool aNewFocusState)

	{

	WindowAnim()->FocusChanged(aNewFocusState);

	WsAnimGc->UserDeactivate();

	}

void CWsAnim::Animate(TDateTime *aDateTime)

	{

	iAnim->Animate(aDateTime);

	WsAnimGc->UserDeactivate();

	}

void CWsAnim::UserDeactivateAnimGc()

	{

	WsAnimGc->UserDeactivate();

	}

// Callback functions //

void CWsAnim::ActivateGc()

	{

	if (!iWindow)

		Panic();

	// Window animation drawing commands need to go through the render stage pipeline. This means

	// that drawing commands issued outside animation redraws (for instance, during Animate() or

	// when the animation receives a command) will mark the animation area as invalid, but the

	// commands themselves will be ignored as drawing will only happen during the next WSERV redraw

	// cycle (CWindowAnim::Redraw).

	// In this new situation MAnimWindowFunctions::ActivateGc doesn't need to activate the graphics

	// context (drawing commands issued outside CWindowAnim::Redraw are ignored), but to avoid some

	// behavior breaks (for instance, panic situations) we mark the GC as "activated by the user".

	WsAnimGc->UserActivate(iWindow, this);

	}

void CWsAnim::DeactivateGc()

	{

	if (!iWindow)

		Panic();

	// Window animation drawing commands need to go through the render stage pipeline. This means

	// that drawing commands issued outside animation redraws (for instance, during Animate() or

	// when the animation receives a command) will mark the animation area as invalid, but the

	// commands themselves will be ignored as drawing will only happen during the next WSERV redraw

	// cycle (CWindowAnim::Redraw).

	// In this new situation MAnimFreeTimerWindowFunctions::DeactivateGc just marks the animation

	// area as invalid so it gets redrawn later.

	WsAnimGc->UserDeactivate();

	}

/*

Because lots of animations don't set a rectangle, or set an empty one, we need

to make a best guess at what to use rather than assuming anything.

*/

TRect CWsAnim::BestRect() const

	{

	TRect rect;

	if (iRect.IsEmpty())

		{

		rect = iWindow->AbsRect();

		}

	else

		{

		rect = iRect;

		rect.Move(iWindow->Origin());

		rect.Intersection(iWindow->AbsRect());

		}

	return rect;

	}

void CWsAnim::Invalidate(const TRect &aRect)

	{

	if (!iWindow)

		{

		if (iSprite) 

			{

			iSprite->RootWindow()->InvalidateWholeScreen();

			}

		return;

		}

	iWindow->Redraw()->ClientExposing();

	TRect rect(aRect);

	rect.Move(iWindow->Origin());

	CWsTop::TriggerRedraws(iWindow->RootWindow());

	}

void CWsAnim::Update()

	{

	if (!iWindow)

		Panic();

	}

void CWsAnim::Parameters(TWindowInfo &aData)

	{

	if (!iWindow)

		Panic();

	aData.iScreenPos=iWindow->FullRect();

	aData.iMode=iWindow->DisplayMode();

	aData.iRegionPair=iRedrawRegionPair;

	}

void CWsAnim::VisibleRegion(TRegion& aRegion)

	{

	if(iWindow)

		{

		aRegion.Copy(iWindow->VisibleRegion());

		}

	}

void CWsAnim::SetSync(TAnimSync aSyncMode)

	{

	if (iAnimSync != aSyncMode)

		{

		iAnimSync=aSyncMode;	

		iLastFrame = -1;

		if (iAnimSync != ESyncNone)

			iWindow->Screen()->ScheduleAnimation(BestRect(),0,0,0);

		if (iAnimSync == ESyncFlash)

			iFlashOn = ETrue;

		}

	}

void CWsAnim::SetInterval(TInt aInterval)

	{

	if (iAnimSync!=ESyncNone)

		Panic();

	iLastFrame = -1;	

	if (aInterval < 0)

		aInterval = 0;

	// convert intervals to milliseconds (there are two intervals per second)

	iInterval = aInterval*KOneHalfSecond;

	if (iInterval > 0)

		{

		iWindow->Screen()->ScheduleAnimation(BestRect(),iInterval,0,0);

		}

	}

void CWsAnim::SetNextInterval(TInt aInterval)

	{

	if (iAnimSync!=ESyncNone)

		Panic();

	aInterval = (aInterval <= 0) ? 1 : aInterval; 

	iWindow->Screen()->ScheduleAnimation(BestRect(),aInterval*KOneHalfSecond,0,0);

	}

void CWsAnim::SetRect(const TRect &aRect)

	{

	if (!iWindow)

		Panic();

	iRect=aRect;

	iWindow->UpdateAnimArea(); // backed up windows only

	}

const TRect& CWsAnim::Rect() const

	{

	return(iRect);

	}

TDateTime CWsAnim::SystemTime() const

	{

	TDateTime dt=iWindow->Screen()->Now().DateTime();

	TInt hour=dt.Hour();

	TInt minute=dt.Minute();

	TInt second=dt.Second();

	TInt microSecond=dt.MicroSecond();

	switch(iAnimSync)

		{

	case ESyncDay:

		hour=0;

		minute=0;

		/*Fall through*/

	case ESyncMinute:

		second=0; 

		/*Fall through*/

	case ESyncNone:

	case ESyncFlash:

	case ESyncSecond:

		microSecond=0;

		break;

		}

	TDateTime dateTime;

	dateTime.Set(dt.Year(),dt.Month(),dt.Day(),hour,minute,second,microSecond);

	return(dateTime);

	}

TBool CWsAnim::FlashStateOn() const

	{

	return(iFlashOn);

	}

const RThread &CWsAnim::Client()

	{

	return(iClient->Client());

	}

void CWsAnim::ReplyBuf(const TDesC8 &aDes)

	{

	CWsClient::ReplyBuf(aDes);

	}

void CWsAnim::ReplyBuf(const TDesC16 &aDes)

	{

	CWsClient::ReplyBuf(aDes);

	}

void CWsAnim::Panic() const

	{

	iClient->PPanic(EWservPanicAnimDll);

	}

void CWsAnim::Panic(TClientPanic aPanic) const

	{

	iClient->PPanic(aPanic);

	}

const CFbsScreenDevice *CWsAnim::ScreenDevice()

	{

	CScreen* screen=NULL;		//To stop a warning

	if (iWindow)

		screen=iWindow->Screen();

	else if (iSprite)

		screen=iSprite->Screen();

	else

		Panic();

	return screen->ScreenDevice();

	}

CFbsFont *CWsAnim::DuplicateFontL(TInt aHandle)

	{

	CFbsFont *font=NULL;

	TInt err;

	font=CAnimFbsFont::NewL(aHandle,err);

	if (err!=KErrNone)

		{

		WS_ASSERT_DEBUG(font==NULL,EWsPanicFailedToInitialise);

		if (err==KErrNoMemory)

			User::Leave(err);

		iClient->PPanic(EWservPanicFont);

		}

	return(font);

	}

void CWsAnim::CloseFont(CFbsFont *aFont)

	{

	if (aFont)

		((CAnimFbsFont *)aFont)->Close();

	}

CFbsBitmap *CWsAnim::DuplicateBitmapL(TInt aHandle)

	{