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

// GETPIXEL.CPP

// Automatically test GetPixel

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TGETPIXEL.H"

CTGetPixel::CTGetPixel(CTestStep* aStep):

	CTWsGraphicsBase(aStep)

	{

	}

CTGetPixel::~CTGetPixel()

	{

	iWindow.Close();

	User::Free(iRgbBuf);

	}

LOCAL_C TInt DoPanicTest(TInt aFunc, TAny *aScreenNumber)

	{

	RWsSession ws;

	if (ws.Connect()==KErrNone)

		switch(aFunc)

			{

			case 1:	// Get pixels into a TPtr 1 pixel too small

				{

				CWsScreenDevice *screen = new(ELeave) CWsScreenDevice(ws);

				User::LeaveIfError(screen->Construct((TInt)aScreenNumber));

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

				TInt bitWid=80;

				TRgb *buf=NULL;

				if (bitmap->Create(TSize(1,bitWid), EGray16)==KErrNone && (buf=(TRgb *)User::Alloc((bitWid-1)*sizeof(TRgb)))!=NULL)

					{

					TPtr8 desc((TUint8 *)buf,(bitWid-1)*sizeof(TRgb));

    				screen->GetScanLine(desc,TPoint(0,0),bitWid, ERgb);

					}

				}

				break;

			}

	return(EWsExitReasonBad);

	}

void CTGetPixel::ClearOutRedraws()

// This has been added because partial redraw store can be triggered to request a

// low priority redraw from the window even though in normal circumstances the window

// would not expect to receive any sort of redraw event.

	{

	iWindow.BeginRedraw();

	iWindow.EndRedraw();

	}

void CTGetPixel::TestPanicsL()

	{

	if (!iTest->IsFullRomL())

		{

		TEST(iTest->TestWsPanicL(DoPanicTest,EWservPanicInvalidParameter,1,(TAny*)iTest->iScreenNumber));

		}

	}

void CTGetPixel::DrawAndCheckLine(const TPoint &aPos,TInt aLen,TRgb aColor)

	{

	TheGc->Activate(iWindow);

	TheGc->SetPenColor(aColor);

	iWindow.BeginRedraw(TRect(aPos,TSize(aLen, 1)));

	TheGc->DrawLine(aPos,aPos+TSize(aLen,0));

	iWindow.EndRedraw();

	TheGc->Deactivate();

	iRgbBuf=(TRgb *)User::ReAlloc(iRgbBuf,aLen*sizeof(TRgb));

	TPtr8 ptr((TUint8 *)iRgbBuf,aLen*sizeof(TRgb));

	TheClient->iScreen->GetScanLine(ptr, aPos+iWindow.InquireOffset(*TheClient->iGroup->WinTreeNode()), aLen, EColor16MA);

	TRgb result(TRgb::Gray16(aColor.Gray16()));

	if (TheClient->iScreen->DisplayMode()==EColor64K)

		result=TRgb::Color64K(result.Color64K());

	for(TInt index=0;index<aLen;index++)

		{

		TEST(iRgbBuf[index]==result);

		}

	}

void CTGetPixel::ConstructL()

	{

	iWindow = TheClient->iWs;

	TheGc->Activate(*BaseWin->Win());

	TheGc->Clear();

	TheGc->SetBrushColor(TRgb::Gray16(0));

	TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	TheGc->SetPenStyle(CGraphicsContext::ENullPen);

	TheGc->DrawRect(TRect(iWinSize));

	TheGc->Deactivate();

	iWindow.Construct(*TheClient->iGroup->GroupWin(),ENullWsHandle);

	iWinSize=TSize(TheClient->iScreen->SizeInPixels());

	iWinSize.iWidth/=3;

	iWinSize.iHeight/=3;

	iWindow.SetRequiredDisplayMode(EGray16);

	TheClient->iWs.Flush();

	iTest->DelayIfFullRomL();	// Need to wait for view server to mess around when display mode changed

	TheClient->WaitForRedrawsToFinish();// otherwise it will stomp on top of our window invalidating it.

	iWindow.SetExtent(TPoint(iWinSize.iWidth,iWinSize.iHeight),iWinSize);

	iWindow.EnableRedrawStore(EFalse);	// Otherwise drawing might trigger a redraw when purging redraw store

	iWindow.Activate();

	iWindow.BeginRedraw();

	iWindow.EndRedraw();

	}

