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

// General window tests

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TWINDOW.H"

const TInt ENumCornerInsets=6;

const TInt corner0[ENumCornerInsets]={0,0,0,0,0,0};

const TInt corner1[ENumCornerInsets]={1,0,0,0,0,0};

const TInt corner2[ENumCornerInsets]={2,1,0,0,0,0};

const TInt corner3[ENumCornerInsets]={3,1,1,0,0,0};

const TInt corner5[ENumCornerInsets]={5,3,2,1,1,0};

const TInt KBaseUserEvent=61750;		//0xF136 - a random number that is unlikely to be used by other applicaions for user event sending

//

CWinTestWindow::CWinTestWindow(TRgb aCol) : CBlankWindow(aCol)

	{

	}

CWinTestWindow::~CWinTestWindow()

	{

	delete iChild;

	}

void CWinTestWindow::ConstructL(TPoint pos,TSize size,CTWinBase *aParent, CWindowGc &aGc, TInt aDepth)

	{

	iWin=RWindow(TheClient->iWs);

	User::LeaveIfError(iWin.Construct(*(aParent->WinTreeNode()),ENullWsHandle));

	SetExt(pos,size);

	if (aDepth<3)

		{

		iChild=new(ELeave) CWinTestWindow(TRgb::Gray256(iCol.Gray256()+34));

		size.iWidth-=8;

		size.iHeight-=8;

		iChild->ConstructL(TPoint(4,4),size,this,aGc,aDepth+1);

		}

	Activate();

	AssignGC(aGc);

	}

//

