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

// Automatically test the window server

// 

//

#include <e32std.h>

#include <w32std.h>

#include <e32svr.h>

#include <hal.h>

#include "../tlib/testbase.h"

#include <stdlib.h>

#include "AUTO.H"

LOCAL_D const TUint KPanicThreadHeapSize=0x8000;

GLREF_C TInt ProcPriTestOtherProcess(TAny *aScreenNumber);

GLREF_C TInt ProcToKill(TAny *aScreenNumber);

GLREF_C TInt ProcDirect(TAny *aScreenNumber);

GLREF_C TInt ProcMultiDisplay(TAny *aScreenNumber);

_LIT(Priority,"ProcPriTest");

_LIT(ToKill,"ProcToKill");

_LIT(Direct,"ProcDirect");

_LIT(MultiDisplay,"ProcMultiDisplay");

CProcess::TInitialFunction CProcess::iFunctions[]=

	{

	TInitialFunction(Priority,ProcPriTestOtherProcess),

	TInitialFunction(ToKill,ProcToKill),

	TInitialFunction(Direct,ProcDirect),

	TInitialFunction(MultiDisplay,ProcMultiDisplay)

	};

GLDEF_D TestWindow *BaseWin;

GLDEF_D TestWindow *TestWin;

GLDEF_D TestClient *TheClient=NULL;

GLDEF_D CWindowGc *TheGc;

TInt CTestBase::iMaxGrays=0;

TInt CTestBase::iScreenNo=0;

TInt CTestBase::iMaxColors=0;

TInt CTestBase::iNumberTestsPass=0;

TInt CTestBase::iNumberTests=0;

TRect CTestBase::iNormalPointerCursorArea;

TPartialRedrawType CTestBase::iRedrawType=EPartialRedraw_Unknown;

TInt CTestBase::iNumberOfGrpWndsOnPrimaryScreenWithZeroPriority = 0;

TInt CTestDriver::iTestNum=0;

GLDEF_D TInt TheTestResult=ETestPassed; // start with passed to anticipate empty test table

const TInt KBorderWinWidth = 5;

_LIT(Auto,"AUTO ");

TInt64 TTestRects::iSeed=0;

TRect TTestRects::iList[]={

// 0-5

	TRect(2,2,2,2),

	TRect(2,2,2,2),

	TRect(2,2,2,2),

	TRect(2,2,2,2),

	TRect(2,2,2,2),

// 5-13

	TRect(0,0,0,0),

	TRect(2,0,2,0),

	TRect(4,0,4,0),

	TRect(0,2,0,2),

	TRect(2,2,2,2),

	TRect(4,2,4,2),

	TRect(0,4,0,4),

	TRect(2,4,2,4),

	TRect(4,4,4,4),

// 13-22

	TRect(0,0,1,1),

	TRect(1,0,3,1),

	TRect(3,0,4,1),

	TRect(0,1,1,3),

	TRect(1,1,3,3),

	TRect(3,1,4,3),

	TRect(0,3,1,4),

	TRect(1,3,3,4),

	TRect(3,3,4,4),

// 23-31

	TRect(0,0,2,0),

	TRect(2,0,4,0),

	TRect(0,0,4,0),

	TRect(0,2,2,2),

	TRect(2,2,4,2),

	TRect(0,2,4,2),

	TRect(0,4,2,4),

	TRect(2,4,4,4),

	TRect(0,4,4,4),

// 32-40

	TRect(0,0,0,2),

	TRect(0,2,0,4),

	TRect(0,0,0,4),

	TRect(2,0,2,2),

	TRect(2,2,2,4),

	TRect(2,0,2,4),

	TRect(4,0,4,2),

	TRect(4,2,4,4),

	TRect(4,0,4,4),

// 41-44

	TRect(0,0,2,2),

	TRect(2,0,4,2),

	TRect(0,2,2,4),

	TRect(2,2,4,4),

// 45-48

	TRect(0,0,3,3),

	TRect(1,0,4,3),

	TRect(0,1,3,4),

	TRect(1,1,4,4),

// 49

	TRect(0,0,4,4),

// 40-53

	TRect(1,2,2,2),

	TRect(2,2,3,2),

	TRect(2,1,2,2),

	TRect(2,2,3,2),

// 54-59

	TRect(1,2,3,2),

	TRect(2,1,2,3),

	TRect(1,1,2,2),

	TRect(1,2,2,3),

	TRect(2,2,3,3),

	TRect(2,1,3,2),

// 60-63

	TRect(1,1,3,2),

	TRect(1,1,2,3),

	TRect(1,2,3,3),

	TRect(2,1,3,3)};

