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

// Sets compiler switches to control WSERV's build

// 

//

#ifndef __WSTOP_H__

#define __WSTOP_H__

#include <e32std.h>

#include <e32base.h>

#include <f32file.h>

#include <w32debug.h>

#include "w32cmd.h"

#include "server.h"

#include "tcursor.h"

#include "ScrDev.H"

#include "Direct.H"

/**

@internalTechnology

*/

class CWsRootWindow;

class CWsPluginManager;

typedef CDebugLogBase *(*CreateDebugLog)(TBool aIsFirst, TDesC &aParams);

class CWsShellLogon : public CActive

	{

public:

	CWsShellLogon();

	~CWsShellLogon();

	void ConstructL(RFs &aFs);

	inline TFullName FullName();

private:

	void DoCancel();

	void RunL();

	void Request();

private:

#if defined(__WINS__)

	RLibrary iLib;

	RThread iShellThread;

	RProcess iShellProcess;

#else

	RProcess iShell;

#endif

	};

class CWsRenderOrienationTracker;

class CWsTop

	{

	enum {EShellBootModeReboot=0,EShellBootModeNoReboot=1,EShellBootModeExit=2};

private:

	class CShellStarter : public CTimer

		{

		public:

			CShellStarter() : CTimer(EPriorityNormal) {CActiveScheduler::Add(this);}

			void ConstructL() {CTimer::ConstructL();}

		private:

			void RunL() { CWsTop::StartShell(); }

		};

public:

	static void RunServerL();

	static void InitStaticsL();

	static void DeleteStaticsL();

	static inline CWsWindowGroup *FocusWindowGroup();

	static CWsClient *FocusWindowGroupOwner();

	static RWsTextCursor *CurrentTextCursor();

	static void SetCurrentTextCursor(RWsTextCursor *aCurrentTextCursor);

	static inline void KillForegroundSession();

//

	static void TriggerRedraws(CWsRootWindow* aRootWindow);

	static void ClientDestroyed(const CWsClient *aClient);

	static void NewSession(const CWsClient *aClient);

	static inline TBool ShuttingDown();

	static void StartShell();

	static void SessionExited(CWsClient *aClient);

	static void ShellExited();

	static void Exit();

    enum TReloadWsIni 

        {

        EDoReloadWsIni,

        EDoNotReloadWsIni

        };

    static void EnableLogging(TReloadWsIni aSetting = EDoReloadWsIni);

	static void DisableLogging();

	static TInt SetSendOffEventsToShell(CWsClient *aClient,const TWsClCmdOffEventsToShell &aData);

	static void StopWindowGettingOffEvents(CWsWindowBase* aWindow);

	static void HandleSwitchOff(TInt aEvent,TBool aDoSwitchOff);

	static inline CScreen* Screen();

	static inline CScreen* Screen(TInt aScreenId);

	static inline TInt NumberOfScreens();

	static void RedrawScreens();

	static void ClearAllRedrawStores();

	static void LogCommand(RWsSession::TLoggingCommand aCommand);

	static inline RTimer& Timer();

	static void StateDump();

	static void SetCurrentFocusScreen(CScreen* aScreen);

	static inline CScreen* CurrentFocusScreen();

	static TInt SetCurrentFocusScreen(TInt aScreenNo);

	static inline CWindowServer* WindowServer();

	static void SetCheckHeapOnDisconnectClient(const CWsClient* aClient);

	static void SetCheckHeapOnDisconnectMode(TWsCheckHeapOnDisconnectMode aCheckHeapOnDisconnectMode);

	static TInt FetchCheckHeapResult();

	static TBool NeedsHeapCheckAndRestart(TInt aStartHeapCount);

	static TBool ReleaseMemory();

	static inline TBool IsFadeEnabled();

	static inline TBool FinishEveryFlush();

	static void ClearSurfaceMap(CWsClient* aClient);

	static TBool SearchDuplicateSurfaceId(const TSurfaceId& aSurfaceId);

	static TBool MultiFocusPolicy();

	static inline CWsPluginManager *PluginManager();

	static void CheckRenderOrientation();

private:

	static void InitLogging();

	static void InitScreenL( TInt aScreenNumber)  ; 	

private:

// Data

	static CShellStarter *iShellStarter;

	static CWindowServer *iServer;

	static RLibrary iDebugLib;

	static CWsShellLogon *iShell;

	static const CWsClient *iShellClient;

	static TBool iPreviousShellClient;

	static TInt iShellBootMode;

	static TBool iShuttingDown;

	static TBool iIsFirstLog;

	static CWsWindowBase *iWindowToSendOffEventsTo;

	static CArrayPtrFlat<CScreen>* iScreens ;

	static CScreen* iCurrentFocusScreen;

	static TInt iNumberOfScreens ;

	static RTimer iTimer;

	static TBool iIgnoreSwitchOffEvent;

	static TBool iFadeEnabled;

	static TBool iFinishEveryFlush;

	static TBool iMultiFocusPolicy;

	static const CWsClient* iTriggerHeapCheckOnClientExit;

	static TWsCheckHeapOnDisconnectMode iHeapCheckMode;

	static TInt iCheckHeapResult;

	static TBool iDoHeapCheckAndRestart;

	static CWsPluginManager *iPluginManager;

    static CWsRenderOrienationTracker* iRenderOrientationTracker;	

	};

