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

// Base classes used for building window server test code

// 

//

#include <e32std.h>

#include <w32std.h>

#include <e32svr.h>

#include <e32def_private.h>

#include "TLIB.H"

const TInt ButtonGap=20;

const TInt ButtonBorderGap=10;

const TInt ButtonBorderMargin=3;

const TInt TextMargin=5;

const TInt KAutoDelaySeconds=60; 

NONSHARABLE_CLASS(CTAutoKey): public CActive

	{

public:

	static CTAutoKey* NewL(RWsSession& aWs);

	~CTAutoKey();

	void Activate(TInt aDelay);

	void RunL();

	void DoCancel();

private:

	CTAutoKey(RWsSession& aWs);

	void ConstructL();	

	RTimer iTimer;

	TInt iDelay;

	RWsSession& iWs;

	};

EXPORT_C CTDialog::CTDialog() : CTTitledWindow(), iNumButtons(1)

	{

	iButton[0].Copy(_L("Continue"));	// Default button

	}

EXPORT_C CTDialog::~CTDialog()

	{

	if (iIsActive)

		CActiveScheduler::Stop();

	delete iAutoKey;

	}

EXPORT_C void CTDialog::ConstructLD(CTWinBase &aParent,CWindowGc &aGc)

	{

	iOldFocus=aParent.Group()->CurWin();

	TRAPD(err,CTTitledWindow::ConstructL(aParent));

	if (err!=KErrNone)

		{

		delete this;

		User::Leave(err);

		}

	iActivated=ETrue;

	iWin.SetBackgroundColor(TRgb::Gray256(238));	// Light gray

	AssignGC(aGc);

	iWin.SetPointerCapture(ETrue);

	Group()->SetCurrentWindow(this, ETrue);

	iAutoKey=CTAutoKey::NewL(Client()->iWs);

	}

EXPORT_C void CTDialog::RelinquishFocus()

	{

	Group()->SetCurrentWindow(iOldFocus);

	}

EXPORT_C TInt CTDialog::Display()

	{

	TInt result;

	SetWindowSize();

	if (iWinActive)

		BaseWin()->SetVisible(ETrue);

	else

		{

		Activate();

		iWinActive=ETrue;

		}

	if (iTakeFocus)

		Group()->SetCurrentWindow(this);

	Group()->GroupWin()->SetOrdinalPosition(0);

	iResultPtr=&result;

	CTClient *client=Client();

	if (client->QueueRead())

		{

		client->iWs.Flush();

		client=NULL;

		}

	iIsActive=ETrue;

	iAutoKey->Activate(KAutoDelaySeconds);

	CActiveScheduler::Start();

	if (client)

		client->CancelRead();

	return(result);

	}

EXPORT_C void CTDialog::SetFlags(TUint aFlags)

	{

	iFlags=aFlags;

	}

void CTDialog::SetMaxWid(TInt &aMax, TInt aWid)

	{

	if (aWid>aMax)

		aMax=aWid;

	}

EXPORT_C void CTDialog::SetWindowSize()

	{

	if (iActivated)

		{

		TInt max=0;

		SetMaxWid(max,iFont->TextWidthInPixels(iTitle));

		SetMaxWid(max,iFont->TextWidthInPixels(iLine1));

		SetMaxWid(max,iFont->TextWidthInPixels(iLine2));

		max+=TextMargin*2;

		iButWid=0;

		if (iNumButtons>0)

			{

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

				SetMaxWid(iButWid,iFont->TextWidthInPixels(iButton[index]));

			iButWid+=ButtonBorderMargin*2;

			SetMaxWid(max,iButWid*iNumButtons+ButtonGap*(iNumButtons-1)+ButtonBorderGap*2);

			}

		TSize parSize=Parent()->Size();

		TSize size(max,iFont->HeightInPixels()*8);

		TPoint pos((parSize.iWidth-size.iWidth)/2,(parSize.iHeight-size.iHeight)/2);

		if (iFlags&EDialogDisplayAtBottom)

			pos.iY*=2;

		if (iFlags&EDialogDisplayAtLeft)

			pos.iX=0;

		SetExt(pos,size);

		Invalidate();

		}

	}

EXPORT_C void CTDialog::SetLine1(const TDesC &aLine1)

	{

	iLine1.Copy(aLine1);

	}

EXPORT_C void CTDialog::SetLine2(const TDesC &aLine2)

	{

	iLine2.Copy(aLine2);

	}

EXPORT_C void CTDialog::SetNumButtons(TInt aNum)

	{

	if ((TUint)aNum>3)

		TbPanic(EDialogButtonCount);

	iNumButtons=aNum;

	}

EXPORT_C void CTDialog::SetButtonText(TInt aNum,const TDesC &aButton)

	{

	if ((TUint)aNum>(TUint)iNumButtons)

		TbPanic(EDialogButtonIndex);

	iButton[aNum].Copy(aButton);

	}

