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

// Test multiple connections to the window server

// 

//

#include <e32std.h>

#include <e32svr.h>

#include "W32STD.H"

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

#include "TMAN.H"

const TInt EMaxSubState=3;

class CMcWindowBase;

class TMultiConTest;

class CMcConnectionBase : public CTClient

	{

public:

	CMcConnectionBase(TMultiConTest *aTest);

	~CMcConnectionBase();

	virtual void ConstructL();

	void SubStateChanged();

protected:

	TMultiConTest *iTest;

	CMcWindowBase *iWin;

	CWindowGc *iGc;

	};

class CMcConnection : public CMcConnectionBase	// Sets AutoForeground off

	{

public:

	CMcConnection(TMultiConTest *aTest);

	void ConstructL();

	};

class CMcWindowGroupAf : public CTWindowGroup

	{

public:

	CMcWindowGroupAf(CTClient *aClient);

	void KeyL(const TKeyEvent &aKey, const TTime &aTime);

	};

class CMcConnectionAf : public CMcConnectionBase	// Sets AutoForeground on

	{

public:

	CMcConnectionAf(TMultiConTest *aTest);

	void ConstructL();

	void KeyL(const TKeyEvent &aKey);

	};

class CMcConnectionDef : public CMcConnectionBase	// Leaves AutoForeground as the default value

	{

public:

	CMcConnectionDef(TMultiConTest *aTest);

	void ConstructL();

	};

class CMcWindowBase : public CTWin

	{

public:

	CMcWindowBase(TMultiConTest *aTest);

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

	virtual void Draw()=0;

	virtual void PointerL(const TPointerEvent &pointer,const TTime &)=0;

protected:

	TMultiConTest *iTest;

	TRgb iBack;

	};

class CMcWindow : public CMcWindowBase

	{

public:

	CMcWindow(TMultiConTest *aTest);

	virtual void Draw();

	virtual void PointerL(const TPointerEvent &pointer,const TTime &);

	};

class CMcWindowAf : public CMcWindowBase

	{

public:

	CMcWindowAf(TMultiConTest *aTest);

	virtual void Draw();

	virtual void PointerL(const TPointerEvent &pointer,const TTime &);

	void ConstructL();

	};

class CMcWindowDef : public CMcWindowBase

	{

public:

	CMcWindowDef(TMultiConTest *aTest);

	virtual void Draw();

	virtual void PointerL(const TPointerEvent &pointer,const TTime &);

	};

class TMultiConTest : public CTestBase

	{

public:

	TMultiConTest();

	~TMultiConTest();

	TestState DoTestL();

	void ConstructL();

	void EndAutoForegroundTest();

	TInt SubState() const;

	void IncSubState();

private:

	CMcConnectionAf *iConn1;

	CMcConnection *iConn2;

	CMcConnectionDef *iConn3;

	TSize iWinSize;

	TInt iState;

	TInt iSubState;

	};

GLDEF_C CTestBase *CreateMultiConTest()

	{

	return(new(ELeave) TMultiConTest());

	}

TMultiConTest::TMultiConTest() : CTestBase(_L("MultiCon"))

	{}

TMultiConTest::~TMultiConTest()

	{

	delete iConn1;

	delete iConn2;

	delete iConn3;

	}

void TMultiConTest::EndAutoForegroundTest()

	{

	iConn1->iGroup->GroupWin()->EnableReceiptOfFocus(EFalse);

	iConn2->iGroup->GroupWin()->EnableReceiptOfFocus(EFalse);

	iConn3->iGroup->GroupWin()->EnableReceiptOfFocus(EFalse);

	Request();

	}

void TMultiConTest::ConstructL()

	{

	iConn3=new(ELeave) CMcConnectionDef(this);

	iConn3->ConstructL();

	iConn2=new(ELeave) CMcConnection(this);

	iConn2->ConstructL();

	iConn1=new(ELeave) CMcConnectionAf(this);

	iConn1->ConstructL();

	}

