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

// Test redraw storing

// Tests Storing the Redraw command mechanism in the window server.

// The first time a window is redrawn its commands are stored. When

// the window needs to be redrawn, the stored commands will be used

// rather than issue a redraw request to the client.

// The principle behind this test is to do lots of different types of drawing to a window,

// invalidate the window and test that no redrawing occurred, instead the stored commands

// should be used to generate the content of the window.

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TREDRSTR.H"

#include "colorblender.h"

//#define LOGGING on

_LIT(KColorUnmatchedFormat, "Check failed, expected color value: 0x%08x, got: 0x%08x");

#define TEST_COLOR_MATCH(aExpected, aActual) \

	TEST(aExpected == aActual); \

	if(aExpected != aActual) \

		LOG_MESSAGE3(KColorUnmatchedFormat, aExpected.Value(), aActual.Value())

/*CPartialRedrawWin*/

void CPartialRedrawWin::Init()

	{

	iClientDrawn = EFalse;

	iClientCanDraw = ETrue;

	Win()->SetRequiredDisplayMode(EColor16MA);

	Win()->SetTransparencyAlphaChannel();

	Win()->SetBackgroundColor(TRgb(127,127,127,0));

	}

void CPartialRedrawWin::Draw()

	{

	DoDraw(*iGc);

	}

void CPartialRedrawWin::DrawToBmp(CGraphicsContext& aGc)

	{

	DoDraw(aGc);

	}	

void CPartialRedrawWin::DoDraw(CGraphicsContext& aGc)

	{

	if(!iClientCanDraw) return;

	iClientDrawn = ETrue;

	CPartialRedrawWin::DrawRects(aGc, iSize, TPoint(0,0), ETrue, EPartialRedraw_Unknown);

	}

/*static*/

void CPartialRedrawWin::DrawRects(CGraphicsContext& aGc, TSize aSize, TPoint aPosition, 

	TBool aIsFullRedraw, TPartialRedrawType aPartialRedrawType)

	{

	aGc.SetPenStyle(CGraphicsContext::ESolidPen);

	aGc.SetPenColor(TRgb::Gray256(0));

	aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

	if(aIsFullRedraw)

		{

		aGc.SetBrushColor(TRgb(200,200,200,127));

		aGc.DrawRect(TRect(aPosition, aSize));

		}

	else if (aPartialRedrawType!=EPartialRedraw_PreserveStoredCmds)

		{

		aGc.SetBrushColor(TRgb(200,200,200,127));	// same color as original background.

		aGc.SetPenStyle(CGraphicsContext::ENullPen);

		aGc.DrawRect(TRect(TPoint(10,10) + aPosition, aSize - TSize(20,20)));

		aGc.SetPenStyle(CGraphicsContext::ESolidPen);

		aGc.SetPenColor(TRgb::Gray256(0));

		}

	TSize r1 = TSize(aSize.iWidth/3, aSize.iHeight/5);

	TSize r2 = TSize(aSize.iWidth/9, 2*aSize.iHeight/3);

	aGc.SetBrushColor(TRgb(255, 0, 0, 127));

	aGc.DrawEllipse(TRect(TPoint(aSize.iWidth/3, aSize.iHeight/5)+aPosition, r1));

	aGc.SetBrushColor(TRgb(0, 255, 0, 127));

	aGc.DrawEllipse(TRect(TPoint(aSize.iWidth/3, 3*aSize.iHeight/5)+aPosition, r1));

	aGc.SetBrushColor(TRgb(0, 0, 255, 127));

	aGc.DrawEllipse(TRect(TPoint(4*aSize.iWidth/9, aSize.iHeight/6)+aPosition, r2));

	}

void CPartialRedrawWin::DrawPartial(TPartialRedrawType aPartialRedrawType)

	{

	TRect rect = TRect(TPoint(10,10), iSize - TSize(20,20));

	Invalidate(rect);

	Win()->BeginRedraw(rect);

	iGc->Activate(*Win());

	CPartialRedrawWin::DrawRects(*iGc, iSize, TPoint(0,0), EFalse, aPartialRedrawType);

	iGc->Deactivate();

	Win()->EndRedraw();

	}