TRect CTDialog::ButtonRect(TInt aIndex) const

	{

	TInt chunk=(iSize.iWidth-ButtonBorderMargin*2)/iNumButtons;

	TInt midPos=ButtonBorderMargin+chunk*aIndex+chunk/2;

	return(TRect(midPos-iButWid/2,iFont->HeightInPixels()*6,midPos+iButWid/2,iFont->HeightInPixels()*7+ButtonBorderMargin*2));

	}

EXPORT_C void CTDialog::Draw()

	{

	CTTitledWindow::Draw();

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

	iGc->DrawText(iLine1, TPoint((iSize.iWidth-iFont->TextWidthInPixels(iLine1))/2,iFont->HeightInPixels()*3));

	iGc->DrawText(iLine2, TPoint((iSize.iWidth-iFont->TextWidthInPixels(iLine2))/2,iFont->HeightInPixels()*4+2));

	if (iNumButtons!=0)

		{

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

			{

			TRect rect=ButtonRect(index);

			iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

			iGc->SetBrushColor(TRgb::Gray256(255));

			iGc->DrawRect(rect);

			iGc->DrawRect(rect);

			iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

			TInt midPos=(rect.iTl.iX+rect.iBr.iX)/2;

			iGc->DrawText(iButton[index], TPoint((midPos-iFont->TextWidthInPixels(iButton[index])/2),

									iFont->HeightInPixels()*6+iFont->AscentInPixels()+ButtonBorderMargin));

			}

		}

	}

EXPORT_C void CTDialog::WinKeyL(const TKeyEvent &aKey,const TTime&)

	{

	switch(aKey.iCode)

		{

		case EKeyEscape:

		case '0':

			ButtonPressL(0);

			break;

		case EKeyEnter:

		case '1':

			ButtonPressL(iNumButtons>1 ? 1 : 0);	// Same as ESC on a single button dialog

			break;

		case ' ':

		case '2':

			ButtonPressL(2);

			break;

		}

	}

EXPORT_C void CTDialog::PointerL(const TPointerEvent &aPointer,const TTime &aTime)

	{

	if (aPointer.iType==TPointerEvent::EButton1Up)

		{

		if (iButtonClickOn>0)

			{

			ButtonPressL(iButtonClickOn-1);

			return;

			}

		}

	else if (aPointer.iType==TPointerEvent::EButton1Down)

		{

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

			if (ButtonRect(index).Contains(aPointer.iPosition))

				{

				if (iFlags&EDialogWaitForButtonUp)

					iButtonClickOn=index+1;

				else

					{

					ButtonPressL(index);

					return;

					}

				}

		}

	CTTitledWindow::PointerL(aPointer, aTime);

	}

EXPORT_C void CTDialog::ButtonPressL(TInt aButton)

	{

	if (aButton<iNumButtons)

		{

		SetResult(aButton);

		CTTitledWindow::Delete(this);

		}

	}

void CTDialog::SetResult(TInt aButton)

	{

	if (iResultPtr)

		*iResultPtr=aButton;

	}

// Simple display dialog //

class CDisplayDialog : public CTDialog

	{		  

public:

	CDisplayDialog(CTWindowGroup *aGroupWin,CWindowGc *aGc);

	void ConstructLD();

private:

	CTWindowGroup *iGroupWin;

	CWindowGc *iGc;

	};

CDisplayDialog::CDisplayDialog(CTWindowGroup *aGroupWin,CWindowGc *aGc) : CTDialog(),

	iGroupWin(aGroupWin),

	iGc(aGc)

	{

	}

void CDisplayDialog::ConstructLD()

	{

	CTDialog::ConstructLD(*iGroupWin, *iGc);

	}

EXPORT_C void DisplayDialog(CTClient *aClient, const TWindowTitle &aTitle, const TDesC &aLine1, const TDesC &aLine2)

	{

	CDisplayDialog *dialog=NULL;

	dialog=new(ELeave) CDisplayDialog(aClient->iGroup, aClient->iGc);

	TRAPD(err,dialog->ConstructLD());

	if (err==KErrNone)

		{

		dialog->SetTitle(aTitle);

		dialog->SetLine1(aLine1);

		dialog->SetLine2(aLine2);

		dialog->SetNumButtons(1);

		dialog->SetButtonText(0,_L("Okay"));

		if (dialog->Display()!=0)		// delete dialog

			TbPanic(EDialogDisplay);

		}

	}

