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

// Shell to launch test code

// 

//

#include <e32std.h>

#include <f32file.h>

#include "W32STD.H"

#include "../SERVER/w32cmd.h"

#include <e32svr.h>

#include <hal.h>

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

#include "../TClick/CLICK.H"

#define __USING_PROCESS_

#if !defined(__USING_PROCESS_)

#define RP_FILENAME_SET _L(".DLL")

#endif

#define THE_PASSWORD _L("pass")

#define INDEX_FOR_SHELL_TEST 0

#define SHELL_TEST_NAME _L("ShellTest")

#define INDEX_FOR_RESTART_TEST 1

#define RESTART_TEST_NAME _L("RestartTest")

#define INDEX_FOR_RESTART_EVENT_TEST 2

#define RESTART_EVENT_TEST_NAME _L("RestartEventTest")

const TInt EDoubleClickTime=500000;

const TInt EDoubleClickDistance=16;

#ifndef __USING_PROCESS_

LOCAL_D const TUint KHeapSize=0x400000;

#endif

enum TShellPanic

	{

	EShellPanicRunningProcessCancel,

	EShellPanicTemp,

	EShellPanicRunningProcessNullPtr,

	EShellPanicPassword,

	};

typedef TInt (*DllTestAppEntryPoint)(TAny *aParam);

class CShellClient;

class RShellWsSession : public RWsSession

	{

public:

	static void Shutdown();

	void SendShutdown();

	};

class MProcessObserver

	{

public:

	virtual void ProcessDied()=0;

	};

class CRunningProcess : public CActive

	{

public:

	CRunningProcess(MProcessObserver* aObserver);

	~CRunningProcess();

	void ConstructL(const TDesC& aName);

	void ConstructTestExecuteL(const TDesC &aName);

	void Link(CRunningProcess** aRpPtr);

#if defined(__USING_PROCESS_)

	inline RProcess& Process() {return iProcess;}

#else

	inline RThread& Process() {return iProcess;}

#endif

private:

	virtual void DoCancel();

	virtual void RunL();

private:

#if defined(__WINS__)

	RLibrary iLib;

#endif

#if defined(__USING_PROCESS_)

	RProcess iProcess;

#else

	RThread iProcess;

#endif

	CRunningProcess* iNext;

	CRunningProcess** iPrevPtr;

	TParse iFileName;

	MProcessObserver* iObserver;

	};

class CShellErrorDialog : public CTDialog

	{		  

public:

	CShellErrorDialog(CTWindowGroup *aGroupWin,CWindowGc *aGc);

	void ButtonPressL(TInt aButton);

	void ConstructLD();

private:

	CTWindowGroup *iGroupWin;

	CWindowGc *iGc;

	};

class CTCalibWindow : public CTWin

	{

public:

	CTCalibWindow();

	void InitWin();

	void DrawPoint(const TPoint &aPoint, const TDesC &aText);

	void Draw();

	void PointerL(const TPointerEvent &aPointer,const TTime& aTime);

private:

	TInt iCount;

	TDigitizerCalibration iCalibPoints;

	TDigitizerCalibration iReturnValues;

	};

class CListWindow : public CTTitledWindow

	{

public:

	CListWindow();

	void CloseWindow();

	void ConstructL(CTWinBase &parent, TBool aExitOnEscape);

	void Draw();

	virtual void SelectedL(TInt aIndex)=0;

	virtual void WinKeyL(const TKeyEvent &aKey,const TTime& aTime);

	void SetExt(const TPoint &aPos, const TSize &aSize);

	void SetSize(const TSize &);

protected:

	virtual TPtrC GetText(TInt aLine)=0;

	virtual TInt ListCount()=0;

	void SetSize();

	void PointerL(const TPointerEvent &aPointer,const TTime& aTime);

private:

	void Resized(const TSize &aSize);

	void SetListPos(TInt aNewPos);

	TInt TextRowHeight() const;

	void RowBox(TRect &aRect, TInt aRow) const;

private:

	TRgb iColorMap[4];

	TInt iListPos;

	TTime iPrevTime;

	TBool iExitOnEscape;

	};

