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

// Top level window server code

// 

//

#include "wstop.h"

#include <hal.h>

#include "ANIM.H"

#include "gc.h"

#include "playbackgc.h"

#include "rootwin.h"

#include "windowgroup.h"

#include "EVENT.H"

#include "KEYCLICK.H"

#include <w32std.h>

#include "offscreenbitmap.h"

#include "panics.h"

#include "inifile.h"

#include "pointer.h"

#include "WSGRAPHICDRAWERFACTORY.H"

#include "redrawmsgwindow.h"

#include <Graphics/WSGRAPHICDRAWERINTERFACE.H>

#include "WsMemMgr.h"

#include "backedupwindow.h"

#include "wsfont.h"

#include "wstraces.h"

#ifdef SYMBIAN_PROCESS_MONITORING_AND_STARTUP

#include <e32power.h>

#endif

#include "graphics/windowserverconstants.h"

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

CWsActiveScheduler* CWsActiveScheduler::Static()

	{

	return static_cast<CWsActiveScheduler*>(CActiveScheduler::Current());

	}

CWsActiveScheduler::CWsActiveScheduler(): iNumSamples(100)

	{

	iRun = User::FastCounter();

	if((KErrNone == HAL::Get(HALData::EFastCounterFrequency,iFastCounterFreq)) && iFastCounterFreq)

		{

		iData = reinterpret_cast<TSample*>(User::AllocZ(sizeof(TSample)*iNumSamples));

		}

	}

CWsActiveScheduler::~CWsActiveScheduler()

	{

	User::FreeZ(reinterpret_cast<void*&>(iData));

	}

void CWsActiveScheduler::PrepareDraw()

	{

	WS_ASSERT_DEBUG((ENormal == iState)||(EDrawn == iState),EWsPanicActiveScheduler);

	__DEBUG_ONLY(iState = EPreparingDraw;)

	iRunDraw = User::FastCounter();

	}

void CWsActiveScheduler::CancelPrepare()

	{

	WS_ASSERT_DEBUG(EPreparingDraw == iState,EWsPanicActiveScheduler);

	__DEBUG_ONLY(iState = ENormal;)

	}

void CWsActiveScheduler::StartDraw()

	{

	WS_TRACE_SERVER_STARTDRAW();

	WS_ASSERT_DEBUG(EPreparingDraw == iState,EWsPanicActiveScheduler);

	__DEBUG_ONLY(iState = EDrawing;)

	TTime now;

	now.UniversalTime();

	TUint64 duration = now.MicroSecondsFrom(iRunDraw).Int64();

	iPreparing += duration;

	iRunDraw = now;

	if(iData)

		{

		iData[iCurrent].iStart = iRunDraw;

		}

	iDraws++;

	}

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

	{

	aUpdatesPerSecond=0;

	aPixelsPerSecond=0;

	if(iData)

		{

		// work out statistic

		TTime window;

		window.UniversalTime();

		window-=TTimeIntervalSeconds(aWindowInSeconds);

		TUint32 pixels=0;

		TInt64 duration=0;

		for(TInt ii=0;ii<iNumSamples;++ii)

			{

			if (iData[ii].iStart>=window)

				{

				pixels+=iData[ii].iPixels;

				duration+=iData[ii].iDuration;

				++aUpdatesPerSecond;

				}

			}

		if (aUpdatesPerSecond && duration)

			{

			aPixelsPerSecond=pixels;

			aPixelsPerSecond=(aPixelsPerSecond*1000000)/duration;

			aUpdatesPerSecond/=aWindowInSeconds;

			}

		}

	}

void CWsActiveScheduler::StopDraw(TInt aPixelsUpdated)

	{

	WS_TRACE_SERVER_STOPDRAW();

	WS_ASSERT_DEBUG(EDrawing == iState,EWsPanicActiveScheduler);

	__DEBUG_ONLY(iState = EDrawn;)

	TTime now;

	now.UniversalTime();

	TUint32 duration = now.MicroSecondsFrom(iRunDraw).Int64();

    // do recording

	if(iData)

		{

		iData[iCurrent].iDuration = now.MicroSecondsFrom(iData[iCurrent].iStart).Int64();

		iData[iCurrent].iPixels = aPixelsUpdated;

		if(++iCurrent >= iNumSamples)

			{

			iCurrent = 0;

			}

		}

	iDrawing += duration;

	}