void doDisplayDialog(TInt aScreenNumber,const TWindowTitle &aTitle, const TDesC &aLine1, const TDesC &aLine2, CTClient *&aClient, const RWindowGroup *aGroup)

	{

	aClient=new(ELeave) CTClient();

	aClient->SetScreenNumber(aScreenNumber);

	aClient->ConstructL();

//

	aClient->iGroup=new(ELeave) CTWindowGroup(aClient);

	aClient->iGroup->ConstructL();

	aClient->iGroup->GroupWin()->SetOrdinalPosition(0,10);

	if (aGroup)

		aClient->iGroup->GroupWin()->SetOwningWindowGroup(aGroup->Identifier());

//

	TRAP_IGNORE(DisplayDialog(aClient, aTitle, aLine1, aLine2));

	}

void doDisplayDialog(const TWindowTitle &aTitle, const TDesC &aLine1, const TDesC &aLine2, CTClient *&aClient, const RWindowGroup *aGroup)

	{

	doDisplayDialog(KDefaultScreen,aTitle,aLine1,aLine2,aClient,aGroup);

	}

EXPORT_C void DisplayDialog(TInt aScreenNumber,const TWindowTitle &aTitle, const TDesC &aLine1, const TDesC &aLine2, const RWindowGroup *aGroup)

	{

	CTClient *client=NULL;

	TRAP_IGNORE(doDisplayDialog(aScreenNumber,aTitle,aLine1,aLine2,client,aGroup));

	delete client;

	}

EXPORT_C void DisplayDialog(const TWindowTitle &aTitle, const TDesC &aLine1, const TDesC &aLine2, const RWindowGroup *aGroup)

	{

	DisplayDialog(KDefaultScreen,aTitle,aLine1,aLine2,aGroup);

	}

//CInfoDialog

EXPORT_C CInfoDialog::CInfoDialog(CTWindowGroup *aGroupWin,CWindowGc *aGc) :CTDialog(), iGroupWin(aGroupWin), iGc(aGc)

	{}

EXPORT_C void CInfoDialog::ButtonPressL(TInt aButton)

	{

	if (aButton==0)

		{

		SetResult(0);

		BaseWin()->SetVisible(EFalse);

		CActiveScheduler::Stop();

		}

	}

EXPORT_C void CInfoDialog::ConstructLD()

	{

	_LIT(OK,"Okay");

	CTDialog::ConstructLD(*iGroupWin, *iGc);

	SetNumButtons(1);

	SetButtonText(0,OK);

	SetTakeFocus();

	}

EXPORT_C void CInfoDialog::TimerResults()

	{

	TProfile profile[eTimes];

	// TProfile only has default constructor -

	// constructor of TProfile does not initialize its members

	for (TInt jj=0; jj<eTimes; jj++)

		{

		profile[jj].iTime=0;

		profile[jj].iCount=0;

		}

	__PROFILE_DISPLAY(eTimes)

	TBuf<64> times;

	TBuf<32> counts;

	TInt ii=1;

	FOREVER

		{

		AppendProfileTime(times,profile[ii].iTime);

		AppendProfileCount(counts,profile[ii].iCount);

		if (++ii==eTimes)

			break;

		AddComma(times);

		AddComma(counts);

		}

	SetLine1(times);

	SetLine2(counts);

	times.Zero();

	AppendProfileTime(times,profile[0].iTime);

	SetTitle(times);

	}

void CInfoDialog::AppendProfileTime(TDes &aDes, TInt aNum)

	{

	_LIT(ThreeDP,"%d.%03d");

	aDes.AppendFormat(ThreeDP,aNum/eSeconds,(aNum%eSeconds)/1000);

	}

void CInfoDialog::AppendProfileCount(TDes &aDes, TInt aNum)

	{

	_LIT(Int,"%d");

	aDes.AppendFormat(Int,aNum);

	}

void CInfoDialog::AddComma(TDes &aDes)

	{

	_LIT(Comma,", ");

	aDes.Append(Comma);

	}

CTAutoKey::CTAutoKey(RWsSession& aWs): CActive(0), iWs(aWs)

	{

	CActiveScheduler::Add(this);

	}

CTAutoKey::~CTAutoKey()

	{

	Cancel();

	iTimer.Close();

	}

void CTAutoKey::ConstructL()

	{

	User::LeaveIfError(iTimer.CreateLocal());

	}

CTAutoKey* CTAutoKey::NewL(RWsSession& aWs)

	{

	CTAutoKey* self=new(ELeave) CTAutoKey(aWs);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CTAutoKey::Activate(TInt aDelay)

	{

	if (IsActive())

		Cancel();

	iDelay=aDelay*1000000;

	iTimer.After(iStatus,iDelay);

	SetActive();

	}

void CTAutoKey::RunL()

	{

	// simulate key event, only needed to run once

	TKeyEvent keyEvent;

	keyEvent.iCode=EKeyEnter;

	keyEvent.iScanCode=EKeyEnter;

	keyEvent.iModifiers=0;

	keyEvent.iRepeats=0;

	iWs.SimulateKeyEvent(keyEvent);

	iWs.Flush();

	}

void CTAutoKey::DoCancel()

	{

	iTimer.Cancel();

	}