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

/**
 @file
 @internalComponent - Internal Symbian test code 
*/


#include <e32base.h>
#include <charconv.h>

#include "TestWindows.h"
#include "TestEventHandler.h"
#include "TestRedrawHandler.h"
#include "ActiveWait.h"
#include "AnimationTestStep.h"
#include "AnimationConfig.h"

const TInt KFontHeight = 17;

//
// Windows:
//
// Backdrop window:
CAnimBackdropWindow::CAnimBackdropWindow(RWsSession& aWsSession, CTestWindowGroup& aGroup, CWindowGc& aGc) : CTestWindow(aWsSession, aGroup, aGc)
	{
	}
	
// Output window:
CAnimationTestWindow::CAnimationTestWindow(RWsSession& aWsSession, CTestWindowGroup& aGroup, CWindowGc& aGc, CWsScreenDevice& aScreen) :
CTestWindow(aWsSession, aGroup, aGc),
iScreen(aScreen)
	{
	}

CAnimationTestWindow::~CAnimationTestWindow()
	{
	}

void CAnimationTestWindow::DrawL()
	{
	if(!iFont)
		{
		TFontSpec fspec(_L("Arial"),KFontHeight);
		User::LeaveIfError(iScreen.GetNearestFontInPixels((CFont *&)iFont, fspec));
		}
	iGc.UseFont(iFont);
	iGc.SetPenColor(KRgbBlack);
	TSize size = Window()->Size();
	for (TInt i = 0; i < iNumLines; ++i)
		{
		iGc.DrawText(iText[(iFirstLine + i) % KMaxLogWinLines], TRect(TPoint(0,i * KFontHeight), size), KFontHeight);
		}
	}

void CAnimationTestWindow::AppendText(const TDesC& aText)
	{
	TInt line = (iFirstLine + iNumLines) % KMaxLogWinLines;
	if (iNumLines < KMaxLogWinLines)
		++iNumLines;
	else
		iFirstLine = (iFirstLine + 1) % KMaxLogWinLines;
		
	iText[line].Copy(aText.Left(iText[line].MaxLength()));
	Window()->Invalidate();
	}
	
void CAnimationTestWindow::Clear()
	{
	iNumLines = 0;
	Window()->Invalidate();
	}

//
// The test:
//
CAnimationTestStep::CAnimationTestStep():
	iBackgroundColor1(TRgb(0xFF8080)),
	iBackgroundColor2(TRgb(0xFF0000))
	{
	}
	
CAnimationTestStep::~CAnimationTestStep()
	{
	if (iWaiter)
		{
		iWaiter->Cancel();
		delete iWaiter;
		}
	delete iRedrawHandler;
	delete iEventHandler;
	delete iAnimTestWin;
	delete iAnimBackdropWin;
	delete iGroupWin;
	delete iGc;
	iFs.Close();
	iWs.Close();
	delete iConverter;
	iColors.Close();
	}

void CAnimationTestStep::InitialiseL()
	{
	iWaiter = CActiveWait::NewL();
	
	User::LeaveIfError(iWs.Connect());
	User::LeaveIfError(iFs.Connect());
	iScreen = new (ELeave) CWsScreenDevice(iWs);
	User::LeaveIfError(iScreen->Construct());
	iDisplayMode = iScreen->DisplayMode();
	iGc = new (ELeave) CWindowGc(iScreen);
	User::LeaveIfError(iGc->Construct());
	
	iConverter = CCnvCharacterSetConverter::NewL();
	iConverterState = CCnvCharacterSetConverter::KStateDefault;
	iConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierAscii, iFs);

	iEventHandler = new (ELeave) CTestEventHandler(iWs);
	iEventHandler->Start();
	iRedrawHandler = new (ELeave) CTestRedrawHandler(iWs);
	iRedrawHandler->Start();
	
	iGroupWin = new (ELeave) CTestWindowGroup(iWs);

	// EColor64K is 16bpp in RGB 5-6-5 format, some color might be truncated during conversion 
	// from TRgb to TUint16
	// The solution is to convert RGB to RGB565 and back to RGB to allow direct color comparison 
    // with value of drawn pixel on the screen 
	if (iScreen->DisplayMode()==EColor64K)
		{
		iBackgroundColor1 = TRgb::Color64K(iBackgroundColor1.Color64K());
		iBackgroundColor2 = TRgb::Color64K(iBackgroundColor2.Color64K());
		}

	iStepWinSize = iScreen->SizeInPixels();
	iStepWinSize.iWidth /= 2;
	iAnimTestWin = new (ELeave) CAnimationTestWindow(iWs, *iGroupWin, *iGc, *iScreen);
	iAnimTestWin->Window()->SetRequiredDisplayMode(EGray2);
	iAnimTestWin->Window()->SetExtent(TPoint(0,0), iStepWinSize);
	iAnimTestWin->Window()->SetBackgroundColor(KRgbWhite);
	iAnimTestWin->Window()->SetVisible(ETrue);
	iAnimTestWin->Window()->Activate();
	
	iAnimBackdropWin = new (ELeave) CAnimBackdropWindow(iWs, *iGroupWin, *iGc);
	iAnimBackdropWin->Window()->SetRequiredDisplayMode(EGray2);
	iAnimBackdropWin->Window()->SetExtent(TPoint(iStepWinSize.iWidth,0), iStepWinSize);
	iAnimBackdropWin->Window()->SetBackgroundColor(KRgbBlack);
	iAnimBackdropWin->Window()->SetVisible(ETrue);
	iAnimBackdropWin->Window()->Activate();
	}