#if defined(__WINS__)

void FindNonMatchingPixelL(TPoint aPt1,TPoint aPt2,TSize aSize)

// This function is purely for use when debugging to find the first non-matching pixel

// when a check of two on screen rects has failed.

	{

	HBufC8* buf1=HBufC8::NewMaxLC(2*aSize.iWidth);

	HBufC8* buf2=HBufC8::NewMaxLC(2*aSize.iWidth);

	TPtr8 ptr1=buf1->Des();

	TPtr8 ptr2=buf2->Des();

	TInt row=0;

	TBool ret = true;

	for (;row<aSize.iHeight;++row)

		{

		TheClient->iScreen->GetScanLine(ptr1,aPt1,aSize.iWidth,EColor64K);

		TheClient->iScreen->GetScanLine(ptr2,aPt2,aSize.iWidth,EColor64K);

		if (ptr1!=ptr2)

			break;

		++aPt1.iY;

		++aPt2.iY;

		}

	TRgb color1,color2;

	if (row<aSize.iHeight)

		{

		for (TInt col=0;col<aSize.iWidth;++col)

			{

			TheClient->iScreen->GetPixel(color1,aPt1);

			TheClient->iScreen->GetPixel(color2,aPt2);

			if (color1!=color2)

				{	// Break here to find first pixel that didn't match.

				TBuf<256> buf;

				_LIT(KFindNonMatchingPixelFmt,"First non matching pixel (%d,%d)");

				buf.Format(KFindNonMatchingPixelFmt,col,row);

				TheClient->iWs.LogMessage(buf);

				break;

				}

			++aPt1.iX;

			++aPt2.iX;

			}

		}

	CleanupStack::PopAndDestroy(2);

	}

void FindNonMatchingPixel(TPoint aPt1,TPoint aPt2,TSize aSize)

	{

	TRAPD(ignore,FindNonMatchingPixelL(aPt1,aPt2,aSize));

	}

#endif

void AutoPanic(TInt aPanic)

	{

	User::Panic(_L("Auto"),aPanic);

	}

void CleanUpWindow(TAny *aWindow)

	{

	((RWindowTreeNode  *)aWindow)->Close();

	}

void PushWindowL(RWindowTreeNode *aWindow)

	{

	CleanupStack::PushL(TCleanupItem(CleanUpWindow,aWindow));

	}

TBool OpacityAndAlphaSupportedL()

	{

	// If opacity is not implemented, EFalse will be returned

	if(TransparencySupportedL()!=KErrNone)

		return EFalse;

	const TRgb KTransparencyColor(0,0,0);

	RWindow winb(TheClient->iWs);

	CleanupClosePushL(winb);

	RWindow wint(TheClient->iWs);

	CleanupClosePushL(wint);

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

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

	winb.SetExtent(TPoint(0,0), TSize(50,50));

	wint.SetExtent(TPoint(0,0), TSize(50,50));

	winb.SetRequiredDisplayMode(EColor256);

	wint.SetRequiredDisplayMode(EColor256);

	wint.SetTransparencyFactor(KTransparencyColor);

	winb.SetBackgroundColor(TRgb(0,0,255));

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

	winb.Activate();

	wint.Activate();

	wint.BeginRedraw();

	TheClient->iGc->Activate(wint);

	TheClient->iGc->SetOpaque(ETrue);

	TheClient->iGc->SetPenStyle(CGraphicsContext::ENullPen);

	TheClient->iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	TheClient->iGc->SetBrushColor(TRgb(0,255,0));

	TheClient->iGc->DrawRect(TRect(TPoint(0,0), TSize(50,50)));

	TheClient->iGc->SetOpaque(EFalse);

	TheClient->iGc->Deactivate();

	wint.EndRedraw();

	TheClient->Flush();

	// The window should be all green, if opacity is working, or all blue if it isn't.

	// If the window has any other colour, then something has broken.

	TRgb color;

	TheClient->iScreen->GetPixel(color,TPoint(25,25));

	if (color.Red()>0 || ((color.Green()==0) == (color.Blue()==0)))

		User::Leave(KErrGeneral);

	TBool ret=(color.Green()>0);

	CleanupStack::PopAndDestroy(2,&winb); // wint

	return ret;

	}