class CShellWindow : public CListWindow, public MProcessObserver

	{

public:

	CShellWindow();

	~CShellWindow();

	void ConstructL(CTWinBase &parent);

	TBool RunClientL(const TDesC &aName,TBool aTestExecute);

	void SelectedL(TInt aIndex);

	virtual void WinKeyL(const TKeyEvent &aKey,const TTime& aTime);

	void ForegroundAppDialogL();

	void HeapCountDialogL();

	void SetPointerZone(TInt aZone);

	void SetAutoLaunch(TBool aAutoLaunch);

	// Virtual function defined in CTBaseWin and overriden in CListWindow

	void PointerL(const TPointerEvent &aPointer,const TTime& aTime);

	// Virtual function defined in CTBaseWin and overriden in CTTitledWindow

	void FocusChanged(TBool aState);

private:

	void DoShellTests();

	void BugHunt();

	void CheckTerminate();

	//Pure virtual functions defined in CListWindow

	TPtrC GetText(TInt aLine);

	TInt ListCount();

	//Pure virtual function defined in MProcessObserver

	void ProcessDied();

	//Simulates SwitchOffEvent

	void SimulateSwitchOffEvent();

#ifdef SYMBIAN_PROCESS_MONITORING_AND_STARTUP	

	//Simulates RestartSystemEvent

	void SimulateRestartEvent();

	//Simulates RestartSystemEvent and test the receiving of off event

	void SimulateAndReceiveRestartEvent();

#endif

private:

	TBool iFailModeEnabled;

	TInt iPointerZone;

	CRunningProcess *iProcessList;

	CArrayFixFlat<TFileName> iFileNames;

	CTPointerCursor *iPointerCursor;

	RSoundPlugIn iClick;

	TInt iCaptureKey;

	TBool iAutoLaunch;

	TInt iNumWindowGroups;

	TBool iIsFocused;

	};

class CTIconWindow : public CTBlankWindow

	{

public:

	CTIconWindow(TInt aType);

	void InitWinL();

	void SetExtentL();

private:

	TInt iType;

	};

class CTPasswordWindow: public CTTitledWindow

	{

public:

	CTPasswordWindow();

	void InitWin();

	void Draw();

private:

	TPoint iTextPos;

	};

class CTaskListWindow : public CListWindow

	{

public:

	CTaskListWindow();

	void ConstructL(CTWinBase &parent);

	void SelectedL(TInt aIndex);

private:

	virtual TPtrC GetText(TInt aLine);

	virtual TInt ListCount();

private:

	CArrayFixFlat<TInt> iWindowHandles;

	CArrayFixFlat<TFullName> iWindowThreadNames;

	TBuf<KMaxFullName+KMaxName+2> iLatestText;

	};

class CShellWindowGroup : public CTWindowGroup

	{

public:

	CShellWindowGroup(CTClient *aClient);

	~CShellWindowGroup();

	void ConstructL();

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

	void ErrorMessage(const TWsErrorMessage &aErrorMessage, const TTime &);

	void ScreenDeviceChangedL();

private:

	TUint32 iCapHandle1;

	TUint32 iCapHandle2;

	TUint32 iCapHandle3;

	TUint32 iCapHandle4;

	};

class CIconWindowGroup : public CTWindowGroup

	{

public:

	CIconWindowGroup(CTClient *aClient);

	void ConstructL();

	};

class CPasswordWindowGroup : public CTWindowGroup

	{

public:

	CPasswordWindowGroup(CTClient *aClient);

	~CPasswordWindowGroup();

	void ConstructL();

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

	void Cancel();

	void PasswordL(const TTime &aTime);

private:

	CTPasswordWindow *iWin;

	TBool iPasswordMode;

	};

class CShellClient : public CTClient

	{

public:

	CShellClient();

	~CShellClient();

	void ConstructL();

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

	void Exit();

	void CreateTestWindowL(CTWin *aWin, const TPoint &aPos);

	void CreateTestWindowL(CTWin *win, const TPoint &aPos, CTWinBase *parent);

	void ErrorDialog(const TDesC &aTitle, TInt aErr);

	void ScreenDeviceChangedL();

public:

	RFs iFs;

private:

	TInt iNum;

	CTWindowGroup *iIconGroup;

	CTIconWindow *iIconWin1;

	CTIconWindow *iIconWin2;

	CTPointerCursor *iPointerCursor;

	CPasswordWindowGroup *iPasswordGroup;

	};