void CPartialRedrawWin::RedrawSubRectWithBitmapL(TRgb aBitmapColour)

	{

	TInt bitmapWidth = Win()->Size().iWidth - 20;

	TInt bitmapHeight = Win()->Size().iHeight - 20;

	TSize bitmapSize(bitmapWidth, bitmapHeight);

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

	CleanupStack::PushL(fbsBitmap);

	User::LeaveIfError(fbsBitmap->Create(bitmapSize, EColor16MU));

	// ensure colour is opaque

	aBitmapColour.SetAlpha(255);

	// draw on the bitmap

	TBitmapUtil bmpUtil(fbsBitmap);

	bmpUtil.Begin(TPoint(0, 0));

	TInt row, col;

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

		{

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

		for(col = 0; col < bitmapHeight; ++col)

			{ // diagonal stripes

			if ( ((col + row) % 8) < 4 )

				{ // colour

				bmpUtil.SetPixel(aBitmapColour.Color16M());

				}

			else

				{ // semi-transparent white

				TRgb white(255, 255, 255, 128);

				bmpUtil.SetPixel(white.Color16M());

				}

			bmpUtil.IncYPos();

			}

		}

	bmpUtil.End();

	// send bitmap to screen

	TRect rect = TRect(TPoint(10,10), bitmapSize);

	Invalidate(rect);

	Win()->BeginRedraw(rect);

	iGc->Activate(*Win());

	iGc->DrawBitmap(rect, fbsBitmap);

	iGc->Deactivate();

	Win()->EndRedraw();

	CleanupStack::PopAndDestroy(fbsBitmap);

	}

/* CResetRedrawStoreWin */

const TInt KResetRedrawMaxAnimState=4;

void CResetRedrawStoreWin::PreSetSize(const TSize &aSize)

// Sets the size variable so draw code using it will use the new size

// before the window has actually been resized

	{

	iSize=aSize;

	}

void CResetRedrawStoreWin::Draw()

	{

	DoDraw(*iGc);

	}

void CResetRedrawStoreWin::DoDraw(CGraphicsContext& aGc) const

	{

	aGc.SetPenStyle(CGraphicsContext::ESolidPen);

	aGc.SetPenColor(KRgbBlack);

	aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

	aGc.SetBrushColor(TRgb(200,200,200,127));

	aGc.DrawRect(TRect(iSize));

	TSize r1(iSize.iWidth/3, iSize.iHeight/5);

	TSize r2(iSize.iWidth/9, 2*iSize.iHeight/3);

	aGc.SetBrushColor(TRgb(255, 0, 0, 127));

	aGc.DrawEllipse(TRect(TPoint(iSize.iWidth/3, iSize.iHeight/5), r1));

	aGc.SetBrushColor(TRgb(0, 255, 0, 127));

	aGc.DrawEllipse(TRect(TPoint(iSize.iWidth/3, 3*iSize.iHeight/5), r1));

	aGc.SetBrushColor(TRgb(0, 0, 255, 127));

	aGc.DrawEllipse(TRect(TPoint(4*iSize.iWidth/9, iSize.iHeight/6), r2));

	DoDrawAnim(aGc);

	}

TRect CResetRedrawStoreWin::AnimRect() const

	{

	if (iUpdateInRedraw)

		{

		TInt row=iAnimState/iSize.iWidth;

		TInt col=iAnimState-row*iSize.iWidth;

		return(TRect(col,row,col+4,row+4));

		}

	return(TRect(iSize.iWidth/6,iSize.iHeight/4,iSize.iWidth*5/6,iSize.iHeight*3/4));

	}

void CResetRedrawStoreWin::DoDrawAnim(CGraphicsContext& aGc) const

	{

	if (iAnimState>0)

		{

		aGc.SetBrushColor(KRgbBlue);

		aGc.SetPenStyle(CGraphicsContext::ENullPen);

		aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

		TInt animColState=iAnimState%KResetRedrawMaxAnimState;

		TRgb animCol(255*animColState/KResetRedrawMaxAnimState,0,255*(KResetRedrawMaxAnimState-animColState)/KResetRedrawMaxAnimState);

		aGc.SetBrushColor(animCol);

		aGc.DrawRect(AnimRect());

		}

	}

CResetRedrawStoreWin::~CResetRedrawStoreWin()

	{

	delete iExtraGc;

	}

