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

// Sprite

// 

//

#include <e32std.h>

#include "sprite.h"

#include "rootwin.h"

#include "windowgroup.h"

#include "ScrDev.H"

#include "wstop.h"

#include "ANIM.H"

#include "panics.h"

#include "EVENT.H"

#include "bitgditomwsgraphicscontextmappings.h"

#include "../debuglog/DEBUGLOG.H"

static const TInt64 KFlashHalfSecond(500000); //interval for flashing sprites

GLDEF_D CWsDeltaTimer *CWsSpriteBase::iDeltaTimer=NULL;

TInt TimerCallBack(TAny *aPtr)

	{

	((CWsSpriteBase *)aPtr)->TimerExpired();

	return(KErrNone);

	}

#ifndef _DEBUG

#define LOG_SPRITE_REDRAW_START(sprite)

#define LOG_SPRITE_REDRAW_END(sprite)

#define LOG_SPRITE_FLASH(aSprite)

#else

#define LOG_SPRITE_REDRAW_START(sprite) LogSpriteRedrawStart(sprite)

#define LOG_SPRITE_REDRAW_END(sprite) LogSpriteRedrawEnd(sprite)

#define LOG_SPRITE_FLASH(sprite) LogSpriteFlash(sprite)

extern CDebugLogBase *wsDebugLog;

static void LogSpriteRedrawStart(const CWsSpriteBase& aSprite)

    {

    if (wsDebugLog)

        {

        _LIT(KAnnotateSpriteRedrawStart, ">> MWsDrawAnnotationObserver::FloatingSpriteRedrawStart [%S][app %d]");

        const TDesC& clientName = aSprite.WsOwner()->Client().FullName();

        TBuf<LogTBufSize> log;

        TTruncateOverflow overflow;

        log.AppendFormat(KAnnotateSpriteRedrawStart, &overflow, &clientName, aSprite.WsOwner()->ConnectionHandle());

        wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

        }

    }

static void LogSpriteRedrawEnd(const CWsSpriteBase& aSprite)

    {

    if (wsDebugLog)

        {

        _LIT(KAnnotateSpriteRedrawEnd, "<< MWsDrawAnnotationObserver::FloatingSpriteRedrawEnd [%S][app %d]");

        const TDesC& clientName = aSprite.WsOwner()->Client().FullName();

        TBuf<LogTBufSize> log;

        TTruncateOverflow overflow;

        log.AppendFormat(KAnnotateSpriteRedrawEnd, &overflow, &clientName, aSprite.WsOwner()->ConnectionHandle());

        wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

        }

    }

static void LogSpriteFlash(const CWsSpriteBase& /*aSprite*/)

    {

    if (wsDebugLog)

        {

        // The following code causes Exception and is commented out, see defect GFX09962

//      _LIT(KAnnotateSpriteFlash, "-- MWsDrawAnnotationObserver::SpriteFlash:%d [%S][app %d]");

//      const TDesC& clientName = aSprite.WsOwner()->Client().FullName();

//      TBuf<LogTBufSize> log;

//      TTruncateOverflow overflow;

//      log.AppendFormat(KAnnotateSpriteFlash, &overflow, &clientName, aSprite.WsOwner()->ConnectionHandle());

//      wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

        // This code is temporarily here until above problem is resolved

        _LIT(KAnnotateSpriteFlash, "-- MWsDrawAnnotationObserver::SpriteFlash");

        TBuf<LogTBufSize> log;

        log.AppendFormat(KAnnotateSpriteFlash);

        wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

        }

    }

#endif

static void AnnotateSpriteRedrawStart(const CWsSpriteBase& aSprite, const TRegion& aRegion)

	{

	LOG_SPRITE_REDRAW_START(aSprite);

	MWsDrawAnnotationObserver* annoObs = aSprite.Screen()->DrawAnnotationObserver();

	if(annoObs)

		{

		annoObs->SpriteRedrawStart(aSprite, aRegion);

		}

	}

static void AnnotateSpriteRedrawEnd(const CWsSpriteBase& aSprite)

	{

	LOG_SPRITE_REDRAW_END(aSprite);

	MWsDrawAnnotationObserver* annoObs = aSprite.Screen()->DrawAnnotationObserver();

	if(annoObs)

		{

		annoObs->SpriteRedrawEnd(aSprite);

		}		

	}