TInt TransparencySupportedL()

	{

	// Creates a window and enables alpha transparency, if this feature

	// is not enabled, KErrNotSupported will be returned

	RWindow win(TheClient->iWs);

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

	win.SetExtent(TPoint(0,0), TSize(50,50));

	TInt ret=win.SetTransparencyAlphaChannel();

	win.Close();

	return ret;

	}

TInt CheckScalingSupportedOrNot()

	{

	TBool scalingSupported=EFalse;

	TSizeMode originalModeData=TheClient->iScreen->GetCurrentScreenModeAttributes();

	TSizeMode tempData=originalModeData;

	tempData.iScreenScale=TSize(2,2);

	TheClient->iScreen->SetCurrentScreenModeAttributes(tempData);

	TSize scale=TheClient->iScreen->GetCurrentScreenModeScale();

	if (scale.iWidth==2 && scale.iHeight==2)

		{

		scalingSupported=ETrue;

		}

	TheClient->iScreen->SetCurrentScreenModeAttributes(originalModeData);

	TheClient->Flush();

	return scalingSupported;

	}

TBool CheckNonZeroOriginsSupportedOrNot()

	{

	TBool nonZeroOriginsSupported=EFalse;

	TSizeMode sizeMode1=TheClient->iScreen->GetCurrentScreenModeAttributes();

	TSizeMode sizeMode2=sizeMode1;

	sizeMode2.iOrigin=TPoint(30,30);

	TheClient->iScreen->SetCurrentScreenModeAttributes(sizeMode2);

	TPoint origin=TheClient->iScreen->GetCurrentScreenModeScaledOrigin();

	if (origin.iX==30 && origin.iY==30)

		{

		nonZeroOriginsSupported=ETrue;

		}

	TheClient->iScreen->SetCurrentScreenModeAttributes(sizeMode1);

	TheClient->Flush();

	return nonZeroOriginsSupported;

	}

TPoint PhysicalToLogical(TPoint aPhysicalPtMinusOrigin,TSize aScale)

	{

	TPoint logicalPt(aPhysicalPtMinusOrigin);

	if (aScale.iWidth!=1)

		{

		logicalPt.iX=(logicalPt.iX>= 0 ? logicalPt.iX/aScale.iWidth : (logicalPt.iX-(aScale.iWidth-1))/aScale.iWidth);

		}

	if (aScale.iHeight!=1)

		{

		logicalPt.iY=(logicalPt.iY>= 0 ? logicalPt.iY/aScale.iHeight : (logicalPt.iY-(aScale.iHeight-1))/aScale.iHeight);

		}

	return logicalPt;

	}

//

// Log window, logs testing //

//

LogWindow::LogWindow() : CTWin(), iTestTitle(KNullDesC), iSubTitle(KNullDesC), iMessage(KNullDesC)

	{}

void LogWindow::ConstructL(CTWinBase &parent)

	{

	CTWin::ConstructL(parent);

	iTitleHeight=iFont->HeightInPixels()+4;

	}

void LogWindow::DrawSubTitle()

	{

	iGc->DrawText(iSubTitle, TRect(2,iTitleHeight*2,iSize.iWidth-2,iTitleHeight*3),iFont->AscentInPixels(), CGraphicsContext::ECenter);

	}

void LogWindow::DrawMessage()

	{

	iGc->DrawText(iMessage, TRect(1,iTitleHeight*4,iSize.iWidth-2,iTitleHeight*5),iFont->AscentInPixels(), CGraphicsContext::ECenter);

	}

void LogWindow::Draw()

	{

	iGc->SetPenColor(TRgb::Gray16(8));

	iGc->SetPenColor(TRgb::Gray16(0));

	DrawBorder();

	iGc->DrawLine(TPoint(0,iTitleHeight),TPoint(iSize.iWidth,iTitleHeight));

	iGc->DrawText(iTestTitle, TPoint((iSize.iWidth-iFont->TextWidthInPixels(iTestTitle))/2,iFont->AscentInPixels()+2));

	DrawSubTitle();

	DrawMessage();

	}

/**

This function is not used at the moment but I leave it in in case I need it when I improve the logging in 

the log window.

*/

