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

// Implements  CTCrpAnim

// Test CRP animations & their interaction with overlapping transparent/non-transparent windows 

// & wserv's underlying redraw-store strategies

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include <w32stdgraphic.h>

#include "tcrpanim.h"

// RUN_SAMPLE_ON_LEFT allows the demo animation to run in the left-hand window during testing. 

// Used for demonstration purposes only

#define RUN_SAMPLE_ON_LEFT

namespace	//anonymous local scope

	{

	const TInt KAnimationFrameDelayTime = 50000; 				// delay in microseconds between frames

	const TInt KShortDelayLoop = 2*KAnimationFrameDelayTime; 	// delay time in microseconds used in test cases

	const TInt KAnimationTotalFrames = 40;						// total number of frames in a CWsGraphicBitmapAnimation

	const TInt KAnimDimension = 40;								// animation width/height. We're enforcing a square animation here

	const TInt KFrameMissedAnimationsThreshold = 10;			// maximum number of missed frame steps allowed

	const TInt KAnimationTearWidthThreshold = 4; 				// maximum columns permitted between a tear

	const TInt KMinGoodFrameThreshold = 30; 					// percentage threshold for number of good frames detected in a test

	const TInt KMaxXY = 200;									// arbitrary maximum size of square used to invalidate a window

	const TInt KMaxRepeatDraw = 2;								// arbitrary value for DrawLine calls during a Draw

	TUid  KUidTestAnimation2 = {0xBAADF00D};					// unique id. for CWsGraphicBitmapAnimation object

	const TUint32 KWhitePixels = 0xFFFFFFFF;					// 32-bit mask value for rgb white

	const TUint32 KBlackPixels = 0x00000000;					// 32-bit value for rgb black

	const TPoint KPointZero(0,0);								// initial point used for animation creation & manipulation (currently 0,0)

	const TPoint KPointOffsite(1000,1000);						// point used to draw off-screen

	const TDisplayMode KTestDisplayMode = EColor16MU;			// display mode used for testing

	const TInt KFrameStepCalculation = Max(1, KAnimDimension/Max(1, KAnimationTotalFrames)); // determine framestep size in columns

	enum TColorDetected

		{

		ECantTell=0,

		EDetRed=1,

		EDetGreen=2,

		EDetBlue=4,

		EDetBlack=0x10,

		EDetGrey=0x20,

		EDetWhite=0x40

		};

	class CCrpAnim;		

	class CAnimRedrawWindow : public CTWin

		{

	public:

		CAnimRedrawWindow(CCrpAnim *aAnimWindow, TBool aIsBase);

		~CAnimRedrawWindow();

		void Draw();

	private:

		CCrpAnim *iAnimWindow;

		TBool iIsBase;

		};

	class CCrpAnim : public CBase

		{

		friend class CAnimRedrawWindow;

	public:

		enum TWinType

			{

			ERedraw,

			EBlank,		// note: not currently used in tcrpanim tests

			EBackedUp	// note: not currently used in tcrpanim tests

			};

	public:

		CCrpAnim(TBool aIsBase, TWinType aWinType);

		~CCrpAnim();

		enum 

			{

			ENoTransparency=0x100

			};

		void ConstructL(const TPoint &aPos, const TSize &aSize,const TInt aAlphaValue=ENoTransparency);

		void DoDraw(TBool aBlankIt);

		inline void DoDraw();

		void DoDrawEllipse();

		inline TSize Size() {return iCtWin->Size();};

		inline RWindowBase* BaseWin() const {return iCtWin->BaseWin();};

		inline RWindow* Window() const {return STATIC_CAST(RWindow*, iCtWin->BaseWin());};

		inline CTBaseWin* CtBaseWin() {return iCtWin;};

		inline void Invalidate() {CTUser::Splat(TheClient, TRect(iCtWin->Position(), iCtWin->Size()), KRgbGray);};

		void Invalidate(const TRect &aRect);

		static void SetEllipseDrawMode(CGraphicsContext::TDrawMode aEllipseDrawMode);

		void InvalidateAndRedraw(TBool aUseBlankItMember,TBool aBlankIt,TBool aUseRWindowInvalidate,TRect* aRect=NULL);

		//A bit of an animation interface...

		//I have written this interface to be amenable to playing multiple animations,

		//which I think needs testing,

		//but the underlying implementation assumes one animation at present.

		//Your mission, should you choose to accept it, ....

		void SetPosAnimation(const TUid& aUid, const TRect& aRect);

		TRect* GetPosAnimation(const TUid& aUid);

		TWsGraphicAnimation* SetAnimation(TUid);	

		TWsGraphicAnimation* GetAnimation(TUid);	

		TBool RemoveAnimation(TUid);	

		inline void	SetBlankIt(TBool aNewVal) {iBlankIt = aNewVal;};

		inline void SetRepeatDrawMax(TInt aVal) {iRepeatDrawMax = aVal;};

	protected:

		static void Draw(CBitmapContext *aGc, const TSize &aSize, TBool aIsBase,const TRect &aRect, TBool aBlankIt,TInt aRepeat, TInt aAlphaValue);

		static void DrawEllipse(CBitmapContext *aGc, const TRect &aRect, TInt aAlphaValue);

		CTBaseWin *iCtWin;

		TWinType iWinType;

		TBool iIsBase;

		TBool iBlankIt;

		TRect iRect;

		TInt  iRepeatDrawMax;

		static CGraphicsContext::TDrawMode iEllipseDrawMode;

		TUid  iAnimUid;

		TWsGraphicAnimation iAnimData;

		TRect iAnimPos;

		TInt iAlphaValue;

		};

/*	    Using this time delay class in order to allow animations to play in our draw.

		User::Wait does not allow the draw to occur (aparrently)

		Note when using this time-delay class: because other active objects can perform part of their

	    processing whilst we wait, wrapping calls to this in __UHEAP_MARK / __UHEAP_MARKEND

	    is likely to fail.  The data providers and animators are a major cause of this. 

*/

	class CActiveWait : public CActive

		{

	public:

		static CActiveWait* NewL();

		~CActiveWait();

		void Wait(TInt aDelay);

		// From CActive:

		void RunL();

		void DoCancel();

		TInt RunError(TInt aError);

	protected:

		CActiveWait();

		void ConstructL();

	protected:

		RTimer iTimer;

		TTime iFromTime;

		};

	CActiveWait* CActiveWait::NewL()

		{

		CActiveWait* self = new (ELeave) CActiveWait;

		CleanupStack::PushL(self);

		self->ConstructL();

		CleanupStack::Pop(self);

		return self;

		}

	void CActiveWait::ConstructL()

		{

		User::LeaveIfError(iTimer.CreateLocal());

		CActiveScheduler::Add(this);

		}

	CActiveWait::CActiveWait() : CActive(EPriorityNormal)

		{

		iFromTime.HomeTime();

		}

	CActiveWait::~CActiveWait()

		{

		Cancel();

		iTimer.Close();

		}

	void CActiveWait::DoCancel()

		{

		iTimer.Cancel();

		CActiveScheduler::Stop();

		}

	void CActiveWait::RunL()

		{

		CActiveScheduler::Stop();

		}

	TInt CActiveWait::RunError(TInt aError)

		{

		return aError; // exists so a break point can be placed on it.

		}

/*	    Note when using this : because other active objects can perform part of their

	    processing whilst we wait, wrapping calls to this in __UHEAP_MARK / __UHEAP_MARKEND

	    is likely to fail.  The data providers and animators are a major cause of this. 

*/

	void CActiveWait::Wait(TInt aDelay)

		{

		iTimer.After(iStatus, aDelay);

		SetActive();

		CActiveScheduler::Start();

		}

	CGraphicsContext::TDrawMode CCrpAnim::iEllipseDrawMode;

//

	}	//end anonymous local scope