CEvWindowGroup* CEvWindowGroup::NewLC(CTClient* aClient,CTWsGraphicsBase* aTest)

	{

	CEvWindowGroup* self=new(ELeave) CEvWindowGroup(aClient,aTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CEvWindowGroup::CEvWindowGroup(CTClient* aClient,CTWsGraphicsBase* aTest) : CTWindowGroup(aClient), iTest(aTest)

	{}

void CEvWindowGroup::ConstructL()

	{

	CTWindowGroup::ConstructL();

	iGroupWin.EnableReceiptOfFocus(EFalse);

	}

void CEvWindowGroup::SetExpectedEvent(TInt aType)

	{

	iTest->TEST(!iExpectingEvent);

	if (iExpectingEvent)

		{

		_LIT(KLog,"Setting expected event of type %d, when previouse event of type %d has not arrived (GpWinId=%d).");

		iTest->LOG_MESSAGE4(KLog,aType,iExpectedEvent,iGroupWin.Identifier());

		}

	iExpectedEvent=aType;

	iExpectingEvent=ETrue;

	}

void CEvWindowGroup::SendEvent(TInt aType)

	{

	TWsEvent event;

	event.SetType(aType);

	iClient->iWs.SendEventToWindowGroup(iGroupWin.Identifier(),event);

	SetExpectedEvent(aType);

	iClient->Flush();

	}

void CEvWindowGroup::UserEvent(TInt aEventType)

	{

	iTest->TEST(iExpectingEvent && iExpectedEvent==aEventType);

	if (!iExpectingEvent || iExpectedEvent!=aEventType)

		{

		TInt id=iGroupWin.Identifier();

		if (!iExpectingEvent)

			{

			_LIT(KLog,"Event of type %d recieved when not expecting an event (GpWinId=%d).");

			iTest->LOG_MESSAGE3(KLog,aEventType,id);

			}

		else

			{

			_LIT(KLog,"Event of type %d when expecting an event of type %d (GpWinId=%d).");

			iTest->LOG_MESSAGE4(KLog,aEventType,iExpectingEvent,id);

			}

		}

	iExpectingEvent=EFalse;

	}

//

CTWindowTest::CTWindowTest(CTestStep* aStep) : CTWsGraphicsBase(aStep)

	{}

CTWindowTest::~CTWindowTest()

	{

	delete iWin;

	}

void CTWindowTest::ConstructL()

	{}

TInt CTWindowTest::MoveGroup(TAny* aParam)

	{

	RWsSession ws;

	TInt err=ws.Connect();

	if (err==KErrNone)

		{

		TInt command=static_cast<TWindowThreadParam*>(aParam)->iCommand;

		err=ws.SetWindowGroupOrdinalPosition(command&EIdMask,(command&EPosMask)>>EPosShift);

		ws.Finish();

		ws.Close();

		}

	return err;

	}

void CTWindowTest::CreateTestWindowL()

	{

	iWin=new(ELeave) CWinTestWindow(TRgb(0,0,0));

	iWin->ConstructL(TPoint(1,1),TSize(TestWin->Size().iWidth/2,TestWin->Size().iHeight/2),TheClient->iGroup,*TheClient->iGc,0);

	}

void CTWindowTest::DrawWindows(CWinTestWindow *aWin)

	{

	if (aWin->iChild)

		DrawWindows(aWin->iChild);

	aWin->Win()->BeginRedraw();

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

	TheGc->DrawRect(TRect(aWin->Win()->Size()));

	TheGc->Deactivate();

	aWin->Win()->EndRedraw();

	TheClient->iWs.Flush();

	}

void CTWindowTest::CheckAndDestroyWindows()

	{

	DrawWindows(iWin);

	delete iWin;

	iWin=NULL;

	}

void CTWindowTest::DestroyWindowWithActiveGc()

	{

	iWin->Win()->BeginRedraw();

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

	delete iWin;

	TheGc->Deactivate();

	iWin=NULL;

	}

void CTWindowTest::DestroyWindowWithActiveGc2L()

	{

	iWin->Win()->BeginRedraw();

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

	CWindowGc *gc1=new(ELeave) CWindowGc(TheClient->iScreen);

	CWindowGc *gc2=new(ELeave) CWindowGc(TheClient->iScreen);

	CWindowGc *gc3=new(ELeave) CWindowGc(TheClient->iScreen);

	gc1->Construct();

	gc2->Construct();

	gc3->Construct();

	gc1->Activate(*iWin->Win());

	gc2->Activate(*iWin->Win());

	gc3->Activate(*iWin->Win());

	delete iWin;

	TheGc->Deactivate();

	delete gc1;

	delete gc2;

	delete gc3;

	iWin=NULL;

	}

LOCAL_C TInt DoPanicTest(TInt aInt, TAny *aScreenNumber)

	{

	RWsSession ws;

	User::LeaveIfError(ws.Connect());

	// use correct screen

	//

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

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

	RWindowGroup group(ws);

	group.Construct(888);

	group.EnableReceiptOfFocus(EFalse);	// Stop auto group switching on close

	RWindow redraw(ws);

	redraw.Construct(group,88);

	RBackedUpWindow backedUp(ws);

	backedUp.Construct(group,EGray16,99);

	RBlankWindow blank(ws);

	blank.Construct(group,111);

	RWindowBase *base=NULL;

	TInt source=aInt/10000;

	TInt target=(aInt%10000)/100;

	TInt panic=aInt%100;

	switch(source)

		{

		case 0:

			base= &redraw;

			break;

		case 1:

			base= &backedUp;

			break;

		case 2:

			base= ␣

			break;

		}

	switch(target)

		{

		case 0:

			{

			RWindow *win=(RWindow *)base;

			switch(panic)

				{

				case 0:

					win->BeginRedraw();

					break;

				case 1:

					ws.SetAutoFlush(ETrue);

					win->BeginRedraw(TRect(0,0,1,1));

					ws.SetAutoFlush(EFalse);

					break;

				case 2:

					ws.SetAutoFlush(ETrue);

					win->EndRedraw();

					ws.SetAutoFlush(EFalse);

					break;

				case 3:

					win->Invalidate();

					break;

				case 4:

					win->Invalidate(TRect(0,0,1,1));

					break;

				case 5:

					{

					RRegion region;

					win->GetInvalidRegion(region);

					}

					break;

				case 6:

					win->SetBackgroundColor(TRgb(0,0,0));

					break;

				case 7:

					return(EWsExitReasonFinished);

				}

			break;

			}

		case 1:

			{

			RBackedUpWindow *win=(RBackedUpWindow *)base;

			switch(panic)

				{

				case 0:

					win->BitmapHandle();

					break;

				case 1:

					win->UpdateScreen();

					break;

				case 2:

					win->UpdateScreen(TRegionFix<1>(TRect(10,10,20,20)));

					break;

				case 3:

					win->UpdateBackupBitmap();

					break;

				case 4:

					win->MaintainBackup();

					break;

				case 5:

					return(EWsExitReasonFinished);

				}

			break;

			}

		case 2:

			{

			RBlankWindow *win=(RBlankWindow *)base;

			switch(panic)

				{

				case 0:

					win->SetColor(TRgb(0));

					break;

				case 1:

					return(EWsExitReasonFinished);

				}

			break;

			}

		}

	ws.Flush();

	return(EWsExitReasonBad);	// Should never get here, but it's baaddd if it does

	}

struct TWsLocalStructure

	{

	TInt xPos;

	TInt yPos;

	TInt Length;

	TAny *ptr;

	};

LOCAL_C TInt DoPanicTest2(TInt aInt, TAny *aScreenNumber)

	{

	RWsSession ws;

	User::LeaveIfError(ws.Connect());

//

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

	screen->Construct((TInt)aScreenNumber);

//

	RWindowGroup group(ws);

	group.Construct(999);

	group.EnableReceiptOfFocus(EFalse);	// Stop auto group switching on close

	RWindow win(ws);

	win.Construct(group,122);

	win.Activate();

	switch(aInt)

		{

		case 0:

			{

			win.BeginRedraw();

			CWindowGc *gc;

			screen->CreateContext(gc);

			gc->Activate(win);

			CFbsFont *font;

			screen->GetNearestFontToDesignHeightInTwips((CFont *&)font,TFontSpec());

			gc->UseFont(font);

			TWsLocalStructure params;

			params.xPos=0;

			params.yPos=0;

			params.Length=1;

			TPckgC<TWsLocalStructure> pkg(params);

			TPtr8 ptr(NULL,10,10);

			ws.TestWriteReplyByProvidingRemoteReadAccess(gc->WsHandle(),EWsGcOpDrawTextPtr,pkg,ptr); // Bad source descriptor

			}

			break;

		case 1:

			{

			TPtr8 bad(NULL,0); // Bad descriptor

			ws.TestWriteReplyP(win.WsHandle(),EWsWinOpSize,NULL,0,&bad); // Bad descriptor

			}

			break;

		case 2:

			{

			TSize size;

			TPtr8 bad((TUint8 *)&size,4,4); // Short descriptor

			ws.TestWriteReplyP(win.WsHandle(),EWsWinOpSize,NULL,0,&bad); // Short descriptor

			}

			break;

		case 3:

			win.EnablePointerMoveBuffer();

			break;

		case 4:

			{

			RBackedUpWindow backup(ws);

			backup.Construct(group,EGray16,123);

			backup.Activate();

			backup.SetRequiredDisplayMode(EGray16);

			}

			break;

		default:

			return(EWsExitReasonFinished);

		}

	ws.Flush();

	return(EWsExitReasonBad);	// Should never get here, but it's baaddd if it does

	}

LOCAL_C TInt CallWindowFuction(RWindowTreeNode* aWin,TInt aWinType,TInt aFunc,RWsSession aWs)

	{

	switch(aWinType)

		{

	case 0:		//Call functions from RWindowTreeNode

		{

		RWindowTreeNode* win=aWin;

		switch(aFunc)

			{

		case 0:

			win->OrdinalPosition();

			break;

		case 1:

			win->SetOrdinalPosition(1);

			break;

		case 2:

			win->SetOrdinalPosition(1,2);

			break;

		case 3:

			win->FullOrdinalPosition();

			break;

		case 4:

			win->Parent();

			break;

		case 5:

			win->PrevSibling();

			break;

		case 6:

			win->SetFaded(0,RWindowTreeNode::EFadeIncludeChildren);

			break;

		case 7:

			win->WindowGroupId();

			break;

		//The following can be called on a window with no parent without panicking

		case 8:

			win->ClearPointerCursor();

			break;

		case 9:

			win->ClientHandle();

			break;

		case 10:

			win->DisableErrorMessages();

			break;

		case 11:

			win->DisableFocusChangeEvents();

			break;

		case 12:

			win->DisableGroupChangeEvents();

			break;

		case 13:

			win->DisableGroupListChangeEvents();

			break;

		case 14:

			win->DisableModifierChangedEvents();

			break;

		case 15:

			win->DisableOnEvents();

			break;

		case 16:

			win->DisableVisibilityChangeEvents();

			break;

		case 17:

			win->EnableErrorMessages(EEventControlAlways);

			break;

		case 18:

			win->EnableFocusChangeEvents();

			break;

		case 19:

			win->EnableGroupChangeEvents();

			break;

		case 20:

			win->EnableGroupListChangeEvents();

			break;

		case 21:

			win->EnableModifierChangedEvents(0,EEventControlAlways);

			break;

		case 22:

			win->EnableVisibilityChangeEvents();

			break;

		case 23:

			win->NextSibling();

			break;

		case 24:

			win->OrdinalPriority();

			break;

		case 25:

			win->SetNonFading(0);

			break;

		case 26:

			win->SetPointerCursor(0);

			break;

		case 27:

			win->Child();

			break;

		case 28:

			return(EWsExitReasonFinished);

		default:;

			}

		}

		break;

	case 1:		//Call functions from RWindowGroup

		{

		RWindowGroup* win=(RWindowGroup*)aWin;

		switch(aFunc)

			{

		case 0:

			win->EnableReceiptOfFocus(ETrue);

			break;

		case 1:

			win->AutoForeground(ETrue);

			break;

		case 2:

			win->SetOrdinalPriorityAdjust(5);

			break;

		case 3:

			win->CaptureKey(20,0,0);

			break;

		case 4:

			win->CaptureKeyUpAndDowns(20,0,0);

			break;

		case 5:

		case 6:

			{

			RWindowGroup group(aWs);

			group.Construct(876);

			group.EnableReceiptOfFocus(EFalse);		// Stop auto group switching on close

			if (aFunc==5)

				win->CancelCaptureKey(group.CaptureKey(20,0,0));

			else

				win->CancelCaptureKeyUpAndDowns(group.CaptureKeyUpAndDowns(20,0,0));