void CWsActiveScheduler::WaitForAnyRequest()

	{

	WS_ASSERT_DEBUG((ENormal == iState)||(EDrawn == iState),EWsPanicActiveScheduler);

	TTime stop;

	stop.UniversalTime();

	iTotal += stop.MicroSecondsFrom(iRun).Int64();

	CActiveScheduler::WaitForAnyRequest();

	iRequests++;

	__DEBUG_ONLY(iState = ENormal;)

	iRun.UniversalTime();

	iIdle += iRun.MicroSecondsFrom(stop).Int64();

	}

void CWsActiveScheduler::Error(TInt /*aError*/) const

	{

	iErrors++;

	}

void CWsActiveScheduler::AccumReclaimedIdleTime(TInt64 aMicroSeconds)

	{

	iReclaimedIdleTime += aMicroSeconds;

	}

GLREF_C void StateDump(CWsRootWindow* aRootWindow);

GLREF_C void HeapDump();

// Static objects that need to be destroyed on exit

GLDEF_D CDebugLogBase *wsDebugLog=NULL;

GLDEF_D TInt wsDebugLogLevel=0;

GLDEF_D CIniFile *WsIniFile=NULL;

//

GLDEF_D TPtr nullDescriptor(NULL,0);

LOCAL_D CWsActiveScheduler *TheActiveScheduler;

#if defined(__WINS__)

LOCAL_D TPtrC shellCmd;

#endif

CScreen* CWsTop::iCurrentFocusScreen;

CArrayPtrFlat<CScreen>* CWsTop::iScreens ;

TInt CWsTop::iNumberOfScreens ;

CWsTop::CShellStarter* CWsTop::iShellStarter;

CWindowServer *CWsTop::iServer;

RLibrary CWsTop::iDebugLib;

CWsShellLogon *CWsTop::iShell;

const CWsClient *CWsTop::iShellClient;

TBool CWsTop::iPreviousShellClient=EFalse;

TInt CWsTop::iShellBootMode;

TBool CWsTop::iShuttingDown;

TBool CWsTop::iIsFirstLog=ETrue;

CWsWindowBase *CWsTop::iWindowToSendOffEventsTo=NULL;

RTimer CWsTop::iTimer;

TBool CWsTop::iIgnoreSwitchOffEvent=EFalse;

TBool CWsTop::iFadeEnabled=ETrue;

TBool CWsTop::iFinishEveryFlush=EFalse;

TBool CWsTop::iMultiFocusPolicy=EFalse;

#if defined(__WINS__)

TFullName WsSemName;

#endif

const CWsClient* CWsTop::iTriggerHeapCheckOnClientExit=NULL;

TWsCheckHeapOnDisconnectMode CWsTop::iHeapCheckMode=EWsCheckHeapOnDisconnectModeNone;

TInt CWsTop::iCheckHeapResult=KErrNotReady;

TBool CWsTop::iDoHeapCheckAndRestart=EFalse;

#define RFbsSession_SendCommand_ShutDownMessage 1	// A FBS message that is not published yet and probably never will be.

void CWsTop::DeleteStaticsL()

	{

	iShuttingDown=ETrue;

	CClick::DeleteStatics();

	WsPointer::DeleteStatics();

	CWsClient::DeleteStatics();

//

	delete iShellStarter;

	delete iServer;

	CWsBackedUpWindow::StaticDestroy();

	TWindowServerEvent::DeleteStatics();

	delete iShell;

	DisableLogging();

	CEventQueue::DeleteStaticsL();

	CWsSpriteBase::DeleteStatics();

	CWsGc::DeleteStatics();

	CPlaybackGc::DeleteStatics();

	CWsAnim::DeleteStatics();		//This destroys a GC so must be done while FBSERV is still around

	CWsAnimDll::DeleteStatics();

	CWsFontCache::DestroyInstance();

	iScreens->ResetAndDestroy() ;

	delete iScreens ;

	if (!iDoHeapCheckAndRestart)

		{

		RFbsSession::GetSession()->SendCommand(RFbsSession_SendCommand_ShutDownMessage);		//This line is just being tidy, never really does anything useful.

		}

	RFbsSession::Disconnect();

	iDebugLib.Close();

	iTimer.Close();

//

	delete WsIniFile;

	delete TheActiveScheduler;

	WsGraphicDrawer::FinalClose();

	}

RWsTextCursor *CWsTop::CurrentTextCursor()

	{

	return(FocusWindowGroup() ? FocusWindowGroup()->TextCursor():NULL);

	}

CWsClient *CWsTop::FocusWindowGroupOwner()

	{

	return(FocusWindowGroup() ? FocusWindowGroup()->WsOwner():NULL);

	}

void CWsTop::ClientDestroyed(const CWsClient *aClient)

	{

	if (aClient==iShellClient)

		iShellClient=NULL;

	}