NONSHARABLE_CLASS(CWsActiveScheduler): public CActiveScheduler, public MWsActiveSchedulerDebug

	{

public:

	static CWsActiveScheduler* Static();

	CWsActiveScheduler();

	~CWsActiveScheduler();

	void PrepareDraw();

	void CancelPrepare();

	void StartDraw();

	void StopDraw(TInt aPixelsUpdated);

	void DrawStats(TInt& aUpdatesPerSecond,TInt64& aPixelsPerSecond,TInt aWindowInSeconds) const;

	void WaitForAnyRequest();

	void Error(TInt aError) const;

	void AccumReclaimedIdleTime(TInt64 aMicroSeconds);

	TInt64 ReclaimedIdleTime() const { return iReclaimedIdleTime; }

	TInt64 Requests() const { return iRequests; }

	TInt64 Errors() const { return iErrors; }

	virtual TInt64 Draws() const { return iDraws; }

	virtual TInt64 Total() const { return iTotal; }

	virtual TInt64 Preparing() const { return iPreparing; }

	virtual TInt64 Drawing() const { return iDrawing; }

	virtual TInt64 Idle() const { return iIdle;	}

private:

#ifdef _DEBUG

	enum TState

		{

		ENormal,

		EPreparingDraw,

		EDrawing,

		EDrawn

		};

	TState iState;

#endif

	// request stats

	TInt64 iRequests;

	mutable TInt64 iErrors;

	TInt64 iDraws;

	TTime iRun;

	TTime iRunDraw;

	TInt64 iTotal;

	TInt64 iPreparing;

	TInt64 iDrawing;

	TInt64 iIdle;

	TInt64 iReclaimedIdleTime;

	//TBool iPaused;

	// pixels-per-second stats

	NONSHARABLE_STRUCT(TSample)

		{

		TTime iStart;

		TUint64 iDuration;

		TUint32 iPixels;

		};

	TInt iFastCounterFreq;

	TUint iNumSamples;

	TUint iCurrent;

	TSample* iData;	

	};

//

// inlines			//

//

//

// CWsTop

//

inline TBool CWsTop::ShuttingDown()

	{return(iShuttingDown);}

inline CWsWindowGroup *CWsTop::FocusWindowGroup()

	{return(iCurrentFocusScreen->FocusWindowGroup());}

inline void CWsTop::KillForegroundSession()

	{iCurrentFocusScreen->KillForegroundSession();}

inline CScreen* CWsTop::Screen()

	{return CWsTop::Screen( 0 ) ;}

inline CScreen* CWsTop::Screen(TInt aScreen)

	{return (*iScreens)[aScreen];}

inline TInt CWsTop::NumberOfScreens()

	{return iNumberOfScreens;}

inline CScreen* CWsTop::CurrentFocusScreen()	

	{return iCurrentFocusScreen;}

inline RTimer& CWsTop::Timer()

	{return iTimer;}

inline CWindowServer* CWsTop::WindowServer()

	{return iServer;}

inline TBool CWsTop::IsFadeEnabled()

	{return iFadeEnabled;}

inline TBool CWsTop::FinishEveryFlush()

	{return iFinishEveryFlush;}

inline CWsPluginManager *CWsTop::PluginManager()

	{return iPluginManager;}

#endif