void CResetRedrawStoreWin::SetUpdateInRedraw(TBool aUpdateInRedraw)

	{

	iUpdateInRedraw=aUpdateInRedraw;

	}

void CResetRedrawStoreWin::SetKeepGcActive(TBool aState)

	{

	if (iKeepGcActive!=aState)

		{

		iKeepGcActive=aState;

		if (iKeepGcActive)

			{

			iExtraGc=new(ELeave) CWindowGc(TheClient->iScreen);

			iExtraGc->Construct();

			iExtraGc->Activate(*Win());

			}

		else

			{

			iExtraGc->Deactivate();

			delete iExtraGc;

			iExtraGc=NULL;

			}

		}

	}

TBool CResetRedrawStoreWin::Failed() const

	{

	return iFailed;

	}

void CResetRedrawStoreWin::UpdateAnim(TInt aSteps)

	{

	TRect oldAnimRect(AnimRect());

	iAnimState+=aSteps;

	if (iUpdateInRedraw)

		{

		if (iAnimState>=(iSize.iWidth*iSize.iHeight))

			{

			iFailed=ETrue;

			}

		}

	else if (iAnimState>KResetRedrawMaxAnimState)

		{

		iAnimState-=KResetRedrawMaxAnimState;

		}

	CWindowGc *gc=Gc();

	if (iUpdateInRedraw)

		{

		Win()->Invalidate(oldAnimRect);

		Win()->BeginRedraw(oldAnimRect);

		if (iKeepGcActive)

			{

			DoDraw(*iExtraGc);

			}

		else

			{

			gc->Activate(*Win());

			DoDraw(*gc);

			gc->Deactivate();

			}

		Win()->EndRedraw();

		TRect animRect=AnimRect();

		Win()->Invalidate(animRect);

		Win()->BeginRedraw(animRect);

		}

	if (iKeepGcActive)

		DoDrawAnim(*iExtraGc);

	else

		{

		gc->Activate(*Win());

		DoDrawAnim(*gc);

		gc->Deactivate();

		}

	if (iUpdateInRedraw)

		Win()->EndRedraw();

	}

void CTRedrawStoring::GetTestWinSizeAndPos(TInt aWinIndex, TPoint& aPos, TSize& aSize) const

	{

	switch(aWinIndex)

		{

		case 0:

			// Centered window half the width of the parent window

			aSize.iWidth=iWinSize.iWidth/2;

			aSize.iHeight=iWinSize.iHeight/2;

			aPos.iX=iWinSize.iWidth/4;

			aPos.iY=iWinSize.iHeight/4;

			break;

		case 1:

			// 1/3rd parent window size window positioned 1/3rd spare size in from the bottom right

			aSize.iWidth=iWinSize.iWidth/3;

			aSize.iHeight=iWinSize.iHeight/3;

			aPos.iX=(iWinSize.iWidth-aSize.iWidth)*2/3;

			aPos.iY=(iWinSize.iHeight-aSize.iHeight)*2/3;

			break;

		}

	}

/*CRedrawStoreWin*/

void CRedrawStoreWin::Draw()

	{

	if (iTest->iQueueTest)

		iDrawOrder=iTest->iDrawOrder++;

	iTest->DoDrawingL(iGc);

	}

/*CNoDrawWin*/

void CNoDrawWin::Draw()

	{

	//Deliberately  have no drawing

	}

/*CBitmapMaskedWin*/

CBitmapMaskedWin* CBitmapMaskedWin::NewL(CFbsBitmap* aFbsBitmap,CFbsBitmap* aFbsMaskBitmap,

										CWsBitmap* aWsBitmap,CWsBitmap* aWsMaskBitmap,

										TRgb aBackground,TRect aRect,TBool aInvertMask,TBool aWsFbs)

	{

	CBitmapMaskedWin* self=new(ELeave) CBitmapMaskedWin(aFbsBitmap,aFbsMaskBitmap,aWsBitmap,

														aWsMaskBitmap,aRect,aInvertMask,aWsFbs);

	CleanupStack::PushL(self);

	self->ConstructL(*TheClient->iGroup);

	self->AssignGC(*TheClient->iGc);

	self->BaseWin()->SetRequiredDisplayMode(EColor16MU);

	self->Win()->SetBackgroundColor(aBackground);

	CleanupStack::Pop(self);

	return self;

	}