void CTGetPixel::TestCheckRect()

	{

	TSize size(TheClient->iScreen->SizeInPixels());

	TEST(TheClient->iScreen->RectCompare(TRect(size),TRect(TPoint(iTest->StdTestWindowSize().iWidth>>1,0),iTest->StdTestWindowSize()))==EFalse);

	}

void CTGetPixel::DrawColorsL()

	{

	TPoint point(0,0);

	TInt color=-1;

	iWindow.BeginRedraw();

	FOREVER

		{

		TheGc->SetPenColor(TRgb::Color256(++color));

		TheGc->Plot(point);

		if (color==255)

			break;

		if (++point.iX==iWinSize.iWidth)

			{

			point.iX=0;

			if (++point.iY==iWinSize.iHeight)

				break;

			}

		}

	iWindow.EndRedraw();

	}

void CTGetPixel::TestColors(CPalette* aPalette)

	{

	TInt numColors=iWinSize.iWidth;

	TPtr8 ptr(REINTERPRET_CAST(TUint8*,iRgbBuf),numColors*sizeof(TRgb));

	TPtr8 paletteData(NULL,0);

	TInt color=0;

	TPoint point(iWinSize.AsPoint());

	do	{

		if (color+numColors>256)

			numColors=256-color;

		TheClient->iScreen->GetScanLine(ptr,point,numColors,EColor16MA);

		aPalette->GetDataPtr(color,numColors,paletteData);

		TEST(ptr==paletteData);

		color+=numColors;

		} while (color<256 && ++point.iY<2*iWinSize.iHeight);

	}

void CTGetPixel::CheckPaletteL(CPalette*& aPalette)

	{

	User::LeaveIfError(TheClient->iScreen->SetCustomPalette(aPalette));

	TestColors(aPalette);

	delete aPalette;

	User::LeaveIfError(TheClient->iScreen->GetPalette(aPalette));

	TestColors(aPalette);

	}

inline TInt Inc(TInt& aValue)

	{

	if (aValue>255-83)

		aValue-=256-83;

	else

		aValue+=83;

	return aValue;

	}

inline TInt Inc2(TInt& aValue)

	{

	if (aValue>255-41)

		aValue-=256-41;

	else

		aValue+=41;

	return aValue;

	}

void CTGetPixel::PaletteTestL()

	{

	//INFO_PRINTF1(_L("AUTO  PaletteTest "));

	TInt numEntries;

	TBool modifiable;

	TheClient->iScreen->PaletteAttributes(modifiable,numEntries);

	INFO_PRINTF2(_L("Number of entries in the palette %d"), numEntries);

	if(numEntries > 65536)

		{

		INFO_PRINTF1(_L("These test cases has been skipped, as the screen is set up in true colour display mode, where palette is not applicable"));

		return; 

		}

	CPalette* palette=NULL;

	if (!modifiable)

		{

		if (numEntries==4)

			palette=CPalette::NewDefaultL(EGray4);

		else if (numEntries==16)

			palette=CPalette::NewDefaultL(EGray16);

		else

			palette=CPalette::NewL(numEntries);

		//INFO_PRINTF1(_L(" Creating Empty Palette, setting it as palette"));

		TInt err=TheClient->iScreen->SetCustomPalette(palette);

		TEST(err==KErrNoMemory || err==KErrNotSupported || (err==KErrNone && numEntries<=16));		//Series5MX palettes are changeable even though they say they aren't

		//INFO_PRINTF1(_L(" Palette setting test passed OK"));

		delete palette;

		}

	TInt err=iWindow.SetRequiredDisplayMode(EColor256);

	TheGc->Activate(iWindow);

	DrawColorsL();

	//INFO_PRINTF1(_L(" Drawn Colors"));

	TheClient->iScreen->PaletteAttributes(modifiable,numEntries);

	iRgbBuf=STATIC_CAST(TRgb*,User::ReAllocL(iRgbBuf,Max(256,iWinSize.iWidth)*sizeof(TRgb)));

	if (err<KErrNone || modifiable==EFalse)

		{

		//INFO_PRINTF1(_L(" Palette Fixed"));

		TInt err=TheClient->iScreen->GetPalette(palette);

		if (err==KErrNotSupported)

			return;

		User::LeaveIfError(err);

		TestColors(palette);

		delete palette;

		//INFO_PRINTF1(_L(" Tested Palette OK"));

		return;

		}

	//INFO_PRINTF1(_L(" Palette Changeable"));

	TEST(numEntries==256);

	CPalette* defPalette=CPalette::NewDefaultL(EColor256);

	CleanupStack::PushL(defPalette);

	TestColors(defPalette);

	User::LeaveIfError(TheClient->iScreen->GetPalette(palette));

	TestColors(palette);

	TInt color;

	TInt index=0;

	for (color=0;color<256;++color)

		palette->SetEntry(color,TRgb::Gray256(color));

	CheckPaletteL(palette);

	for (color=0;color<256;++color)

		palette->SetEntry(color,TRgb(Inc(index),Inc(index),Inc(index)));

	CheckPaletteL(palette);

	for (color=0;color<256;++color)

		palette->SetEntry(color,TRgb(Inc2(index),Inc2(index),Inc2(index)));

	CheckPaletteL(palette);

	delete palette;

	User::LeaveIfError(TheClient->iScreen->SetCustomPalette(defPalette));

	TestColors(defPalette);

	CleanupStack::PopAndDestroy(defPalette);

	ClearOutRedraws();

	}