class ROverrideProtectionInRSessionBase : public RWsSession

	{

public:

	inline TInt Send(TInt aFunction) const {return(RSessionBase::Send(aFunction,TIpcArgs()));};

	};

const TInt Xmove=8;

const TInt Ymove=6;

const TInt ENumPointerCursors=2;

void DrawShellDragCursor(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *aParam);

void DrawShellListCursor(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *aParam);

TSpriteCreateParams spriteParams1(TSize(32,32),TPoint(-16,-16),DrawShellListCursor,NULL,EFalse,CGraphicsContext::EDrawModeXOR);

TSpriteCreateParams spriteParams2(TSize(32,32),TPoint(-16,-16),DrawShellDragCursor,NULL,ETrue,CGraphicsContext::EDrawModePEN);

TSpriteCreateParams *PointerParams[ENumPointerCursors]={&spriteParams1,&spriteParams2};

void Panic(TInt aPanic)

	{

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

	}

void RShellWsSession::Shutdown()

	{

	RShellWsSession ShellSession;

	ShellSession.Connect();

	ShellSession.SendShutdown();

	}

void RShellWsSession::SendShutdown()

	{

	SendReceive(EWservMessShutdown,TIpcArgs(EWservShutdownCheck));

	}

//

// Sprite drawing functions //

//

void DrawPointerCursor(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *)

	{

	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 0 : 2));

	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	aGc->SetPenStyle(CGraphicsContext::ENullPen);

	aGc->DrawRect(TRect(aSize));

	aGc->SetPenStyle(CGraphicsContext::ESolidPen);

	aGc->SetPenColor(TRgb::Gray4(3));

	aGc->SetBrushColor(TRgb::Gray4(3));

	aGc->DrawRect(TRect(0,aSize.iHeight/2-1,aSize.iWidth,aSize.iHeight/2+2));

	aGc->DrawRect(TRect(aSize.iWidth/2-1,0,aSize.iWidth/2+2,aSize.iHeight));

	if (!aDoMask)

		{

		aGc->SetPenColor(TRgb::Gray4(0));

		aGc->DrawLine(TPoint(0,aSize.iHeight/2),TPoint(aSize.iWidth,aSize.iHeight/2));

		aGc->DrawLine(TPoint(aSize.iWidth/2,0),TPoint(aSize.iWidth/2,aSize.iHeight));

		}

	}

void DrawShellDragCursor(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *)

	{

	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 0 : 2));

	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	aGc->SetPenStyle(CGraphicsContext::ENullPen);

	aGc->DrawRect(TRect(aSize));

	aGc->SetPenStyle(CGraphicsContext::ESolidPen);

	aGc->SetPenColor(TRgb::Gray4(aDoMask ? 3 : 1));

	for(TInt y=0;y<aSize.iHeight;y++)

		{

		TInt xfact=aSize.iWidth*Abs(y-aSize.iHeight/2)/aSize.iHeight;

		aGc->DrawLine(TPoint(xfact,y),TPoint(aSize.iWidth-xfact,y));

		}

	}

void DrawShellListCursor(CBitmapContext *aGc,TInt , const TSize &aSize, TBool , TAny *)

	{

	aGc->SetBrushColor(TRgb::Gray4(0));

	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	aGc->SetPenStyle(CGraphicsContext::ENullPen);

	aGc->DrawRect(TRect(aSize));

	aGc->SetBrushColor(TRgb::Gray4(3));

	aGc->DrawRect(TRect(0,aSize.iHeight/2-1,aSize.iWidth,aSize.iHeight/2+2));

	aGc->DrawRect(TRect(aSize.iWidth/2-1,0,aSize.iWidth/2+2,aSize.iHeight));

	}

//

// Calibration window //

//

CTCalibWindow::CTCalibWindow()

	{

	}