CBitmapMaskedWin::~CBitmapMaskedWin()

	{

	delete iFbsBitmap;

	delete iFbsMaskBitmap;

	delete iWsBitmap;

	if (!iWsFbs)

		{

		delete iWsMaskBitmap;	

		}

	}

void CBitmapMaskedWin::SetDestRectSize(const TSize aSize)

	{

	iRect.SetSize(aSize);

	}

void CBitmapMaskedWin::Draw()

	{

	if (iWsFbs)

		{

		TheClient->iGc->DrawBitmapMasked(iRect,iWsBitmap,TRect(iWsBitmap->SizeInPixels()),iWsMaskBitmap,iInvertMask);

		}

	else

		{

		TheClient->iGc->DrawBitmapMasked(iRect,iFbsBitmap,TRect(iFbsBitmap->SizeInPixels()),iFbsMaskBitmap,iInvertMask);

		}

	}

/* TESTCASE:	DEF095130

 * TITLE:		Redraw store for Alpha Channel Transparency.

 * IMPORTANCE:	1

 *

 * ACTION: a. Creates a window disable the redrawstore. Set the Alpha channel

 * Transparency.

 *

 * RESULT: Redraw store should be enabled and should redraw correctly.

 */

void CTRedrawStoring::DoRedrawStoreAlphaChannelTransTest()

	{

	// Create testwin and disable the redraw store

	// Set alpha transparency and check if redraw store is enabled

	RWindow win(TheClient->iWs);

	CleanupClosePushL(win);

	User::LeaveIfError(win.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle));

	win.SetExtent(iWinPos, iWinSize);

	win.SetRequiredDisplayMode(EColor256);

	win.EnableRedrawStore(EFalse);

	win.SetTransparencyAlphaChannel();

	TEST(win.IsRedrawStoreEnabled());

	CleanupStack::PopAndDestroy(&win);

	// Create a window and disable the redraw store

	// Set alpha transparency and check if redraw store is enabled

	// and check if redraw storing is done correctly

	RWindow wint(TheClient->iWs);

	CleanupClosePushL(wint);

	User::LeaveIfError(wint.Construct(*TheClient->iGroup->GroupWin(), ENullWsHandle));

	wint.SetExtent(iWinPos, iWinSize);

	wint.SetRequiredDisplayMode(iTestDisplayMode);

	wint.SetBackgroundColor(TRgb(255,255,255));

	wint.SetShadowDisabled(ETrue);

	wint.EnableRedrawStore(EFalse);

	wint.SetTransparencyAlphaChannel();

	wint.Activate();

	wint.BeginRedraw();

	TheClient->iGc->Activate(wint);

	DoDrawingL(23,TheClient->iGc,ETrue);

	TheClient->iGc->Deactivate();

	wint.EndRedraw();

	DoDrawingL(23,iCheckGc,EFalse);

	iCheckWin->BackedUpWin()->UpdateScreen();

	iBlankWin.SetOrdinalPosition(0);

	iBlankWin.SetVisible(ETrue);

	iBlankWin.SetVisible(EFalse);

	TheClient->Flush();

	TheClient->WaitForRedrawsToFinish();

	TInt gap = 5;

	const TSize scrSize(TheClient->iScreen->SizeInPixels());

	TEST(TheClient->iScreen->RectCompare(TRect(TPoint(scrSize.iWidth-2*iWinSize.iWidth-gap,0),iWinSize),TRect(TPoint(scrSize.iWidth-iWinSize.iWidth,0),iWinSize)));

	CleanupStack::PopAndDestroy(&wint);

	}

/* TESTCASE:	PDEF091091

 * TITLE:		Redraw in between begin and end redraw.

 * IMPORTANCE:	1

 *

 * ACTION: Draws some content to test window in its redraw. Then starts drawing 

 * to test window by using BeginRedraw and EndRedraw methods. A blank window in 

 * front of test wndow is made visible and invisible in between BeginRedraw and

 * EndRedraw.

 * 

 *

 * RESULT: When the window is made visible again redraw should ot happen.

 */