static void AnnotateSpriteFlash(const CWsSpriteBase& aSprite, TBool aFlashOn)

	{

	LOG_SPRITE_FLASH(aSprite);

	MWsDrawAnnotationObserver* annoObs = aSprite.Screen()->DrawAnnotationObserver();

	if(annoObs)

		{

		annoObs->SpriteFlash(aSprite, aFlashOn);

		}	

	}

//

// CWsSpriteMember

//

CWsSpriteMember::CWsSpriteMember()

	{

	}

CWsSpriteMember::~CWsSpriteMember()

	{

	delete iBitmap;

	delete iMaskBitmap;

	}

TBool CWsSpriteMember::SetL(const TCmdSpriteMember &aCmdSpriteMember)

	{

	if (aCmdSpriteMember.iBitmap!=0)	// Null member of sequence, time is only valid field in member data

		{

		iBitmap=new(ELeave) CFbsBitmap();

		TInt ret = iBitmap->Duplicate(aCmdSpriteMember.iBitmap);

		if (ret == KErrNoMemory)

			{

			User::Leave(ret);

			}

		if (ret != KErrNone)

			return(ETrue);

		if (aCmdSpriteMember.iMaskBitmap)

			{

			iMaskBitmap=new(ELeave) CFbsBitmap();

			TInt ret = iMaskBitmap->Duplicate(aCmdSpriteMember.iMaskBitmap);

			if (ret == KErrNoMemory)

				{

				User::Leave(ret);

				}

			if (ret != KErrNone)

				return(ETrue);

			}

		iInvertMask=aCmdSpriteMember.iInvertMask;

		iDrawMode=aCmdSpriteMember.iDrawMode;

		iOffset=aCmdSpriteMember.iOffset;

		}

	iInterval=aCmdSpriteMember.iInterval;

	return(EFalse);

	}

//

// CWsSpriteBase

//

TBool CWsSpriteBase::UpdateMemberL(CWsSpriteMember *aMember, const TCmdSpriteMember &aCmdSpriteMember)

	{

	CFbsBitmap *old=aMember->iBitmap;

	CFbsBitmap *oldMask=aMember->iMaskBitmap;

	aMember->iBitmap=NULL;

	aMember->iMaskBitmap=NULL;

	TBool ret=EFalse;

	TRAPD(err,ret=aMember->SetL(aCmdSpriteMember));

	if (err!=KErrNone)

		{

um_error:

		delete aMember->iBitmap;

		delete aMember->iMaskBitmap;

		aMember->iBitmap=old;

		aMember->iMaskBitmap=oldMask;

		User::Leave(err);

		}

	TRAP(err,CheckSizesL());

	if (err!=KErrNone)

		goto um_error;

	SetMember(0);

	delete old;

	delete oldMask;

	return(ret);

	}

void CWsSpriteBase::InitStaticsL()

	{

	iDeltaTimer=CWsDeltaTimer::NewL(ESpriteAnimatePriority);

	}

void CWsSpriteBase::DeleteStatics()

	{

	delete iDeltaTimer;

	}

CWsSpriteBase::CWsSpriteBase(CWsClient *owner, WH_HANDLES aType) : CWsScreenObject(owner,aType,owner->Screen())

	{

	}

CWsSpriteBase::~CWsSpriteBase()

	{

	Deactivate();

	if(IsFloating() && iGroupWin)

		{

		iGroupWin->RemoveSprite(this);

		}

	//iDeltaTimer->Remove(iDeltaTimerEntry);

	if (iMembers)

		{

		iMembers->ResetAndDestroy();

		delete iMembers;

		}

	}

void CWsSpriteBase::ForceRedraw()

	{

	TRegionFix<1> region;

	region.AddRect(Rect());

	Screen()->AddRedrawRegion(region);

	}

