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

 @test

 @internalComponent

*/

#include "spritewin.h"

#include "utils.h"

#include <hal.h>

//common configuration parameter names

_LIT(KT_WservStressParamRandomizeDrawMode, "randomize_draw_mode");

_LIT(KT_WservStressParamMaxRandomStepX, "max_random_step_x");

_LIT(KT_WservStressParamMaxRandomStepY, "max_random_step_y");

_LIT(KT_WservStressParamMaxRandomOffsetX, "max_random_offset_x");

_LIT(KT_WservStressParamMaxRandomOffsetY, "max_random_offset_y");

//static configuration data, definitions and default assignments

TBool CSpritedWin::iEnabled = ETrue;

TBool CSpritedWin::iTransparent = ETrue;

TBool CSpritedWin::iRandomizePenStyle = EFalse;

TBool CSpritedWin::iRandomizeBrushStyle = EFalse;

TBool CSpritedWin::iRandomizeDrawMode = EFalse;

TBool CSpritedWin::iTransparentForegroundWindow = EFalse;

TInt CSpritedWin::iMaxRandomStepX = 0;

TInt CSpritedWin::iMaxRandomStepY = 0;

TInt CSpritedWin::iMaxRandomOffsetX = 0;

TInt CSpritedWin::iMaxRandomOffsetY = 0;

const TInt sInvisibleFrame = 24;	//how much bigger the invisible window is