void CWsTop::NewSession(const CWsClient *aClient)

	{

	if (iShellClient==NULL && iShell)

		{

#if defined(__WINS__)

		RThread proc;

		proc=aClient->Client();

#else

		RProcess proc;

		aClient->Client().Process(proc);

#endif

		TFullName procName = proc.FullName();

		// Before comparing the proc name with iShell name , truncate the proc name up to the actual name

		// referring to the process, by removing the part which starts with ':', if exists.

		TInt colonLocation = procName.Locate(':');

		if( KErrNotFound != colonLocation)

			{

			procName = procName.Left(colonLocation);

			}

		if (procName ==iShell->FullName())

			{

			iShellClient=aClient;

			if (!iPreviousShellClient)

				{

				iPreviousShellClient=ETrue;

				aClient->Screen()->RootWindow()->SetColorIfClear();

				}

			}

#if !defined(__WINS__)

		proc.Close();

#endif

		}	

	}

void CWsTop::SessionExited(CWsClient *aClient)

	{

	if (iShuttingDown)

		{

		RProcess proc;

		TInt err=aClient->Client().Process(proc);

		if (err==KErrNone && proc.Id()!=RProcess().Id())

			proc.Kill(0);

		else

			const_cast<RThread&>(aClient->Client()).Kill(0);

		if (err==KErrNone)

			proc.Close();

		}

	else if (iHeapCheckMode!=EWsCheckHeapOnDisconnectModeNone && aClient==iTriggerHeapCheckOnClientExit)

		{

		if (iHeapCheckMode==EWsCheckHeapOnDisconnectModeOnce)

			{

			iHeapCheckMode=EWsCheckHeapOnDisconnectModeNone;

			}

		iTriggerHeapCheckOnClientExit=NULL;

		iDoHeapCheckAndRestart=ETrue;

		Exit();

		}

	if (iServer->SessionCount()==1 && iShellBootMode==EShellBootModeNoReboot && iShell==NULL)

		StartShell();

	}

void CWsTop::RunServerL()

	{

	InitStaticsL();

	CWsMemoryManager* memMgr = CWsMemoryManager::NewLC();

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(memMgr);

	DeleteStaticsL();

	}