//

/** This fn allocates an animation frame of the specified dimensions.

	Not tested outside the current limited parameter set (16/2/2007).

	Note the use of 32-bit integers for pixel/colour values. Using display mode lower than 24bpp may not produce correct results

	My attempt to write animation generating code that avoids CIclLoader and Decoder class.

	@param aDelayUs	 	the display time for the frame

	@param aImageType	Colour format for colour plane. 24MA currently not flagged correctly I expect.

	@param aMaskType	Format for mask. ENone for no mask.

	@param aImageSize	Width/height of bitmap area

	@param aImageOffset	Optional offset for bitmap area

	@param aTotalSize	Optional width/height of whole animation (I think)

	@return CFrame		filled in with allocated bitmaps. The get methods for the bitmaps return const type.

**/

static CWsGraphicBitmapAnimation::CFrame* NewFrameLC(TInt aDelayUs,TDisplayMode aImageType,TDisplayMode aMaskType,const TSize& aImageSize,const TPoint& aImageOffset=KPointZero,const TSize& aTotalSize=TSize(0,0))

	{

	TFrameInfo info;

	info.iFrameCoordsInPixels = TRect(aImageOffset,aImageSize);

	info.iFrameSizeInTwips = aImageSize;	  //this is zero in the gif loader

	info.iDelay = TTimeIntervalMicroSeconds(aDelayUs);

	info.iFlags = TFrameInfo::EColor|TFrameInfo::ELeaveInPlace|TFrameInfo::EUsesFrameSizeInPixels;

	if (aMaskType != ENone)

		{

		info.iFlags|=TFrameInfo::ETransparencyPossible;

		}

	if ((aTotalSize.iHeight > 0) && (aTotalSize.iWidth > 0))

		{

		// restrict the size of the frame to specified size of the animation

		info.iOverallSizeInPixels = aTotalSize;

		}

	else

		{

		// assign the size of the frame to the size of the entire bitmap area

		info.iOverallSizeInPixels = info.iFrameCoordsInPixels.iBr.AsSize();

		}

	info.iFrameDisplayMode = aImageType;

	info.iBackgroundColor = KRgbGreen;

	CWsGraphicBitmapAnimation::CFrame* frame = CWsGraphicBitmapAnimation::CFrame::NewL();

	CleanupStack::PushL(frame);

	frame->SetFrameInfo(info);

	CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

	frame->SetBitmap(bitmap); //takes ownership

	TSize frameInfoSize = info.iFrameCoordsInPixels.Size();

	User::LeaveIfError(bitmap->Create(frameInfoSize, aImageType));

	if((TFrameInfo::EAlphaChannel|TFrameInfo::ETransparencyPossible) & info.iFlags)

		{

		CFbsBitmap* mask = new(ELeave) CFbsBitmap;

		frame->SetMask(mask); //takes ownership

		User::LeaveIfError(mask->Create(frameInfoSize, aMaskType));

		}

	return frame;

	}