CSpritedWin* CSpritedWin::NewLC(RWsSession& aWs, RWindowGroup* aGroup, CCompWin* aParent, CWindowGc& aGc)

	{

	CSpritedWin* self = new (ELeave) CSpritedWin( aWs, aGroup, aParent, aGc );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

void CSpritedWin::LoadConfiguration(const MTestStepConfigurationContext* aContext)

	{

	aContext->GetBool(KT_WservStressParamEnabled, iEnabled);

	aContext->GetBool(KT_WservStressParamTransparent, iTransparent);

	aContext->GetBool(KT_WservStressParamRandomizePenStyle, iRandomizePenStyle);

	aContext->GetBool(KT_WservStressParamRandomizeBrushStyle, iRandomizeBrushStyle);

	aContext->GetBool(KT_WservStressParamRandomizeDrawMode, iRandomizeDrawMode);

	aContext->GetBool(KT_WservStressParamTransparentForegroundWindow, iTransparentForegroundWindow);

	aContext->GetInt(KT_WservStressParamMaxRandomStepX, iMaxRandomStepX);

	aContext->GetInt(KT_WservStressParamMaxRandomStepY, iMaxRandomStepY);

	aContext->GetInt(KT_WservStressParamMaxRandomOffsetX, iMaxRandomOffsetX);

	aContext->GetInt(KT_WservStressParamMaxRandomOffsetY, iMaxRandomOffsetY);

	}

CSpritedWin::~CSpritedWin()

	{ 

	if (iForeWin)

		{

		iForeWin->Close();

		delete iForeWin;

		}

	iSprite.Close();

	TInt idx;

	for ( idx = 0; idx < ENofSlides; idx++)

		{

		delete iSpriteCntDevice [idx];

		delete iSpriteMskDevice [idx]; 

		delete iSpriteContent[idx];

		delete iSpriteMask[idx];

		}

	}

void CSpritedWin::Redraw(const TRect& aRect)

	{

	if (iSpriteStartup == 0)

		{

		//first time getting here should be very close to the sprite activation time

		iSpriteStartup = User::NTickCount();

		}

	iWsGc.Activate(*iWindow);

	iRedrawWindow->BeginRedraw( aRect );

	iWsGc.Reset();

	//draw rectangle filling window area

	iWsGc.SetPenStyle( iPenStyle );

	iWsGc.SetBrushStyle( iBrushStyle );

	iWsGc.SetBrushColor( iBgColor );

	iWsGc.SetPenColor( iBgColor );

	iWsGc.SetDrawMode(iDrawMode);

	TRect drawRect( TPoint(0,0), iSize );

	iWsGc.DrawRect( drawRect );

	iRedrawWindow->EndRedraw();

	iWsGc.Deactivate();	

	}

void CSpritedWin::DrawBitmap(CFbsBitGc* aGc, TRect& aClip, TPoint& aOrigin)

	{

	if (iSpriteStartup == 0)

		{

		//although bitmap drawing requested, sprite was not yet rendered - skip

		return;

		}

	aGc->Reset();

	TPoint origin = iPos + aOrigin;

	aGc->SetOrigin(origin);

	TRect clip(origin, iSize);

	clip.Intersection(aClip);

	clip.Move(-origin);

	aGc->SetClippingRect(clip);

	// draw win

	aGc->SetPenStyle(iPenStyle);

	aGc->SetBrushStyle(iBrushStyle);

	aGc->SetBrushColor( iBgColor );

	aGc->SetPenColor( iBgColor );

	aGc->SetDrawMode(iDrawMode);

	aGc->DrawRect(TRect(TPoint(0,0), iSize));

	// emulate sprite, cur frame

	// time (in ticks) passed since sprite activation

	TUint64 delta = TTickUtils::CalcTickDelta( iVerifyTick, iSpriteStartup );

	// time for a single slide (in microseconds)

	TUint slideDur  = iSlideDuration.Int();

	TInt slideNo = TUint32( ( (delta * iKernelTicksPeriod ) / slideDur ) % ENofSlides );

	TPoint spritePos( iSize.iWidth / 2 - ESpriteSzXHalf, 

			iSize.iHeight / 2 - ESpriteSzYHalf );

	TSize spriteSize(ESpriteSzX, ESpriteSzY);

	TRect	spriteRect ( TPoint(0,0), spriteSize );

	TRect   destRect( spritePos, spriteSize );

	destRect.Move(iSpriteDef[slideNo].iOffset);

	aGc->DrawBitmapMasked( destRect, 

						   iSpriteContent[slideNo], 

						   spriteRect, 

						   iSpriteMask[slideNo],

						   EFalse);

	// inherited

	CCompWin::DrawBitmap(aGc, aClip, aOrigin);	

	}

void CSpritedWin::ClearBitmapBackground(CFbsBitGc* aGc, TRect& aClip, TPoint& aOrigin)

	{

	if (iSpriteStartup == 0)

		{

		//although bitmap drawing requested, sprite was not yet rendered - skip

		return;

		}

	CCompWin::ClearBitmapBackground(aGc, aClip, aOrigin);

	}

void CSpritedWin::SetSize(const TSize & aSize)

	{

	CCompWin::SetSize( aSize );

	if ( iConstructed )

		{		

		TPoint spritePos( iSize.iWidth / 2 - ESpriteSzXHalf, 

				iSize.iHeight / 2 - ESpriteSzYHalf );

		iSprite.SetPosition( spritePos );

		}

	if (iForeWin)

		{

		iForeWin->SetExtent(TPoint(iPos.iX-sInvisibleFrame, iPos.iY-sInvisibleFrame), 

	            TSize(iSize.iWidth+2*sInvisibleFrame, iSize.iHeight+2*sInvisibleFrame));

		}

	}

void CSpritedWin::SetPos(const TPoint & aPos)

	{

	CCompWin::SetPos( aPos );

	if (iForeWin)

		{

		iForeWin->SetPosition(TPoint(iPos.iX-sInvisibleFrame, iPos.iY-sInvisibleFrame));

		}

	}

CSpritedWin::CSpritedWin(RWsSession& aWs, RWindowGroup* aGroup, CCompWin* aParent, CWindowGc& aGc):

	CCompWin( aWs, aGroup, aParent, aGc ), iSprite ( aWs ), iForeWin(NULL)

	{

	iBgColor 	= TRnd::rnd();

	if (!iTransparent)

		{

		iBgColor.SetAlpha(255);

		}

	iSlideDuration = (TRnd::rnd( ESlideDurMaxTenthSec ) + 1) * ESlideDurMult;

	HAL::Get( HAL::ENanoTickPeriod, iKernelTicksPeriod );	

	}

void CSpritedWin::ConstructL()

	{

	// prepare surface

	CCompWin::PreConstructL(iTransparent);

	TInt idx, err = KErrNone;

	TRect rect;

	CGraphicsContext* gCtxSpr = NULL;

	CGraphicsContext* gCtxMsk = NULL;

	// init sprite handles

	TPoint spritePos( iSize.iWidth / 2 - ESpriteSzXHalf, 

			iSize.iHeight / 2 - ESpriteSzYHalf );

	err = iSprite.Construct( *iWindow, spritePos, ESpriteNoChildClip  );

	User::LeaveIfError( err );

	iPenStyle = iRandomizePenStyle ? GetRandomPenStyle() : CGraphicsContext::ESolidPen;

	iBrushStyle = iRandomizeBrushStyle ? GetRandomBrushStyle() : CGraphicsContext::ESolidBrush;

	iDrawMode = iRandomizeDrawMode ? GetRandomDrawMode() : CGraphicsContext::EDrawModePEN;

	TInt stepx = iMaxRandomStepX > 0 ? TRnd::rnd(2*iMaxRandomStepX) - iMaxRandomStepX : 0;

	TInt stepy = iMaxRandomStepY > 0 ? TRnd::rnd(2*iMaxRandomStepY) - iMaxRandomStepY : 0;

	TInt offsetx = iMaxRandomOffsetX > 0 ? TRnd::rnd(2*iMaxRandomOffsetX) - iMaxRandomOffsetX : 0;

	TInt offsety = iMaxRandomOffsetY > 0 ? TRnd::rnd(2*iMaxRandomOffsetY) - iMaxRandomOffsetY : 0;

	// create sprites & masks

	for ( idx = 0; idx < ENofSlides; idx++)

		{

		iSpriteContent[idx] = new (ELeave) CFbsBitmap();

		iSpriteMask[idx]	= new (ELeave) CFbsBitmap();;

		err = iSpriteContent[idx]->Create(TSize(ESpriteSzX,ESpriteSzY), EColor64K);

		User::LeaveIfError( err );

		err = iSpriteMask[idx]->Create(TSize(ESpriteSzX,ESpriteSzY), EColor64K);

		User::LeaveIfError( err );

		iSpriteCntDevice [idx] = CFbsBitmapDevice::NewL (iSpriteContent[idx]);

		iSpriteMskDevice [idx] = CFbsBitmapDevice::NewL (iSpriteMask[idx]);

		// draw sprite content

		err = iSpriteCntDevice[idx]->CreateContext( gCtxSpr );

		User::LeaveIfError( err );

		CleanupStack::PushL( gCtxSpr );

		err = iSpriteMskDevice[idx]->CreateContext( gCtxMsk );

		User::LeaveIfError( err );

		CleanupStack::PushL( gCtxMsk );

		gCtxSpr->SetPenStyle(CGraphicsContext::ESolidPen);

		gCtxSpr->SetPenColor(KRgbWhite);

		gCtxSpr->SetBrushColor(KRgbWhite);

		gCtxSpr->SetBrushStyle( iBrushStyle );

		gCtxMsk->SetPenStyle(CGraphicsContext::ESolidPen);

		gCtxMsk->SetPenColor(KRgbBlack);

		gCtxMsk->SetBrushColor(KRgbBlack);

		gCtxMsk->SetBrushStyle( CGraphicsContext::ESolidBrush );

		rect.SetRect( 0, 0, ESpriteSzX, ESpriteSzY );

		gCtxSpr->DrawRect( rect );

		gCtxMsk->DrawRect( rect );

		// cross mask

		gCtxMsk->SetBrushColor(KRgbWhite);

		gCtxMsk->SetPenColor(KRgbWhite);

		rect.SetRect( ESpriteSzXHalf - EStepWidth * (idx + 1), 0, 

					  ESpriteSzXHalf + EStepWidth * (idx + 1), ESpriteSzY );

		gCtxMsk->DrawRect( rect );

		rect.SetRect( 0, ESpriteSzYHalf - EStepHeight * (idx + 1),

				      ESpriteSzX, ESpriteSzYHalf + EStepHeight * (idx + 1) );

		gCtxMsk->DrawRect( rect );

		CleanupStack::PopAndDestroy( gCtxMsk );		

		CleanupStack::PopAndDestroy( gCtxSpr );		

		// make sprite

		iSpriteDef[idx].iBitmap 		= iSpriteContent[idx];

		iSpriteDef[idx].iMaskBitmap	= iSpriteMask[idx];

		iSpriteDef[idx].iOffset		= TPoint( offsetx+idx*stepx, offsety+idx*stepy );

		iSpriteDef[idx].iDrawMode		= CGraphicsContext::EDrawModeAND;

		iSpriteDef[idx].iInvertMask	= EFalse;

		iSpriteDef[idx].iInterval		= iSlideDuration;

		err = iSprite.AppendMember( iSpriteDef[idx] );

		User::LeaveIfError( err );

		}

	//Create a transparent foreground window, moving and resizing with the sprite window

	if (iTransparentForegroundWindow)

		{

		iForeWin = new(ELeave) RBlankWindow(iWs);

		iForeWin->Construct(*iGroup,reinterpret_cast<TUint32>(iForeWin));

		iForeWin->SetColor(TRgb(0, 0, 0, 0));	//a transparent window

		iForeWin->SetExtent(TPoint(iPos.iX-sInvisibleFrame, iPos.iY-sInvisibleFrame), 

				            TSize(iSize.iWidth+2*sInvisibleFrame, iSize.iHeight+2*sInvisibleFrame));

		iForeWin->SetOrdinalPosition(0);

		iForeWin->Activate();

		}

	// finally

	CCompWin::PostConstructL();	

	iSpriteStartup = 0;

	// show up the sprite

	err = iSprite.Activate();

	User::LeaveIfError( err );

	iConstructed = ETrue;

	}

TBool CSpritedWin::QueryReadyForVerification()

	{

	TBool res;

	// time (in ticks) passed since sprite activation

	TUint64 delta = TTickUtils::CalcTickDelta( iVerifyTick, iSpriteStartup );

	// time for a single slide (in microseconds)

	TUint slideDur  = iSlideDuration.Int();

	// time for all sprite slides (in microseconds)

	TUint spriteDur = slideDur * ENofSlides;

	// time passed since begining of sprite sequence (in microseconds)

	TUint64 sense = (delta * iKernelTicksPeriod ) % spriteDur; // microsec

	res = (sense >= EFrameBorderSenseMs);

	res = res && CCompWin::QueryReadyForVerification();

	return res;

	}

void CSpritedWin::DumpDetails(RFile& aFile, TInt aDepth)

	{

	TBuf8<256> buf;

	buf.SetLength(0);

	for (TInt d = 0; d < aDepth; ++d)

		{

		buf.Append(_L8("  "));

		}

	buf.Append(_L8("Transparent = ["));

	buf.AppendNum((TInt64)iTransparent);

	buf.Append(_L8("] pen_style = ["));

	buf.AppendNum((TInt64)iPenStyle);

	buf.Append(_L8("] brush_style = ["));

	buf.AppendNum((TInt64)iBrushStyle);

	buf.Append(_L8("] draw_mode = ["));

	buf.AppendNum((TInt64)iDrawMode);

	buf.Append(_L8("] transparent_foreground_window = ["));

	buf.AppendNum((TInt64)iTransparentForegroundWindow);

	buf.Append(_L8("] max_random_step_x = ["));

	buf.AppendNum((TInt64)iMaxRandomStepX);

	buf.Append(_L8("] max_random_step_y = ["));

	buf.AppendNum((TInt64)iMaxRandomStepY);

	buf.Append(_L8("] max_random_offset_x = ["));

	buf.AppendNum((TInt64)iMaxRandomOffsetX);

	buf.Append(_L8("] max_random_offset_y = ["));

	buf.AppendNum((TInt64)iMaxRandomOffsetY);

	buf.Append(_L8("]\r\n"));

	aFile.Write(buf);

	}