void CWsTop::InitStaticsL()

	{

	iShuttingDown=EFalse;

	// By default shell should be started.

	TBool startShell = ETrue;

	// The windows server has been invoked.

	// This may have been from the system starter (via a

	// start up rss file)  

	// This block looks for a "-NoShell" argument in the invocation.

	// The existence of the argument means that shell does not need to be 

	// invoked from here because the new system starter

	// is in charge, and it will do it if required.

	_LIT(KNoShell,"-NOSHELL");

	TInt argLen = User::CommandLineLength();

	if(argLen)

		{

		HBufC* arg = HBufC::NewLC(argLen);

		TPtr argPtr = arg->Des();

		User::CommandLine(argPtr);

		argPtr.UpperCase();

		if(KErrNotFound != argPtr.Find(KNoShell))

			{

			// Don't start the shell. It will be started if required by 

			// the system starter.

			startShell = EFalse;

			}

		CleanupStack::PopAndDestroy(arg);

		}

	TheActiveScheduler=new(ELeave) CWsActiveScheduler;

	CActiveScheduler::Install(TheActiveScheduler);

//

	WsIniFile=CIniFile::NewL();

	_LIT(KWSERVIniFileVarLogEnable,"LOGENABLE");

	TInt loggingLevel;

	if (WsIniFile->FindVar(KWSERVIniFileVarLogEnable,loggingLevel))

		{

		EnableLogging(EDoNotReloadWsIni);

		if (wsDebugLog)

			{

			wsDebugLog->SetLoggingLevel(loggingLevel);

			}

		}

	_LIT(KWSERVIniFileVarFadeEnable,"FADEDISABLE");

	iFadeEnabled = !WsIniFile->FindVar(KWSERVIniFileVarFadeEnable);

	_LIT(KWSERVIniFileVarFinishEveryFlush,"FINISHEVERYFLUSH");

	iFinishEveryFlush = WsIniFile->FindVar(KWSERVIniFileVarFinishEveryFlush);

	_LIT(KWSERVIniFileVarSwitchOffEvent,"IGNORESWITCHOFFEVENT");

	iIgnoreSwitchOffEvent = WsIniFile->FindVar(KWSERVIniFileVarSwitchOffEvent);	

	iServer=CWindowServer::NewL();

	CClick::InitStaticsL();

	RProcess wservProc;

	if (!wservProc.DefaultDataPaged())

	{

		iServer->SetPinClientDescriptors(ETrue);

	}

//

	iServer->StartL(KWSERVServerName);

//

	User::LeaveIfError(FbsStartup());

	User::LeaveIfError(RFbsSession::Connect());

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

	TWindowServerEvent::InitStaticsL();

	//-------------------------------------------

	User::LeaveIfError(  HAL::Get( HAL::EDisplayNumberOfScreens, iNumberOfScreens ) ) ; 

	// Check that the INI file matches the HAL

	WS_ASSERT_ALWAYS(WsIniFile->NumberOfScreens()<=iNumberOfScreens, EWsPanicScreenInformationError);

	iScreens = new (ELeave) CArrayPtrFlat<CScreen>( iNumberOfScreens ) ;  //

	// now construct screens for as long as there is information

	TInt ii ;

	for ( ii = 0 ; ii < iNumberOfScreens ; ++ii )

		{

		InitScreenL( ii ) ;

		}

	//---------------------------------------------

	iCurrentFocusScreen = (*iScreens)[0] ;

	CWsFontCache::CreateInstanceL();

	CWsGc::InitStaticsL();

	CPlaybackGc::InitStaticsL();

	CWsSpriteBase::InitStaticsL();

	CEventQueue::InitStaticsL();

//

	CWsAnimDll::InitStaticsL();

	CWsAnim::InitStaticsL();

//

	TInt bootMode=0;

	_LIT(KWSERVIniFileVarReboot,"REBOOT");

	WsIniFile->FindVar(KWSERVIniFileVarReboot,bootMode);

	if (bootMode>=0 && bootMode<=2)

		iShellBootMode=bootMode;

//

	CWsBackedUpWindow::StaticInitL();

	CWsRedrawMsgWindow::StaticInitL();

//

	WsPointer::InitStaticsL();

	iShellStarter=new (ELeave) CShellStarter;

	iShellStarter->ConstructL();

	_LIT(KPreProcess,"REMOVEFADINGONFOCUSGAIN");

	CWsWindowGroup::SetFocusGainPreprocessing(WsIniFile->FindVar(KPreProcess));

	_LIT(KAbsFade,"ABSOLUTEFADING");

	CWsClientWindow::SetAbsoluteFading(WsIniFile->FindVar(KAbsFade));

//Set the focus policy

	_LIT(KFocusPolicy,"MULTIFOCUSPOLICY");

	if(WsIniFile->FindVar(KFocusPolicy))

		{

		iMultiFocusPolicy = ETrue;	

		}

	RProcess::Rendezvous(KErrNone);

	// Start the shell from here unless the 'NoShell' option has been 

	// received indicating that the system starter will start the shell directly.

	if(startShell)

		{

		StartShell();

		}

	UserSvr::WsRegisterSwitchOnScreenHandling(ETrue);

	}

void CWsTop::InitScreenL( TInt aScreenNumber)  // static

	{

	// create a new screen,  read ini file for aScreenNumber (this happens in CScreen - just need to pass a screen number from here

	CScreen* screen = new (ELeave) CScreen() ;

	CleanupStack::PushL( screen ) ;

	TRect digitiserArea;

	if (aScreenNumber==0)

		{

		TMachineInfoV1Buf machineBuf;

		UserHal::MachineInfo(machineBuf);

		TMachineInfoV1& machineInfo=*(TMachineInfoV1*)machineBuf.Ptr();

		digitiserArea = TRect(-machineInfo.iOffsetToDisplayInPixels,machineInfo.iXYInputSizeInPixels);

		}

	screen->ConstructL(digitiserArea, aScreenNumber);

	iScreens->AppendL( screen ) ; 

	CleanupStack::Pop( screen ) ;

	}

void CWsTop::UpdateAllScreens()

	{

	TInt ii;

	for (ii=0; ii<iNumberOfScreens; ++ii)

		{

		(*iScreens)[ii]->Update();

		}

	}

void CWsTop::ClearAllRedrawStores()

	{

	TInt ii;

	for (ii=0; ii<iNumberOfScreens; ++ii)

		{

		CScreen *screen=(*iScreens)[ii];

		CWsWindowGroup* group=screen->RootWindow()->Child();

		while (group!=NULL)

			{

			CWsWindowBase* win=group->Child();

			if (win)

				{

				while (win!=group)

					{

					static_cast<CWsWindow*>(win)->Redraw()->ClearRedrawStore(ETrue);

					if (win->BaseChild())

						win=win->BaseChild();

					else

						{

						do	

							{

							if (win->NextSibling())

								{

								win=win->NextSibling();

								break;

								}