void CWsSpriteBase::Deactivate()

	{

	//Disconnect from the sprite list and hide the sprite

	if (iFlags & ESpriteActive)

		{

		iFlags&=~ESpriteActive;

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

		if (windowTreeObserver)

			{

			windowTreeObserver->NodeReleased(*this);

			}

		if (iMembers && iMembers->Count()>1)

			{

			iDeltaTimer->Remove(iDeltaTimerEntry);

			}

		if (IsFloating())

			{

			Screen()->SpriteManager()->RemoveFloatingSprite(this);

			if (!Screen()->ChangeTracking())

				{

				ForceRedraw();

				}

			}

		// Note: This could be a floating sprite attached to the root window (PDEF138379)

		if(iWin)

			{

			iWin->RemoveSprite(this);

			}

		}

	}

/** Called from groupwin destructor only */

void CWsSpriteBase::DisconnectGroupWin()

	{

	WS_ASSERT_DEBUG(IsFloating(),EWsPanicFloatingSprite);

	iGroupWin=NULL;

	}

void CWsSpriteBase::CheckSizesL()

	{

	iMaxSize.SetSize(0,0);

	for(TInt index=0;index<iMembers->Count();index++)

		{

		CWsSpriteMember *wsm=(*iMembers)[index];

		if (wsm->iBitmap)

			{

			TSize size=wsm->iBitmap->SizeInPixels();

			if (wsm->iMaskBitmap)

				{

				TSize maskSize=wsm->iMaskBitmap->SizeInPixels();

				if (maskSize.iWidth<size.iWidth || maskSize.iHeight<size.iHeight)

					OwnerPanic(EWservPanicMaskSize);

				}

			if (size.iWidth>iMaxSize.iWidth)

				iMaxSize.iWidth=size.iWidth;

			if (size.iHeight>iMaxSize.iHeight)

				iMaxSize.iHeight=size.iHeight;

			}

		}

	}

void CWsSpriteBase::ConstructL(TUint aFlags, CWsWindow *aWindow)

	{

	// Common part of construct for both sprites and pointer cursors

	iFlags=aFlags;

/*

	if (iFlags&ESpriteNoChildClip)

		iLink.iPriority+=ENoChildPriorityBoost;

	if (iFlags&ESpritePointer)

		iLink.iPriority+=EPointerPriorityBoost;

*/

	iWin=aWindow;

	TCallBack callback(TimerCallBack,this);

	iDeltaTimerEntry.Set(callback);

	iMembers=new(ELeave) CArrayPtrFlat<CWsSpriteMember>(10);

	}

void CWsSpriteBase::AppendMemberL(const TCmdSpriteMember &aCmdSpriteMember)

	{

	CWsSpriteMember *&pwsm=iMembers->ExtendL();

	pwsm=NULL;	// In case new leaves

	pwsm=new(ELeave) CWsSpriteMember();

	// coverity[leave_without_push]

	// pwsm is not owned by the stack and will be deleted by RWsSpriteBase::Close()

	if (pwsm->SetL(aCmdSpriteMember))

		OwnerPanic(EWservPanicBitmap);

	}

void CWsSpriteBase::CompleteL()

	{

	if (iMembers->Count() <= 0)

		{

		if(iWin)

			iWin->OwnerPanic(EWservPanicNoSpriteMember);

		//Not sure if this is a neccessary fall back if iWin is NULL.

		else if(iWin==NULL && iGroupWin)

			iGroupWin->OwnerPanic(EWservPanicNoSpriteMember);

		}

	else

		{

		iMembers->Compress();

		CheckSizesL();

		SetMember(0);

		}

	}

void CWsSpriteBase::Activate()

	{

	if (iFlags&ESpriteDisabled)

		{

		iFlags&=~ESpriteDisabled;

		}

	if (iMembers->Count()>1)

		{

		QueueDeltaTimer();

		iDeltaTimer->Activate();

		}

	iFlags|=ESpriteActive;

	if(iWin)	

		iWin->AddSprite(this);

	SetDirty(ETrue);

	Screen()->SpriteManager()->Schedule(this);

	if(IsFloating())

		{		

		Screen()->SpriteManager()->AddFloatingSprite(this);

		if (!Screen()->ChangeTracking())

			ForceRedraw();

		}

	// As custom text cursors are sprites (CWsCustomTextCursor) and can be activated/deactivated

	// on various different windows during their lifetime, when activating

	// a text cursor, we pretend it's just been created to give us the option

	// of specifying a new parent window. Normal sprites (CWsSprite) are

	// treated the same way just for consistency as it does no harm.

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

	if (windowTreeObserver)

		{

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

		windowTreeObserver->NodeExtentChanged(*this, Rect());

		windowTreeObserver->NodeActivated(*this);

		}

	}