void CTGetPixel::RunTestCaseL(TInt /*aCurTestCase*/)

	{

	((CTGetPixelStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(++iTest->iState)

		{

/**

@SYMTestCaseID		GRAPHICS-WSERV-0212

@SYMDEF             DEF081259

@SYMTestCaseDesc    Draw lines and check them by scanning the lines

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Draw lines and then scan them to check that they have

					been drawn correctly

@SYMTestExpectedResults Scanning the lines reveals they have been drawn correctly

*/

		case 1:

			((CTGetPixelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0212"));

			TheClient->iWs.SetAutoFlush(ETrue);

			iTest->LogSubTest(_L("Basic"));

			DrawAndCheckLine(TPoint(0,2),iWinSize.iWidth-2,TRgb::Gray4(0));

			DrawAndCheckLine(TPoint(0,iWinSize.iHeight-2),iWinSize.iWidth,TRgb::Gray4(1));

			DrawAndCheckLine(TPoint(iWinSize.iWidth-1,iWinSize.iHeight-1),1,TRgb::Gray4(2));

			ClearOutRedraws();

			TheClient->iWs.SetAutoFlush(EFalse);

			break;

/**

@SYMTestCaseID		GRAPHICS-WSERV-0213

@SYMDEF             DEF081259

@SYMTestCaseDesc    Draw line on every line of a window and

					check them by scanning the lines

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Draw lines on every line of a window and

					check them by scanning the lines

@SYMTestExpectedResults Scanning the lines reveals they have been drawn correctly

*/

		case 2:

			{

			((CTGetPixelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0213"));

			iTest->LogSubTest(_L("Full window"));

			for(TInt ypos=0;ypos<iWinSize.iHeight;ypos++)

				DrawAndCheckLine(TPoint(0,ypos),iWinSize.iWidth,TRgb::Gray4(0));

			ClearOutRedraws();

			}

			break;

/**

@SYMTestCaseID		GRAPHICS-WSERV-0214

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test the check rect method 

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Use the check rect method to check the image in a window

@SYMTestExpectedResults The check rect method functions correctly

*/

		case 3:

			((CTGetPixelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0214"));

			iTest->LogSubTest(_L("Check Rect"));

			TestCheckRect();

			break;

/**

@SYMTestCaseID		GRAPHICS-WSERV-0215

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test that the GetScanLine method panics correctly 

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Cause the GetScanLine method to panic and chekc the response

@SYMTestExpectedResults The panic for the GetScanLine method is correct

*/

		case 4:

			((CTGetPixelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0215"));

			iTest->LogSubTest(_L("Panic"));

			TestPanicsL();

			break;

/**

@SYMTestCaseID		GRAPHICS-WSERV-0216

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test that CPalette class functions correctly 

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Create a CPalette object and exercise all its methods

@SYMTestExpectedResults The palette functions as exepcted

*/

		case 5:

			((CTGetPixelStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0216"));

			iTest->LogSubTest(_L("Palette Test"));

			PaletteTestL();

			break;

		case 6:

            		((CTGetPixelStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

			((CTGetPixelStep*)iStep)->CloseTMSGraphicsStep();

			TestComplete();

			break;

		}

	((CTGetPixelStep*)iStep)->RecordTestResultL();

	}

__WS_CONSTRUCT_STEP__(GetPixel)