void LogWindow::LogTest(const TDesC &aTitle,TInt aNum)

	{

	_LIT(Test,"Test %d,%S");

	iTestTitle.Format(Test,aNum,&aTitle);

	TLogMessageText buf;

	_LIT(AutoNewTest,"AUTO New Test: ");

	buf.Append(AutoNewTest);

	buf.Append(iTestTitle);

	TheClient->LogMessage(buf);

	iMessage.Zero();

	iWin.Invalidate();

	}

/**

This function is not used at the moment but I leave it in in case I need it when I improve the logging in 

the log window.

*/

const TDesC& LogWindow::LogSubTest(const TDesC &aTitle,TInt aNum)

	{

	_LIT(SubTest,"Sub-Test[%d], %S");

	iSubTitle.Format(SubTest,aNum,&aTitle);

	TLogMessageText buf;

	buf.Append(Auto);

	buf.Append(iSubTitle);

	TheClient->LogMessage(buf);

	iMessage.Zero();

	iGc->Activate(iWin);

	iGc->UseFont((CFont *)iFont);

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	DrawSubTitle();

	DrawMessage();

	iGc->Deactivate();

	TheClient->iWs.Flush();

	return iSubTitle;

	}

const TDesC& LogWindow::LogMessage(TBool aLog,const TDesC& aText,TInt aNum)

	{

	if (aNum!=EDummyValue)

		{

		_LIT(StringInt,"%S %d");

		iMessage.Format(StringInt,&aText,aNum);

		}

	else

		{

		_LIT(String,"%S");

		iMessage.Format(String,&aText);

		}

	iGc->Activate(iWin);

	iGc->UseFont((CFont *)iFont);

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	DrawMessage();

	iGc->Deactivate();

	if (aLog)

		{

		TLogMessageText buf;

		buf.Append(Auto);

		buf.Append(iMessage);

		TheClient->LogMessage(buf);

		}

	TheClient->iWs.Flush();

	return iMessage;

	}

//

// Test window, simple window used to do test graphics in //

//

TestWindow::TestWindow() : CTWin()

	{

	}

TestWindow::~TestWindow()

	{

	delete iBorderWin;

	}

void TestWindow::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc)

	{

	iBorderWin=new(ELeave) CBorderWindow();

	iBorderWin->SetUpL(pos,size,parent,aGc);

	TRAPD(err, CTWin::ConstructL(*iBorderWin));

	if (err==KErrNone)

		{

		SetExt(TPoint(2,2),TSize(size.iWidth-4,size.iHeight-4));

		if (err==KErrNone)

			{

			Activate();

			AssignGC(aGc);

			return;

			}

		}

	delete this;

	User::Leave(err);

	}

void TestWindow::Draw()

	{

	iGc->Clear();

	}

void TestWindow::ClearWin()

	{

	TheGc->Activate(*Win());

	TheGc->Clear();

	TheGc->Deactivate();

	}

void TestWindow::SetBorderExt(TPoint aPos, TSize aSize)

	{

	iBorderWin->SetExt(aPos, aSize);

	}

CBorderWindow* TestWindow::GetBorderWin()

	{

	return iBorderWin;

	}

//

CBorderWindow::CBorderWindow() : CTWin()

	{

	}

void CBorderWindow::ConstructL(CTWinBase &parent)

	{

	CTWin::ConstructL(parent);

	}

void CBorderWindow::Draw()

	{

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

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iGc->SetPenStyle(CGraphicsContext::ENullPen);

	iGc->DrawRect(TRect(Size()));

	}

//

TestWindowGroup::TestWindowGroup(CTClient *aClient) : CTWindowGroup(aClient)

	{

	}

void TestWindowGroup::BecomeOwning()

	{

	iGroupWin.DefaultOwningWindow();

	}

void TestWindowGroup::KeyL(const TKeyEvent &aKey,const TTime &aTime)

	{

	if (aKey.iModifiers&EModifierFunc)

		{

		switch(aKey.iCode)

			{

			case 'f':

				TheClient->Driver()->iTest->TriggerFail();

				break;

			}

		}

	else if (iCurWin)

		iCurWin->WinKeyL(aKey,aTime);

	}

void TestWindowGroup::KeyDownL(const TKeyEvent &aKey,const TTime &aTime)

	{

	if (iCurWin)

		iCurWin->KeyDownL(aKey,aTime);

	}

void TestWindowGroup::KeyUpL(const TKeyEvent &aKey,const TTime &aTime)

	{

	if (iCurWin)

		iCurWin->KeyUpL(aKey,aTime);

	}

//