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

 #include "wsfont.h"

 #include "pointer.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 //

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

 	{

 	__DECLARE_NAME(_S("CWsAnim"));

 	iBitFlags.Set(EFlashOn);

 	}

 void CWsAnim::WindowClosing(CWsAnim *aWsAnim)

 	{

 	CWsAnim *anim=aWsAnim;

 	CWsAnim *next;

 	while(anim)

 		{

 		next=anim->iNextWin;

 		CloseAnim(anim);

 		anim=next;

 		}

 	}

 void CWsAnim::CloseAnim(CWsAnim *aWsAnim)

 	{

 	if(aWsAnim)

 		{

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

 		if (handle<0)

 			delete aWsAnim;

 		else

 			aWsAnim->iAnimDll->Remove(handle);

 		}

 	}

 CWsAnim::~CWsAnim()

 	{

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

 		{

 		iWindow->SetupVisibleRegionTracking(EFalse);

 		MWsWindowTreeObserver* windowTreeObserver = iClient->Screen()->WindowTreeObserver();

 		if (windowTreeObserver && (iBitFlags.IsSet(EWinAnimConstructed)))

 			{

 			windowTreeObserver->NodeReleased(*this);

 			iBitFlags.Clear(EWinAnimConstructed);

 			}

 		CWsAnim **pAnim;

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

 			{}

 		*pAnim=iNextWin;

 		}

 	else if (iSprite)

 		{

 		// coverity[extend_simple_error]

 		iSprite->iAnim=NULL;

 		iSprite->SetHasAnimation(EFalse);

 		if(iSprite->Win())

 			iSprite->Win()->SetupVisibleRegionTracking(EFalse);

 		}

 	// force the anim for the event handler list.

 	TWindowServerEvent::RemoveEventHandler(Anim());

 	TWindowServerEvent::RemoveNotificationHandler(Anim());

 	delete iAnim.iWindowAnim;

 	delete iAnimGc;

 	// coverity[extend_simple_error]

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

 	}

 void CWsAnim::Connect(CWsClientWindow *aWindow)

 	{

 	//coverity[var_compare_op]

 	WS_ASSERT_DEBUG(aWindow,EWsPanicWindowNull);

 	if ((iSprite))

 		Panic();

 	iWindow=aWindow;

 	iNextWin=aWindow->iAnimList;

 	aWindow->iAnimList=this;

 	iBitFlags.Assign(EAdvancedPointersEnabled, aWindow->AdvancedPointersEnabled());

 	iWindow->SetupVisibleRegionTracking(ETrue);

 	}

 void CWsAnim::Connect(CWsSprite *aSprite)

 	{

 	WS_ASSERT_DEBUG(aSprite,EWsPanicNoSprite);

 	if (iWindow)

 		Panic();

 	iSprite=aSprite;

 	iSprite->iAnim=this;

 	iSprite->SetHasAnimation(ETrue);

 	iBitFlags.Assign(EAdvancedPointersEnabled, aSprite->AdvancedPointersEnabled());

 	if(iSprite->Win())

 		{

 		iSprite->Win()->SetupVisibleRegionTracking(ETrue);

 		}

 	}

 LOCAL_C void HandleLeaveInCWsAnimConstructL(TAny* aAnim)

 	{

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

 	STATIC_CAST(CWsAnim*,aAnim)->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;

 	if(!aAnim)

 	    {

 	    RDebug::Printf("CreateInstanceL did not create an anim instance.");

 	    Panic();

 	    }

 	aAnim->iFunctions=this;

 	SetMessage(&iClient->ClientMessage());

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

 	if (aIsWindow)

 		{

 		iAnim.iWindowAnim = static_cast<CWindowAnim*>(aAnim);

 		iAnimGc = new (ELeave) CWsAnimGc(*this);

 		iAnim.iWindowAnim->iWindowFunctions=this;

 		iAnim.iWindowAnim->iGc=iAnimGc;

 		iAnim.iWindowAnim->ConstructL(aArgs, isFocused);

 		iBitFlags.Set(EWinAnimConstructed);

 		WS_ASSERT_DEBUG(iClient->Screen(), EWsPanicNoScreen);

 		if (iClient->Screen())

 			{

 			MWsWindowTreeObserver* windowTreeObserver = iClient->Screen()->WindowTreeObserver();

 			if (windowTreeObserver)

 				{

 				windowTreeObserver->NodeCreated(*this, ParentNode());

 				const TRect rect = BestRect();

 				windowTreeObserver->NodeExtentChanged(*this, rect);

 				windowTreeObserver->NodeActivated(*this); //window-anim inherits activate status from iWindow

 				}

 			}

 		}

 	else

 		{

 		iAnim.iSpriteAnim = static_cast<CSpriteAnim*>(aAnim);

 		iAnim.iSpriteAnim->iSpriteFunctions=this;

 		iAnim.iSpriteAnim->ConstructL(aArgs);

 		}

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

 	}

 /**

 This function should only be called in the context of a redraw (i.e. CScreenRedraw::OnAnimation) 

 @panic EWsPanicAnim will be raised in debug build if this function is called in the wrong context.

 */

 void CWsAnim::RedrawWindowAnimL(const TTime& aTimeNow, MWsGraphicsContext* aGc, const TRegion* aRegion)

 	{

 	WS_ASSERT_DEBUG(iWindow, EWsPanicAnimHasNoWindow);

 	WS_ASSERT_DEBUG(iWindow->Screen(), EWsPanicNoScreen);

 	WS_ASSERT_DEBUG(iWindow->Screen()->IsAnimating(), EWsPanicAnim);

 	iBitFlags.Set(EInRedraw);

 	TInt frame;

 	TInt64 adjustedStart;

 	 // Don't call AnimateL() on CFreeTimerWindowAnim animations

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

 	    {

 	    AnimateL(aTimeNow, frame, adjustedStart);

 	    }

 	RedrawWindowAnimL(aGc, aRegion);

 	ReSchedule(aTimeNow, frame, adjustedStart);

 	iBitFlags.Clear(EInRedraw);

 	}

 /**

 This function should only be called in the context of a redraw (i.e. CScreenRedraw::OnAnimation)

 @panic EWsPanicAnim will be raised in debug build if this function is called in the wrong context. 

 */

 void CWsAnim::AnimateSpriteAnimL(const TTime& aTimeNow)

 	{

 	WS_ASSERT_DEBUG(iSprite, EWsPanicNoSprite);

 	WS_ASSERT_DEBUG(iSprite->Screen(), EWsPanicNoScreen);

     WS_ASSERT_DEBUG(iSprite->Screen()->IsAnimating(), EWsPanicAnim);

     iBitFlags.Set(EInRedraw);

 	TInt frame;

 	TInt64 adjustedStart;

 	AnimateL(aTimeNow, frame, adjustedStart);

 	ReSchedule(aTimeNow, frame, adjustedStart);

 	iBitFlags.Clear(EInRedraw);

 	}

 void CWsAnim::AnimateL(const TTime& aTimeNow, TInt& aFrame, TInt64& aAdjustedStart)

 	{

 	// Work out which frame we are in:

 	if (iLastFrame < 0)

 		iStartTime = aTimeNow;

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

 	aAdjustedStart = iStartTime.Int64();

 	aFrame = 0;

 	switch (iAnimSync)

 		{

 		case ESyncNone:

 			if (iInterval > 0)

 				{

 				aFrame = elapsed / iInterval.Int64();

 				}

 				else

 				{

 				aFrame = -1; //This would be a CFreeTimerWindowAnim

 				}

 			break;

 		case ESyncFlash:

 			{

 			TInt64 fraction = elapsed % (KFlashOnTime + KFlashOffTime);

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

 			if (fraction > KFlashOnTime)

 				{

 				aFrame += 1;

 				iBitFlags.Clear(EFlashOn);

 				}

 			else

 				{

 				iBitFlags.Set(EFlashOn);

 				}

 			}

 			break;

 		case ESyncSecond:

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

 			elapsed = aTimeNow.Int64() - aAdjustedStart;

 			aFrame = elapsed / KOneSecond;

 			break;

 		case ESyncMinute:

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

 			elapsed = aTimeNow.Int64() - aAdjustedStart;

 			aFrame = elapsed / KOneMinute;

 			break;

 		case ESyncDay:

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

 			elapsed = aTimeNow.Int64() - aAdjustedStart;

 			aFrame = elapsed / KOneDay;

 			break;

 		}

 	// If the frame has changed, animate:

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

 		{

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

 			{

 			Animate(NULL); //This can leave

 			}

 		else

 			{

 			TDateTime dt = aTimeNow.DateTime();

 			Animate(&dt);

 			}

 		iLastFrame = aFrame;

 		}

 	}

 void CWsAnim::RedrawWindowAnimL(MWsGraphicsContext * aGc, const TRegion *aRegion)

 	{

 	WS_ASSERT_DEBUG(iWindow,EWsPanicAnimHasNoWindow);

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

 	TWindowInfo::TRegionPair regionPair;

 	regionPair.iRegion1 = aRegion;

 	regionPair.iRegion2 = NULL;

 	iRedrawRegionPair = &regionPair;

 	if(iWindow && iAnim.iWindowAnim)

 		{

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

 		iAnimGc->Activate(aRegion, aGc);

 		iAnim.iWindowAnim->Redraw();	//This can leave

 		iAnimGc->Deactivate();

 		}

 	iRedrawRegionPair = NULL;				

 	}

 void CWsAnim::ReSchedule(const TTime& aTimeNow, const TInt& aFrame, const TInt64& aAdjustedStart)

 	{

 	// 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() * (aFrame + 1) - aTimeNow.Int64();

 				}

 			break;

 		case ESyncFlash:

 			if (iBitFlags.IsSet(EFlashOn))

 				{

 				timeToNextFrame = iStartTime.Int64() + (KFlashOnTime + KFlashOffTime) * aFrame / 2 + KFlashOnTime - aTimeNow.Int64();

 				}

 			else

 				{

 				timeToNextFrame = iStartTime.Int64() + (KFlashOnTime + KFlashOffTime) * (aFrame + 1 ) / 2 - aTimeNow.Int64();

 				}

 			break;

 		case ESyncSecond:

 			timeToNextFrame = aAdjustedStart + KOneSecond * (aFrame + 1) - aTimeNow.Int64();

 			break;

 		case ESyncMinute:

 			timeToNextFrame = aAdjustedStart + KOneMinute * (aFrame + 1) - aTimeNow.Int64();

 			break;

 		case ESyncDay:

 			timeToNextFrame = aAdjustedStart + KOneDay * (aFrame + 1) - aTimeNow.Int64();

 			break;

 		}

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

 		{

 		ScheduleSelf(timeToNextFrame);

 		}

 	}

 /**

 Mark the animation area as invalid so it gets redrawn later. 

 */

 void CWsAnim::ScheduleSelf(const TTimeIntervalMicroSeconds& aFrom)

 	{

 	ASSERT( (iWindow && iAnim.iWindowAnim) || (iSprite && iAnim.iSpriteAnim) );

 	if(iWindow && iAnim.iWindowAnim)

 		{

 		WS_ASSERT_DEBUG(iWindow->Screen(), EWsPanicNoScreen);

 		const TRect rect = BestRect();

 		iWindow->Screen()->ScheduleAnimation(EWindowAnim, rect, aFrom, 0, 0, iWindow);

 		}

 	else if(iSprite && iAnim.iSpriteAnim)

 		{

 		WS_ASSERT_DEBUG(iSprite->Screen(), EWsPanicNoScreen);

 		const TRect rect = iSprite->Rect();

 		if(iSprite->Win())

 			iSprite->Screen()->ScheduleAnimation(ESpriteAnim, rect, aFrom, 0, 0, iSprite->Win());

 		else

 			iSprite->Screen()->ScheduleAnimation(EFloatingSpriteAnim, rect, aFrom, 0, 0, NULL);

 		}

 	}

 void CWsAnim::UserDeactivateAnimGc()

 	{

 	if (iAnimGc) // For sprite anims iAnimGc is NULL

 	    {

         //If we have been receiving draw commands outside the context of 

 	    //CScreenRedraw::OnAnimation, then we need to schedule a redraw.

 	    if (iAnimGc->IsActive() && iBitFlags.IsClear(EInRedraw))

 	         {

 	         ScheduleSelf(0);

 	         }

 	    iAnimGc->UserDeactivate();

 	    }

 	}

 void CWsAnim::FocusChanged(TBool aNewFocusState)

 	{

 	WS_ASSERT_DEBUG(iWindow && iAnimGc && iAnim.iWindowAnim,EWsPanicAnim);

 	iAnim.iWindowAnim->FocusChanged(aNewFocusState);

 	UserDeactivateAnimGc();

 	}

 void CWsAnim::Animate(TDateTime *aDateTime)

 	{

 	WS_ASSERT_DEBUG(Anim(),EWsPanicAnim);

 	Anim()->Animate(aDateTime);

 	UserDeactivateAnimGc();

 	}

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

 	iAnimGc->UserActivate();

 	}

 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.

 	UserDeactivateAnimGc();

 	}

 /*

 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

 	{

 	WS_ASSERT_DEBUG(iWindow,EWsPanicAnimHasNoWindow);

 	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)

 			ScheduleSelf(0);

 		if (iAnimSync == ESyncFlash)

 			iBitFlags.Set(EFlashOn);

 		}

 	}

 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)

 		{

 		ScheduleSelf(iInterval);

 		}

 	}

 void CWsAnim::SetNextInterval(TInt aInterval)

 	{

 	if (iAnimSync!=ESyncNone)

 		Panic();

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

 	ScheduleSelf(aInterval*KOneHalfSecond);

 	}

 void CWsAnim::SetRect(const TRect &aRect)

 	{

 	if (!iWindow)

 		Panic();

 	if (iRect != aRect)

 		{

 		iRect=aRect;

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

 		MWsWindowTreeObserver* windowTreeObserver = iClient->Screen()->WindowTreeObserver();

 		if (windowTreeObserver && iBitFlags.IsSet(EWinAnimConstructed))

 			{

 			const TRect rect = BestRect();

 			windowTreeObserver->NodeExtentChanged(*this, rect);

 			}

 		}

 	}

 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(iBitFlags.IsSet(EFlashOn));

 	}

 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::SessionPanic() const

 	{

 	iClient->SessionPanic(EWservPanicAnimDll);

 	}

 void CWsAnim::Panic() const

 	{

 	iClient->PPanic(EWservPanicAnimDll);

 	}

 void CWsAnim::Panic(TClientPanic aPanic) const

 	{

 	iClient->PPanic(aPanic);

 	}

 void CWsAnim::SendState(MWsWindowTreeObserver& aWindowTreeObserver) const

 	{

 	if(iNextWin)

 		iNextWin->SendState(aWindowTreeObserver);

 	if(iBitFlags.IsSet(EWinAnimConstructed))

 		{

 		aWindowTreeObserver.NodeCreated(*this, ParentNode());

 		const TRect rect = BestRect();

 		aWindowTreeObserver.NodeExtentChanged(*this, rect);

 		aWindowTreeObserver.NodeActivated(*this); //window-anim inherits activate status from iWindow

 		}

 	}

 const CFbsScreenDevice *CWsAnim::ScreenDevice()

 	{

 	return NULL; // Deprecated by PREQ 2095

 	}

 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)

 	{

 	CFbsBitmap *bitmap=new(ELeave) CFbsBitmap();

 	TInt err=bitmap->Duplicate(aHandle);

 	if (err!=KErrNone)

 		{

 		delete bitmap;

 		if (err==KErrNoMemory)

 			User::Leave(err);

 		iClient->PPanic(EWservPanicBitmap);

 		}

 	return(bitmap);

 	}

 TSize CWsAnim::WindowSize() const

 	{

 	if (!iWindow)

 		Panic();

 	return(iWindow->Size());

 	}

 TBool CWsAnim::IsHidden()

 	{

 	if (!iWindow)

 		Panic();

 	return iWindow->IsHidden();

 	}

 void CWsAnim::SetVisible(TBool aState)

 	{	

 	//The (iAnimGc->IsActive() && aState) part of the below if statement is in place to accomodate bc with 

 	//the original wserv. 

 	//We panic when we call SetVisible(ETrue) and the CWsAnimGc has been activated because the origininal wserv did.

 	//We don't panic when we call SetVisible(EFalse) and the CWsAnimGc is activated because the original wserv didn't.

 	if( !iWindow || (iAnimGc->IsActive() && aState) )

 		{

 		Panic();	

 		}

 	iWindow->SetVisible(aState);

 	STACK_REGION region;

 	VisibleRegion(region);

 	TRect rect = region.BoundingRect();

 	region.Close();

 	if(!rect.IsEmpty())

 		iWindow->Screen()->ScheduleAnimation(EWindowAnim, rect,0,0,0, iWindow);

 	}

 MAnimGeneralFunctions::TAnimSync CWsAnim::Sync() const

 	{

 	return(iAnimSync);

 	}

 void CWsAnim::GetRawEvents(TBool aGetEvents) const

 	{

 	if (aGetEvents)

 		{

 		if (!iAnimAddedInHandler)

 			{

 			TWindowServerEvent::AddEventHandler(Anim(), iBitFlags.IsSet(EAdvancedPointersEnabled));

 			iAnimAddedInHandler = ETrue;

 			}

 		}

 	else

 		{

 		if (iAnimAddedInHandler)

 			{

 			TWindowServerEvent::RemoveEventHandler(Anim());

 			iAnimAddedInHandler = EFalse;

 			}

 		}

 	}

 void CWsAnim::PostRawEvent(const TRawEvent &aRawEvent) const

 	{

 	// Cannot remove const from aRawEvent parameter type for compatibility reasons.

 	if (TWsPointer::PreProcessClientEvent(const_cast<TRawEvent &>(aRawEvent), iBitFlags.IsSet(EAdvancedPointersEnabled)))

 		{

 		TWindowServerEvent::ProcessRawEvent(aRawEvent);

 		}

 	}

 void CWsAnim::PostKeyEvent(const TKeyEvent &aRawEvent) const

 	{

 	TWindowServerEvent::ProcessKeyEvent(aRawEvent,0);

 	}

 /**

 Generate repeated key events. 

 */	

 void CWsAnim::PostKeyEvent(const TKeyEvent& aRawEvent, TInt aRepeats) const

 	{

 	TWindowServerEvent::ProcessKeyEvent(aRawEvent,aRepeats);

  	}

 TInt CWsAnim::RegisterForNotifications(TUint32 aNotifications)

 	{

 	if (aNotifications)

 		{

 		return TWindowServerEvent::AddNotificationHandler(Anim(),aNotifications);

 		}

 	else

 		{

 		TWindowServerEvent::RemoveNotificationHandler(Anim());

 		return KErrNone;

 		}

 	}

 const RMessagePtr2* CWsAnim::Message()

 	{

 	return iMessage;

 	}

 void CWsAnim::SetMessage(const RMessagePtr2* aMessage)

 	{

 	iMessage=aMessage;

 	}

 TInt CWsAnim::CommandReply(TInt aOpcode, TAny* aArgs)

 	{

 	SetMessage(&iClient->ClientMessage()); // ClientMessage returns a reference, so taking the address of it is okay (it it returned it by value, then taking the address would be taking the address of a temporary which would be dodgey)

 	TInt returnValue=0;

 	TRAP(returnValue,returnValue=Anim()->CommandReplyL(aOpcode, aArgs));

 	SetMessage(NULL);

 	return returnValue;

 	}

 TSpriteMember *CWsAnim::GetSpriteMember(TInt aMember) const

 	{

 	if (!iSprite)

 		Panic();

 	return REINTERPRET_CAST(TSpriteMember*,&(*iSprite->iMembers)[aMember]->iBitmap);		//The 2 classes involved in the cast have exactly the same data members in the same order

 	}

 void CWsAnim::UpdateMember(TInt aMember,const TRect& aRect,TBool aFullUpdate)

 	{

 	if (!iSprite)

 		Panic();

 	iSprite->Update(aMember,aRect,aFullUpdate);

 	}

 void CWsAnim::Activate(TBool aActive)

 	{

 	if (!iSprite)

 		Panic();

 	if (!aActive)

 		iSprite->Deactivate();

 	else

 		{

 		if (iSprite->IsActive())

 			Panic();

 		iSprite->Activate();

 		}

 	}

 void CWsAnim::SizeChangedL()

 	{

 	if (!iSprite)

 		Panic();

 	iSprite->CWsSpriteBase::CompleteL();

 	}

 void CWsAnim::SetPosition(const TPoint &aPos)

 	{

 	iSprite->SetPos(aPos);

 	}

 TAny* CWsAnim::ExtendedInterface(TInt aInterface)

 	{

 	switch(aInterface)

 		{

 	case ENumberOfExtendedInterfaces:

 		return reinterpret_cast<TAny*>(EInterfaceCount-1);

 	case EWindowExtensionInterface:

 		return static_cast<MAnimGeneralFunctionsWindowExtension*>(this);

 	case EEventExtentionInterface:

 		return static_cast<MAnimGeneralFunctionsEventExtension*>(this);

 	default:

 		return NULL;

 		}

 	}

 TInt CWsAnim::Screens() const

 	{

 	return CWsTop::NumberOfScreens();

 	}

 TInt CWsAnim::FocusScreens() const

 	{

 	return CWsTop::CurrentFocusScreen()->ScreenNumber();

 	}

 void CWsAnim::SetFocusScreen(TInt aScreenNo)

  	{

  	if (aScreenNo<CWsTop::NumberOfScreens() && aScreenNo>=0)

  		{

  		CWsTop::SetCurrentFocusScreen(aScreenNo);

  		}

  	else

  		{

  		Panic();

  		}

  	}

 TInt CWsAnim::WindowGroups(TInt aScreen) const

 	{

 	return(CWsWindowGroup::NumWindowGroupsOnScreen(CWsTop::Screen(aScreen)->RootWindow()->Child(),ETrue,0));

 	}

 TBool CWsAnim::WindowGroupInfo(TWindowGroupInfo& aInfo,TInt aScreen,TInt aFullOrdinalPosition) const

 	{

 	CWsWindowGroup* group=CWsTop::Screen(aScreen)->RootWindow()->WindowGroup(aFullOrdinalPosition);

 	if (!group)

 		return EFalse;

 	aInfo.iId=group->Identifier();

 	if (group->ReceivesFocus() && group->ScreenDeviceValid())

 		aInfo.iFlags=TWindowGroupInfo::EIsFocusable;

 	else

 		aInfo.iFlags=0;

 	aInfo.iOrdinalPriority=group->OrdinalPriority();

 	HBufC* groupName=group->GroupName();

 	aInfo.iNameLength=groupName?group->GroupName()->Length():0;

 	if (!group->IsChained(aInfo.iParentId))

 		aInfo.iParentId=-1;

 	return ETrue;

 	}

 TInt CWsAnim::WindowGroupName(TPtrC& aWindowName,TInt aScreen,TInt aFullOrdinalPosition) const

 	{

 	CWsWindowGroup* group=CWsTop::Screen(aScreen)->RootWindow()->WindowGroup(aFullOrdinalPosition);

 	if (!group)

 		return EFalse;

 	HBufC* name=group->GroupName();

 	if (name)

 		aWindowName.Set(*name);

 	else

 		aWindowName.Set(NULL,0);

 	return ETrue;

 	}

 TInt CWsAnim::SetOrdinalPosition(TInt aWindowGroupId,TInt aPos,TInt aOrdinalPriority)

 	{

 	CWsWindowGroup* group=CWsWindowGroup::WindowGroupFromIdentifier(aWindowGroupId);

 	if (group)

 		{

 		group->SetOrdinalPriority(aPos,aOrdinalPriority);

 		return KErrNone;

 		}

 	return KErrNotFound;

 	}

 void CWsAnim::WindowConfig(TWindowConfig& aWindowConfig) const

 	{

 	aWindowConfig.iFlags = 0x00;

 	if (iWindow->IsTranslucent())

 		{

 		aWindowConfig.iFlags |= TWindowConfig::ETransparencyEnabled;

 		if (iWindow->HasAlpha())

 			{

 			aWindowConfig.iFlags |= TWindowConfig::EAlphaBlendedTransparency;

 			}		

 		}

 	}

 TBool CWsAnim::SpriteCanBeSeen() const

 	{

 	if(!iSprite)

 		Panic();

 	return iSprite->CanBeSeen();

 	}

 /** @see MWsWindowTreeNode */

 MWsWindowTreeNode::TType CWsAnim::NodeType() const

 	{

 	return (iSprite) ? iSprite->NodeType() : MWsWindowTreeNode::EWinTreeNodeAnim;

 	}

 /** @see MWsWindowTreeNode */

 const MWsWindow* CWsAnim::Window() const

 	{

 	return NULL;

 	}

 /** @see MWsWindowTreeNode */

 const MWsSprite* CWsAnim::Sprite() const

 	{

 	return iSprite;

 	}

 /** @see MWsWindowTreeNode */

 const MWsStandardTextCursor* CWsAnim::StandardTextCursor() const

 	{

 	return NULL;

 	}

 /** @see MWsWindowTreeNode */

 const MWsWindowGroup* CWsAnim::WindowGroup() const

 	{

 	if (iSprite)

 		return iSprite->WindowGroup();

 	else if (iWindow)

 		return iWindow->WindowGroup();

 	Panic();

 	return NULL;

 	}

 /** @see MWsWindowTreeNode */

 const MWsWindowTreeNode* CWsAnim::ParentNode() const

 	{

 	if (iSprite)

 		return iSprite->ParentNode();

 	else if (iWindow)

 		return iWindow; //A window-anim is considered to be a child of the window

 	Panic();

 	return NULL;

 	}

 //

 CObjectConIx* CWsAnimDll::AnimObjectConIx=NULL;

 void CWsAnimDll::InitStaticsL()

 	{

 	CWsAnimDll::AnimObjectConIx=CObjectConIx::NewL();

 	}

 void CWsAnimDll::DeleteStatics()

 	{

 	delete CWsAnimDll::AnimObjectConIx;

 	}

 CWsAnimDll::CWsAnimDll(CWsClient *aOwner) : CWsObject(aOwner,WS_HANDLE_ANIM_DLL)

 	{

 	__DECLARE_NAME(_S("CWsAnimDll"));

 	}

 CWsAnimDll::~CWsAnimDll()

 	{

 	delete iInstanceIndex;

 	AnimObjectConIx->Remove(iInstanceCon);

 	delete iAnimDll;

 	iAnimLib.Close();

 	}

 TInt CWsAnimDll::doCreateInstanceL(CWsAnim *aInstance, TInt aType, TAny *aArgs, TBool aIsWindow)

 	{

 	iInstanceCon->AddL(aInstance);

 	aInstance->ConstructL(iAnimDll->CreateInstanceL(aType),aArgs,this,aIsWindow);

 	return(iInstanceIndex->AddL(aInstance));

 	}

 TInt CWsAnimDll::CreateInstanceL(TUint32 aHandle, TInt aType, TAny *aArgs, TBool aIsWindow)

 	{

 	TWindowServerEvent::PotentialEventHandlerL(1);

 	CWsAnim *instance=new(ELeave) CWsAnim(this);

 	CleanupClosePushL(*instance);

 	if (aIsWindow)

 		{

 		CWsClientWindow *win;

 		iWsOwner->HandleToClientWindow(aHandle,&win);

 		instance->Connect(win);

 		}

 	else

 		{

 		CWsObject *sprite=iWsOwner->HandleToObj(aHandle, WS_HANDLE_SPRITE);

 		if (!sprite)

 			OwnerPanic(EWservPanicSprite);

 		instance->Connect(STATIC_CAST(CWsSprite*,sprite));

 		}

 	TInt handle=doCreateInstanceL(instance, aType, aArgs, aIsWindow);

 	CleanupStack::Pop(instance);	

 	return(handle);

 	}

 void CWsAnimDll::LoadL(const TDesC &aDllName)

 	{

 	NewObjL();

 	TFileName name(aDllName);

 	User::LeaveIfError(iAnimLib.Load(name));

 	if (wsDebugLog)

 		{

 		TBuf<256> buf;

 		_LIT(KWSERVLoadedAnimDll,"Loaded Anim DLL:  ");

 		buf.Append(KWSERVLoadedAnimDll);

 		buf.Append(iAnimLib.FileName());

 		wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant,buf);

 		}

 	TUidType uid=iAnimLib.Type();

 	if (uid[1]!=KWservAnimDllUid)

 		User::Leave(KErrNotSupported);

 	CreateCAnimDll f;

 	f=(CreateCAnimDll)User::LeaveIfNull((TAny *)iAnimLib.Lookup(1));

 	iAnimDll=(*f)();

 	iInstanceIndex=CObjectIx::NewL();

 	iInstanceCon=AnimObjectConIx->CreateL();

 	}

 void CWsAnimDll::Remove(TInt aHandle)

 	{

 	iInstanceIndex->Remove(aHandle);

 	}

 void CWsAnimDll::CommandL(TInt aOpcode, const TAny *aCmdData)

 	{

 	TWsAnimDllCmdUnion pData;

 	pData.any=aCmdData;

 	switch(aOpcode)

 		{

 		case EWsAnimDllOpFree:

 			delete this;

 			break;

 		case EWsAnimDllOpCreateInstance:

 		case EWsAnimDllOpCreateInstanceSprite:

 			SetReply(CreateInstanceL(*pData.UInt,*((TInt *)(pData.UInt+1)),(TAny *)(pData.UInt+2)

 																					,aOpcode==EWsAnimDllOpCreateInstance));

 			break;

 		case EWsAnimDllOpCommandReply:

 		case EWsAnimDllOpCommand:

 		case EWsAnimDllOpDestroyInstance:

 			{

 			CWsAnim *anim=(CWsAnim *)iInstanceIndex->At(*pData.UInt);

 			TInt ret;

 			//Deleting a non existant Anim is allowed as the Anim will be destroyed

 			//when the window it is on (or a parent of) it destroyed

 			if (anim==NULL && aOpcode!=EWsAnimDllOpDestroyInstance)

 				OwnerPanic(EWservPanicAnim);

 			switch(aOpcode)

 				{

 				case EWsAnimDllOpCommandReply:

 					{

 					TInt reply=KErrNone;

 					TRAP(ret,reply=anim->CommandReply(*((TInt *)(pData.UInt+1)),(TAny *)(pData.UInt+2)));

 					anim->UserDeactivateAnimGc();

 					if (ret!=KErrNone)

 						User::Leave(ret);

 					SetReply(reply);

 					}

 					break;

 				case EWsAnimDllOpCommand:

 					TRAP(ret,anim->Anim()->Command(*((TInt *)(pData.UInt+1)),(TAny *)(pData.UInt+2)));

 					if (ret!=KErrNone && ret!=CWsClient::EPanicLeave)

 						OwnerPanic(EWservPanicAnimLeave);

 					anim->UserDeactivateAnimGc();

 					break;

 				case EWsAnimDllOpDestroyInstance:

 					if (anim) // Added to go with changes described above

 						Remove(*pData.UInt);

 					break;

 				default:

 					break;

 				}

 			}

 			break;

 		default:

 			OwnerPanic(EWservPanicOpcode);

 		}

 	}

 CAnimFbsFont::~CAnimFbsFont()

 	{}

 CAnimFbsFont::CAnimFbsFont()

 	{}

 CAnimFbsFont* CAnimFbsFont::NewL(TInt aHandle,TInt& aError)

 	{

 	CAnimFbsFont *font=new(ELeave) CAnimFbsFont();

 	font->iAccessCount=1;

 	aError=font->Duplicate(aHandle);

 	if (aError!=KErrNone)

 		{

 		delete font;

 		font=NULL;

 		}

 	return(font);

 	}

 void CAnimFbsFont::Open()

 	{

 	iAccessCount++;

 	}

 void CAnimFbsFont::Close()

 	{

 	if (--iAccessCount==0)

 		delete this;

 	}

 /*MAnimGeneralFunctions*/

 void MAnimGeneralFunctions::Reserved1() const

 	{}

 void MAnimGeneralFunctions::Reserved2() const

 	{}

 void MAnimGeneralFunctions::Reserved3() const

 	{}

 /*MAnimGeneralFunctionsExtension*/

 void MAnimGeneralFunctionsWindowExtension::Reserved1() const

 	{}

 void MAnimGeneralFunctionsWindowExtension::Reserved2() const

 	{}

 void MAnimGeneralFunctionsWindowExtension::Reserved3() const

 	{}

 /*MAnimWindowFunctions*/

 void MAnimWindowFunctions::Reserved() const

 	{}

 void MAnimWindowFunctions::Reserved1() const

 	{}

 void MAnimWindowFunctions::Reserved2() const

 	{}

 void MAnimWindowFunctions::Reserved3() const

 	{}

 /*MAnimFreeTimerWindowFunctions*/

 void MAnimFreeTimerWindowFunctions::Reserved3() const

 	{}

 /*MAnimSpriteFunctions*/

 void MAnimSpriteFunctions::Reserved() const

 	{}

 void MAnimSpriteFunctions::Reserved2() const

 	{}

 void MAnimSpriteFunctions::Reserved3() const

 	{}

 void MAnimSpriteFunctions::Reserved4() const

 	{}	

 /*MAnimGeneralFunctionsEventExtension*/

 void MAnimGeneralFunctionsEventExtension::Reserved1() const

 	{}

 void MAnimGeneralFunctionsEventExtension::Reserved2() const

 	{}