void CWsSpriteBase::SetMember(TInt aIndex)

	{

	const TSize oldSize = iSize;

	const TPoint oldPos = iPos;

	if(IsFloating())

		{		

		TRect rect(iPos,iSize);

		}

	iCurIndex=aIndex;

	iPos=iBasePos+(*iMembers)[iCurIndex]->iOffset;

	if ((*iMembers)[iCurIndex]->iBitmap)

		iSize=(*iMembers)[iCurIndex]->iBitmap->SizeInPixels();

	else

		iSize.SetSize(0,0);

	if (iSize.iWidth > iMaxSize.iWidth || iSize.iHeight > iMaxSize.iHeight)

		{

		WS_ASSERT_DEBUG(EFalse, EWsPanicSpriteBitmapSizeChange);

		CheckSizesL();

		}

	if(oldSize!=iSize || oldPos!=iPos)

		NotifyExtentChanged();

	}

void CWsSpriteBase::SetPos(const TPoint &aPos)

	{

	//Non-floating anim whose window is destroyed 

	if (!IsFloating() && iWin==NULL) 

		{ 

		OwnerPanic(EWservPanicWindowDestroyed); 

		} 

	//Floating anim whose group window is destroyed 

	if (IsFloating()  && iGroupWin==NULL && iWin->WinType() != EWinTypeRoot) 

		{ 

		OwnerPanic(EWservPanicWindowDestroyed); 

		}

	if(IsFloating())

		{		

		TRect rect(iPos,iSize);

		}

	iBasePos=aPos;

	TPoint newPos(iBasePos+(*iMembers)[iCurIndex]->iOffset);

	if (iPos!=newPos)

		{

		if (!Screen()->ChangeTracking())

			//Ensure the region covered by the sprite before as well as after the move gets scheduled for redraw

			Screen()->SpriteManager()->Schedule(this);

		iPos=newPos;

		if (!Screen()->ChangeTracking())

			Screen()->SpriteManager()->Schedule(this);

		NotifyExtentChanged();

		}

	}

void CWsSpriteBase::QueueDeltaTimer()

	{

	iDeltaTimer->Queue((*iMembers)[iCurIndex]->iInterval,iDeltaTimerEntry);

	}

void CWsSpriteBase::TimerExpired()

	{

	if (!Screen()->ChangeTracking())

		Screen()->SpriteManager()->Schedule(this);

	SetMember((iCurIndex+1)==iMembers->Count() ? 0 : iCurIndex+1);

	SetDirty(ETrue);

	Screen()->SpriteManager()->Schedule(this);

	QueueDeltaTimer();

	}

TPoint CWsSpriteBase::Pos() const

	{

	if (iGroupWin || iWin==NULL || iWin->WinType() == EWinTypeRoot )

		{

		return(iPos);

		}

	return(iPos+iWin->Origin());

	}

TRect CWsSpriteBase::Rect() const

	{

	TRect rect;

	rect.iTl=Pos();

	rect.iBr=rect.iTl+iSize;

	return(rect);

	}

MWsSprite::TSpriteType CWsSpriteBase::SpriteType() const

	{

	if (IsFloating())

		return EFloatingSprite;

	TSpriteType spriteType = EWindowSprite; 

	switch(Type())

		{

	case WS_HANDLE_SPRITE:

		spriteType = EWindowSprite;

		break;

	case WS_HANDLE_POINTER_CURSOR:

		spriteType = EPointerCursorSprite;

		break;

	case WS_HANDLE_TEXT_CURSOR:

		spriteType = ECustomTextCursorSprite;

		break;

	default:

		ASSERT(0);

		}

	return spriteType;

	}

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

	{

	TWsSpriteCmdUnion pData;

	pData.any=aCmdData;

	switch(aOpcode)

		{

		case EWsSpriteOpAppendMember:

			AppendMemberL(*pData.SpriteMember);

			break;

		case EWsSpriteOpActivate:

			if(!(iFlags&ESpriteActive))

				CompleteL();

			break;

		case EWsSpriteOpUpdateMember:

			if (pData.UpdateMember->index==iCurIndex)