// 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();

 	}