//

// CMcConnection

CMcConnectionBase::CMcConnectionBase(TMultiConTest *aTest) : iTest(aTest)

	{

	}

CMcConnectionBase::~CMcConnectionBase()

	{

	CTWin::Delete(iWin);

	delete iGc;

	}

void CMcConnectionBase::SubStateChanged()

	{

	iWin->Invalidate();

	iWs.Flush();

	}

void CMcConnectionBase::ConstructL()

	{

	CTClient::ConstructL();

	User::LeaveIfError(iScreen->CreateContext(iGc));

	}

CMcConnection::CMcConnection(TMultiConTest *aTest) : CMcConnectionBase(aTest)

	{

	}

void CMcConnection::ConstructL()

	{

	CMcConnectionBase::ConstructL();

	iGroup=new(ELeave) CTWindowGroup(this);

	iGroup->ConstructL();

	TSize screenSize=iGroup->Size();

	TInt winWidth=screenSize.iWidth/3;

	TInt winHeight=screenSize.iHeight/2-10;

	iGroup->GroupWin()->AutoForeground(EFalse);

	CMcWindow *win=new(ELeave) CMcWindow(iTest);

	win->SetUpL(TPoint(5,5),TSize(winWidth,winHeight),iGroup,*iGc);

	iWin=win;

	iWs.Flush();

	}

CMcConnectionAf::CMcConnectionAf(TMultiConTest *aTest) : CMcConnectionBase(aTest)

	{

	}

void CMcConnectionAf::ConstructL()

	{

	CMcConnectionBase::ConstructL();

	iGroup=new(ELeave) CMcWindowGroupAf(this);

	iGroup->ConstructL();

	TSize screenSize=iGroup->Size();

	TInt winWidth=screenSize.iWidth/3;

	TInt winHeight=screenSize.iHeight/2-10;

	iGroup->GroupWin()->AutoForeground(ETrue);

	CMcWindowAf *win=new(ELeave) CMcWindowAf(iTest);

	win->SetUpL(TPoint(winWidth,5),TSize(winWidth,winHeight),iGroup,*iGc);

	iWin=win;

	iWs.Flush();

	}

void CMcConnectionAf::KeyL(const TKeyEvent &aKey)

	{

	switch(aKey.iCode)

		{

		case ' ':

			if (iTest->SubState()==0)

				{

				iTest->TestL(iGroup->GroupWin()->OrdinalPosition()==0);

				iTest->IncSubState();

				}

			break;

		case EKeyEscape:

			iTest->EndAutoForegroundTest();

			break;

		}

	}

CMcConnectionDef::CMcConnectionDef(TMultiConTest *aTest) : CMcConnectionBase(aTest)

	{

	}

void CMcConnectionDef::ConstructL()

	{

	CMcConnectionBase::ConstructL();

	iGroup=new(ELeave) CTWindowGroup(this);

	iGroup->ConstructL();

	iGroup->GroupWin()->EnableReceiptOfFocus(EFalse);

	TSize screenSize=iGroup->Size();

	TInt winWidth=screenSize.iWidth/3-10;

	TInt winHeight=(screenSize.iHeight/2)-10;

	CMcWindowDef *win=new(ELeave) CMcWindowDef(iTest);

	win->SetUpL(TPoint(5+winWidth/2,screenSize.iHeight/2),TSize(winWidth,winHeight),iGroup,*iGc);

	iWin=win;

	iWs.Flush();

	}

//

// CMcWindow, base class //

//

CMcWindowBase::CMcWindowBase(TMultiConTest *aTest) : CTWin(), iTest(aTest)

	{

	}

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

	{

	ConstructExtLD(*parent,pos,size);

	iWin.SetBackgroundColor(iBack);

	Activate();

	AssignGC(aGc);

	}

//

// CMcWindow, window used to test multiple connections //

//

CMcWindow::CMcWindow(TMultiConTest *aTest) : CMcWindowBase(aTest)

	{

	iBack=TRgb::Gray256(221);

	}