//

// function called back by TCleanupItem frameListCleanup from within CreateAnimFramesL(..) method

//

void CleanupFrameList(TAny* aPtr)

	{

	RPointerArray<CWsGraphicBitmapAnimation::CFrame>* ptrArray = STATIC_CAST(RPointerArray<CWsGraphicBitmapAnimation::CFrame>*, aPtr);

	ptrArray->ResetAndDestroy();

	ptrArray->Close();

	}

/** Helper function for making animation frames.

	//Called from CreateAnimL(...)

	@param aDelayUs		the delay between frames

	@param aNumFrames	number of frames (approx - image width is a factor)

	@param aImageType	colour format of colour data. This may not work properly for non-32-bit, but I haven't fully understood TBitmapUtil documentation.

	@param aMaskType	format for mask - ENone for no mask.

	@param aImageSize	width/height of animation

	@param aBgCol		background colour for image non-masked areas. Masked areas are black.

	@param aFgCol		foreground colour of animating area

	@param aFrames		frames that the animation is constructed from

**/

static void CreateAnimFramesL(TInt aDelayUs,TInt aNumFrames,TDisplayMode aImageType,TDisplayMode aMaskType,TSize aImageSize,TRgb aBgCol,TRgb aFgCol, RPointerArray<CWsGraphicBitmapAnimation::CFrame>& aFrames)

	{

	const TInt 	animWH = aImageSize.iWidth;

	const TInt	animStep = Max(1,animWH/Max(1,aNumFrames));	//note this intentionally rounds down to avoid overflows

	for (TInt ii = 0 ; ii < animWH ; ii += animStep)

		{

		CWsGraphicBitmapAnimation::CFrame* frame = NewFrameLC(aDelayUs,aImageType,aMaskType,aImageSize,KPointZero,aImageSize);

		aFrames.AppendL(frame);

		CleanupStack::Pop(frame);

		TBitmapUtil utilMask(CONST_CAST(CFbsBitmap*, frame->Mask()));

		TBitmapUtil utilCol(CONST_CAST(CFbsBitmap*, frame->Bitmap()));

		utilCol.Begin(KPointZero);

		// cycle through the frame's actual bitmap & assign each pixel a value identical to the specified colours

		TUint32 colback=aBgCol.Internal();

		TUint32 colfront=aFgCol.Internal();

		TInt row = KErrNone;

		TInt col = KErrNone;

		for (row = 0 ; row < aImageSize.iHeight ; row++)

			{

			utilCol.SetPos(TPoint(0, row));

			for (col = 0 ; col < aImageSize.iWidth ; col++)

				{

				utilCol.SetPixel(colback);	

				utilCol.IncXPos();

				}

			utilCol.SetPos(TPoint(ii, row));

			for (col = 0 ; col < animStep ; col++)	  //Note I rely on intentional rounding down here!

				{

				utilCol.SetPixel(colfront);	

				utilCol.IncXPos();

				}			

			}

		if (aMaskType)

			{

			// cycle through each pixel of the frame's mask & assign a default pixel a colour value

			utilMask.Begin(KPointZero);

			for (row = 0 ; row < aImageSize.iHeight ; row++)

				{

				utilMask.SetPos(TPoint(0,row));

				for (col = 0 ; col < aImageSize.iWidth ; col++)

					{

					utilMask.SetPixel(KWhitePixels);

					utilMask.IncXPos();

					}

				}

			const TInt maxmaskWidth = Min(8,Max(animWH/3,2));

			//cut the corners off the mask

			for (row = 0 ; row < maxmaskWidth ; row++)

				{

				TInt currentX = maxmaskWidth - row;

				TInt xPos = KErrNone;

				utilCol.SetPos(TPoint(0,row));

				utilMask.SetPos(TPoint(0,row));

				for(xPos = currentX ; xPos >= 0 ; xPos--)

					{

					utilCol.SetPixel(KBlackPixels);	

					utilCol.IncXPos();

					utilMask.SetPixel(KBlackPixels);	

					utilMask.IncXPos();

					}

				utilCol.SetPos(TPoint(animWH - 1, row));

				utilMask.SetPos(TPoint(animWH - 1, row));

				for(xPos = currentX ; xPos >= 0 ; xPos--)

					{

					utilCol.SetPixel(KBlackPixels);	

					utilCol.DecXPos();

					utilMask.SetPixel(KBlackPixels);	

					utilMask.DecXPos();

					}

				utilCol.SetPos(TPoint(0, animWH - 1 - row));

				utilMask.SetPos(TPoint(0, animWH - 1 - row));

				for(xPos = currentX ; xPos >= 0 ; xPos--)

					{

					utilCol.SetPixel(KBlackPixels);	

					utilCol.IncXPos();

					utilMask.SetPixel(KBlackPixels);	

					utilMask.IncXPos();

					}

				utilCol.SetPos(TPoint(animWH - 1, animWH - 1 - row));

				utilMask.SetPos(TPoint(animWH - 1, animWH - 1 - row));

				for(xPos = currentX ; xPos >= 0 ; xPos--)

					{

					utilCol.SetPixel(KBlackPixels);	

					utilCol.DecXPos();

					utilMask.SetPixel(KBlackPixels);	

					utilMask.DecXPos();

					}

				}

			utilMask.End();

			}

		utilCol.End();

		}

	}