// This is not a completely safe function, but then this is only a test harness
void CAnimationTestStep::Log(const TDesC& aText)
	{
	iAnimTestWin->AppendText(aText);
	}
	
void CAnimationTestStep::ClearLog()
	{
	iAnimTestWin->Clear();
	}
	
void CAnimationTestStep::Wait(TInt aDelay)
	{
	iWaiter->Wait(aDelay);
	}
	
TBool CAnimationTestStep::RectCompare(const TRect& a, const TRect& b)
	{
	if(iScreen->RectCompare(a,b,CWsScreenDevice::EIncludeSprite))
		{
		return ETrue;
		}
	else
		{
		return EFalse; // This is a good place for a break point
		}
	}

TInt CAnimationTestStep::CountColorsL(const TRect& aRect, TInt aMin, TInt aMax)
	{
	TDisplayMode displayMode = iScreen->DisplayMode();
	TInt width = CFbsBitmap::ScanLineLength(aRect.Width(),displayMode);
	HBufC8* buf=HBufC8::NewMaxLC(width);
	TPtr8 ptr=buf->Des();
	iColors.Reset();
	TInt inc = width/aRect.Width();
	for (TInt row = aRect.iTl.iY; row < aRect.iBr.iY; ++row)
		{
		ptr.SetLength(0);
		iScreen->GetScanLine(ptr,TPoint(aRect.iTl.iX,row),aRect.Width(),displayMode);
		for (TInt col = 0; col < ptr.Length(); col+=inc)
			{
			TUint clr = ptr[col];
			// Pixel buffer represented in block of bytes, if color mode is 8bpp (1byte) we can
			// simply access the buffer sequentially eg clr = ptr[col], however if the color mode
			// is 16bpp or more, access must be adjusted accordingly. 
			// The "inc" variable indicates how many bytes each pixel's colour takes
			// and could be any value from 1 to 4 depending on the color mode.
			for (TInt byteNumber = 1; byteNumber < inc; byteNumber++)
				{
				clr = clr << 8;
				clr += ptr[col + byteNumber];
				}
			if (iColors.Find(clr) == KErrNotFound)
				{
				iColors.Append(clr);
				}
			}
		}
	TInt count = iColors.Count();
	CleanupStack::PopAndDestroy(buf);
	
	if (count < aMin)
		{
		return (count - aMin);	// This is a good place for a break point
		}
	else if (count > aMax)
		{
		return (count - aMax);	// This is a good place for a break point
		}
	else
		{
		return 0;
		}
	
	}

//
// Wait till redraws finished //
//

class CStopTheScheduler : public CAsyncOneShot
	{
public:
	CStopTheScheduler(TInt aPriority);
	static CStopTheScheduler* NewL(TInt aPriority);
	void RunL();
	};

CStopTheScheduler* CStopTheScheduler::NewL(TInt aPriority)
	{
	return new(ELeave)CStopTheScheduler(aPriority);
	}

CStopTheScheduler::CStopTheScheduler(TInt aPriority)
	:CAsyncOneShot(aPriority)
	{
	}

void CStopTheScheduler::RunL()
	{
	CActiveScheduler::Stop();
	}

void CAnimationTestStep::WaitForRedrawsToFinish()
	{
	CStopTheScheduler* ps=new CStopTheScheduler(-11);
	if(ps)
		{
		ps->Call();
		CActiveScheduler::Start();
		delete ps;
		}
	}