void CMcWindow::PointerL(const TPointerEvent &pointer,const TTime &)

	{

	if (pointer.iType==TPointerEvent::EButton1Down)

		{

		switch(iTest->SubState())

			{

			case 1:

				iTest->TestL(Client()->iGroup->GroupWin()->OrdinalPosition()==1);

				iTest->IncSubState();

				break;

			}

		}

	}

void CMcWindow::Draw()

	{

	iGc->Clear();

	TBuf<0x40> buf;

	switch(iTest->SubState())

		{

		case 1:

			buf.Copy(_L("Click on me"));

			break;

		case 0:

		case 2:

		case 3:

			buf.Copy(_L(""));

			break;

		default:

			buf.Copy(_L("ERROR"));

		}

	iGc->DrawText(buf, TPoint(10,20));

	}

//

// CMcWindowAf, Auto foreground version of CMcWindow //

//

CMcWindowAf::CMcWindowAf(TMultiConTest *aTest) : CMcWindowBase(aTest)

	{

	iBack=TRgb::Gray256(150);

	}

void CMcWindowAf::PointerL(const TPointerEvent &pointer,const TTime &)

	{

	if (pointer.iType==TPointerEvent::EButton1Down)

		{

		switch(iTest->SubState())

			{

			case 2:

				iTest->TestL(Client()->iGroup->GroupWin()->OrdinalPosition()==0);

				iTest->IncSubState();

				break;

			}

		}

	}

void CMcWindowAf::Draw()

	{

	iGc->Clear();

	TBuf<0x40> buf;

	switch(iTest->SubState())

		{

		case 1:

		case 3:

			break;

		case 0:

			buf.Copy(_L("Press <Space>"));

			break;

		case 2:

			buf.Copy(_L("Click on me"));

			break;

		default:

			buf.Copy(_L("ERROR"));

		}

	iGc->DrawText(buf, TPoint(10,20));

	}

//

CMcWindowGroupAf::CMcWindowGroupAf(CTClient *aClient) : CTWindowGroup(aClient)

	{}

void CMcWindowGroupAf::KeyL(const TKeyEvent &aKey, const TTime &)

	{

	((CMcConnectionAf *)iClient)->KeyL(aKey);

	}

//

// CMcWindowDef, Default auto foreground version of CMcWindow //

//

CMcWindowDef::CMcWindowDef(TMultiConTest *aTest) : CMcWindowBase(aTest)

	{

	iBack=TRgb::Gray256(236);

	}

void CMcWindowDef::PointerL(const TPointerEvent &pointer,const TTime &)

	{

	if (pointer.iType==TPointerEvent::EButton1Down)

		{

		switch(iTest->SubState())

			{

			case 3:

				iTest->TestL(Client()->iGroup->GroupWin()->OrdinalPosition()==0);

				iTest->IncSubState();

				break;

			}

		}

	}

void CMcWindowDef::Draw()

	{

	iGc->Clear();

	TBuf<0x40> buf;

	switch(iTest->SubState())

		{

		case 0:

		case 1:

		case 2:

			break;

		case 3:

			buf.Copy(_L("Click on me"));

			break;

		default:

			buf.Copy(_L("ERROR"));

		}

	iGc->DrawText(buf, TPoint(10,20));

	}

//

TInt TMultiConTest::SubState() const

	{

	return(iSubState);

	}

void TMultiConTest::IncSubState()

	{

	if (iSubState==EMaxSubState)

		EndAutoForegroundTest();

	else

		{

		iSubState++;

		iConn1->SubStateChanged();

		iConn2->SubStateChanged();

		iConn3->SubStateChanged();

		}

	}

TestState TMultiConTest::DoTestL()

	{

	switch(iState)

		{

		case 0:

			LogSubTest(_L("MultiCon 1"),1);

			iState++;

			return(EContinue);

		default:

			return(EFinished);

		}

//	return(ENext);

 	}