void CTCalibWindow::InitWin()

	{

	UserHal::CalibrationPoints(iCalibPoints);

	AssignGC(*Client()->iGc);

	iWin.SetOrdinalPosition(0,1);

	iWin.Activate();

	}

void CTCalibWindow::DrawPoint(const TPoint &aPoint, const TDesC &aText)

	{

	iGc->MoveTo(aPoint);

	iGc->MoveBy(TPoint(0,-20));

	iGc->DrawLineBy(TPoint(0,40));

	iGc->MoveBy(TPoint(-20,-20));

	iGc->DrawLineBy(TPoint(40,0));

	iGc->DrawText(aText, aPoint+TPoint(4,-4));

	}

void CTCalibWindow::Draw()

	{

	iGc->Clear();

	DrawPoint(iCalibPoints.iTl,_L("1"));

	DrawPoint(iCalibPoints.iBl,_L("2"));

	DrawPoint(iCalibPoints.iTr,_L("3"));

	DrawPoint(iCalibPoints.iBr,_L("4"));

	}

void CTCalibWindow::PointerL(const TPointerEvent &aPointer,const TTime& )

	{

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

		{

		switch(iCount++)

			{

			case 0:

				iReturnValues.iTl=aPointer.iPosition;

				break;

			case 1:

				iReturnValues.iBl=aPointer.iPosition;

				break;

			case 2:

				iReturnValues.iTr=aPointer.iPosition;

				break;

			case 3:

				iReturnValues.iBr=aPointer.iPosition;

				UserHal::SetXYInputCalibration(iReturnValues);

				delete this;

				break;

			}

		}

	}

//

// Error dialog //

//

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

	iGroupWin(aGroupWin),

	iGc(aGc)

	{

	}

void CShellErrorDialog::ButtonPressL(TInt aButton)

	{

	if (aButton==0)

		CTDialog::ButtonPressL(aButton);

	}

void CShellErrorDialog::ConstructLD()

	{

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

	}

//

// Offscreen icon->button window //

//

CTIconWindow::CTIconWindow(TInt aType) : iType(aType)

	{

	}

void CTIconWindow::InitWinL()

	{

	SetExtentL();

	iWin.SetShadowDisabled(ETrue);

	Activate();

	}

void CTIconWindow::SetExtentL()

	{

	enum {ENumYKeys=5};

	enum {ENumXKeys=9};

	TRect digRect(Client()->iScreen->PointerRect());

	TSize scrSize(Client()->iScreen->SizeInPixels());

	TInt ypos=0;

	TInt count=0;

	iWin.RemoveAllKeyRects();

	if (iType==0)

		{

		for (;count<ENumYKeys;count++)

			{

			TInt oldypos=ypos;

			ypos=digRect.iTl.iY+(count+1)*digRect.Height()/ENumYKeys;

			User::LeaveIfError(iWin.AddKeyRect(TRect(0,oldypos,-digRect.iTl.iX,ypos),'A'+count,ETrue));

			}

		iWin.SetExtent(digRect.iTl,TSize(-digRect.iTl.iX,scrSize.iHeight));

		}

	else

		{

		TInt xpos=0;

		for (count=0;count<ENumXKeys;count++)

			{

			TInt oldxpos=xpos;

			xpos=digRect.iTl.iY+(count+1)*digRect.Width()/ENumXKeys;

			User::LeaveIfError(iWin.AddKeyRect(TRect(oldxpos,0,xpos,digRect.iBr.iY-scrSize.iHeight), EStdKeyF1+count, EFalse));

			}

		iWin.SetExtent(TPoint(digRect.iTl.iX,scrSize.iHeight),TSize(digRect.Width(),digRect.Height()-scrSize.iHeight));

		}

	}

//

// Individual window sub-classes

//

void CShellClient::ErrorDialog(const TDesC &aTitle, TInt aErr)

	{

	TBuf<0x20> err;

	err.Format(TRefByValue<const TDesC>(_L("Error %d")),aErr);

	DisplayDialog(this, aTitle, err,_L(""));

	}

CListWindow::CListWindow() : CTTitledWindow(), iPrevTime(0)

	{

	iColorMap[0]=TRgb::Gray4(0);

	iColorMap[1]=TRgb::Gray4(3);