void CTRedrawStoring::DoBeginEndRedraw()

	{

	// Check whether redrawstoring is working

	RedrawWindows();

	iBlankWin.SetVisible(ETrue);

	iBlankWin.SetVisible(EFalse);

	iClientDidDraw = EFalse;

	CheckWindowsMatch();

	TEST(!iClientDidDraw);

	if(iClientDidDraw != 0)

		INFO_PRINTF3(_L("iClientDidDraw Expected value %d Actual value %d"), 0, iClientDidDraw);

	// Change the size and make the blank window visible

	// Then start drawing by BeginRedraw and Activating its gc

	// Now make the blank window visible

	iTestWin->Win()->Invalidate();

	iBlankWin.SetSize(TSize(40,40));

	iBlankWin.SetVisible(ETrue);

	CWindowGc* gc = iTestWin->Gc();

	RWindow* win = iTestWin->Win();

	win->BeginRedraw();

	gc->Activate(*win);

	gc->SetPenStyle(CGraphicsContext::ESolidPen);

	gc->SetPenColor(TRgb(0,0,0));

	gc->SetPenSize(TSize(1,1));

	gc->DrawLine(TPoint(iWinSize.iWidth,0), TPoint(0, iWinSize.iHeight));

	iBlankWin.SetVisible(EFalse);

	gc->DrawLine(TPoint(0,0), TPoint(iWinSize.iWidth, iWinSize.iHeight));

	iBlankWin.SetVisible(ETrue);

	gc->DrawLine(TPoint(iWinSize.iWidth/2,0), TPoint(iWinSize.iWidth/2, iWinSize.iHeight));

	gc->DrawLine(TPoint(0,iWinSize.iHeight/2), TPoint(iWinSize.iWidth, iWinSize.iHeight/2));

	iCheckGc->Clear();

	iCheckGc->SetPenStyle(CGraphicsContext::ESolidPen);

	iCheckGc->SetPenColor(TRgb(0,0,0));

	iCheckGc->SetPenSize(TSize(1,1));

	iCheckGc->DrawLine(TPoint(iWinSize.iWidth/2,0), TPoint(iWinSize.iWidth/2, iWinSize.iHeight));

	iCheckGc->DrawLine(TPoint(0,iWinSize.iHeight/2), TPoint(iWinSize.iWidth, iWinSize.iHeight/2));

	iCheckGc->DrawLine(TPoint(0,0), TPoint(iWinSize.iWidth, iWinSize.iHeight));

	iCheckGc->DrawLine(TPoint(iWinSize.iWidth,0), TPoint(0, iWinSize.iHeight));

	iCheckWin->BackedUpWin()->UpdateScreen();

	iBlankWin.SetVisible(EFalse);

	// This is to check if any redraw happened in between Begin and EndRedraw

	/* Andy commented this out.  I'm not entirely sure what it's doing.  We just redrew a window

	while part of it was hidden, and then revealed the hidden part before calling EndRedraw, and

	this is testing that the new draw commands for the region revealed are not processed, or are not

	processed correctly. In the new window server they are processed and the region checked matches

	the test bitmap. */

//	TInt gap = 5;

//	const TSize scrSize(TheClient->iScreen->SizeInPixels());

//	TBool failed=DoCheckRect(TPoint(scrSize.iWidth-2*iWinSize.iWidth-gap,0),TPoint(scrSize.iWidth-iWinSize.iWidth,0),TSize(40,40));

	gc->Deactivate();

	win->EndRedraw();

/*	if (failed)

		{

		TEST(EFalse);

		return;

		} */

	// This is to check redraw is done after EndRedraw has called.

	iBlankWin.SetVisible(ETrue);

	iBlankWin.SetVisible(EFalse);

	CheckRect(iTestWin,iCheckWin,TRect(TSize(40,40)),_L("CTRedrawStoring::DoBeginEndRedraw"));

	// Finally bring every thing to normal

	RedrawWindows();

	CheckWindowsMatch();

	iBlankWin.SetSize(iWinSize);

	}

/**

@SYMTestCaseID			GRAPHICS-WSERV-00XX-0006

@SYMDEF             	INC087721

@SYMTestCaseDesc    	Invisible Redraw Storing Test

						Tests the non-redraw storing commands are stored/executed properly,

						in presence of partial redraw commands.

						When a semi-transparent window ST0 sits on top of an opaque window OW1,