/** My attempt to write animation generating code that avoids CIclLoader and Decoder class.

	//It is better if this test class used it's own generated animation

	//rather than relying on the GIF loader in order to reduce the cross-dependencies.

	//The animation generated is a simple vertical line moving from left to right.

	//To prove the masking, I cut the corners off.

	@param aDelayUs		the delay between frames

	@param aNumFrames	number of frames (approx - image width is a factor)

	@param aImageType	colour format of colour data. This may not work properly for non-32-bit, but I haven't fully understood TBitmapUtil documentation.

	@param aMaskType	format for mask - ENone for no mask.

	@param aImageSize	width/height of animation

	@param aBgCol		background colour for image non-masked areas. Masked areas are black.

	@param aFgCol		foreground colour of animating area

	@param aTUid		TUid assigned to animation

	@return CWsGraphicBitmapAnimation allocated to represent the final animation	

**/

static CWsGraphicBitmapAnimation* CreateAnimL(TInt aDelayUs,TInt aNumFrames,TDisplayMode aImageType,TDisplayMode aMaskType,TSize aImageSize,TRgb aBgCol,TRgb aFgCol,TUid& aTUid)

	{

	RPointerArray<CWsGraphicBitmapAnimation::CFrame> frames;

	TCleanupItem frameListCleanup(CleanupFrameList, &frames);

	CleanupStack::PushL(frameListCleanup);

	CreateAnimFramesL(aDelayUs, aNumFrames, aImageType, aMaskType, aImageSize,aBgCol, aFgCol, frames);

	CWsGraphicBitmapAnimation* anim = CWsGraphicBitmapAnimation::NewL(aTUid,frames.Array());

	CleanupStack::PopAndDestroy(&frames);

	return anim;

	}

//

// Describes the pure colour of the RGB value. yellow/magenta/cyan set 2 bits. White/grey is seperately flagged.

// This method attempts to determine the strongest primary colour present in any given pixel. 

// Note: The algorithm used is known to work for the current test cases only but requires careful review

// for anyone making additional changes to tcrpanim. Given time, improved algorithm should be developed

// to replace the current one

//

TUint PredominantColour(TUint aCol)

	{	 //I don't like all these ifs, but I don't see an easy alternative

		 //Possibly a bit look-up of the deltas from average would work 

		 //(ignoring the bottom 5 bits =32, not 0x30=48. Ignore bottom 4 bits and accept 3-same answers, or divide by delta?)

		 //

	const TInt Kdelta=0x30;

	TInt red=(aCol&0x00ff0000)>>16;

	TInt green=(aCol&0x0000ff00)>>8;

	TInt blue=(aCol&0x000000ff);

	TInt ave=((red+green+blue)*(65536/3))>>16;

	TBool rOverA=(red>ave);

	TBool gOverA=(green>ave);

	TBool bOverA=(blue>ave);

	TInt numOverAve=(rOverA?1:0)+(gOverA?1:0)+(bOverA?1:0);

	if (numOverAve==1)

		{

		if (rOverA)

			{

			if (red>ave+Kdelta)

				{

				if ((green-blue)>-Kdelta && (green-blue)<Kdelta)

					return  EDetRed;

				}

			else

				{

				if (ave<Kdelta)

					return EDetBlack;

				else

					{

					if (green>ave-Kdelta && blue>ave-Kdelta)

						{

						if (ave>256-Kdelta)

							return EDetWhite;

						else

							return EDetGrey;

						}

					}

				}

			}

		if (gOverA)

			{

			if (green>ave+Kdelta)

				{

				if ((blue-red)>-Kdelta && (blue-red)<Kdelta)

					return  EDetGreen;

				}

			else

				{

				if (ave<Kdelta)

					return EDetBlack;

				else

					{

					if (red>ave-Kdelta && blue>ave-Kdelta)

						if (ave>256-Kdelta)

							return EDetWhite;

						else

							return EDetGrey;

					}

				}

			}

		if (bOverA)

			{

			if (blue>ave+Kdelta)

				{

				if ((green-red)>-Kdelta && (green-red)<Kdelta)

					return  EDetBlue;

				}

			else

				{

				if (ave<Kdelta)

					return EDetBlack;

				else

					{

					if (red>ave-Kdelta && green>ave-Kdelta)

						if (ave>256-Kdelta)

							return EDetWhite;

						else

							return EDetGrey;

					}

				}

			}

		}

	else	

		{

		if (!rOverA)

			 if (red<ave-Kdelta)

			 	{

			 	if ((green-blue)>-Kdelta && (green-blue)<Kdelta)

			 		return EDetGreen|EDetBlue;

			 	}

			 else

				{

				if (ave>256-Kdelta)

					return EDetWhite;

				else

					{

					if (blue<ave+Kdelta && green<ave+Kdelta)

						{

						if (ave<Kdelta)

							return EDetBlack;

						else