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

 // Window server 'server' class

 // 

 //

 #include "server.h"

 #include "panics.h"

 #include "wstop.h"

 #include "EVENT.H"

 #include <bitdraw.h>

 #include <hal.h>

 #include "inifile.h"

 #include "wspluginmanager.h"

 GLREF_D CDebugLogBase *wsDebugLog;

 const TUint KRangeCount = 1; 

 // We use a lot of 64 bit time calculations, but a periodic can only cope with signed 32 bit times

 // which gives them a limit of about 35 minutes.

 // Fortunately, our animtions are safe if redrawn early.  Every half an hour isn't going to hurt.

 const TTimeIntervalMicroSeconds KHalfHour = 30 * 60 * 1000 * 1000;

 const TInt KWsServRanges[KRangeCount] = 

 	{	

 	0

 	};

 const TUint8 KElementsIndex[KRangeCount] =

 	{

 	CPolicyServer::EAlwaysPass,		

 	};

 const CPolicyServer::TPolicyElement KPolicyElements[] = 

 	{ 

 	{_INIT_SECURITY_POLICY_C1(ECapabilityPowerMgmt), CPolicyServer::EFailClient}, 

 	{_INIT_SECURITY_POLICY_C1(ECapabilitySwEvent), CPolicyServer::EFailClient}, 

 	{_INIT_SECURITY_POLICY_C1(ECapabilityWriteDeviceData), CPolicyServer::EFailClient} 

 	};

 const CPolicyServer::TPolicy KWsServPolicy =

 	{

 	CPolicyServer::EAlwaysPass, 

 	KRangeCount,

 	KWsServRanges,

 	KElementsIndex,

 	KPolicyElements 	

 	};

 // CWindowServer::CDefaultAnimationScheduler \\\\\\\\\\\\\\\\\\\\\\\\\\\

 class CWindowServer::CDefaultAnimationScheduler: public CBase, public MWsAnimationScheduler

 	{

 public:

 	enum TInactivityBehaviour

 		{

 		EStopAnimation,

 		EStopAllDrawing,

 		EIgnore,

 		};

 	class CKickBack;

 	CDefaultAnimationScheduler(MWsGraphicDrawerEnvironment& aEnv);

 	~CDefaultAnimationScheduler();

 	void ConstructL();		//LeaveScan:  member of nested class declaration

 	// implementing MWsAnimationScheduler

 	void ScheduleAnimation(MWsScreen& aScreen,const TTime& aWhen);

 	void UnscheduleAnimation(MWsScreen& aScreen);

 	void Invalidate(const TGraphicDrawerId& aId);

 	void OnInactive();

 	void OnActive();

 	void ScheduleRedraw(MWsScreen& aScreen,const TTime& aWhen);

 	void DoRedrawNow(MWsScreen& aScreen);

 	void DoRedrawNow(MWsScreen& aScreen, MWsAnimationScheduler::MScreenUpdateObserver& aObserver);

 	void ClearScreenUpdateObserver(const MWsAnimationScheduler::MScreenUpdateObserver& /*aObserver*/) {}

 	TInt RemoveGraphicDrawer(const TGraphicDrawerId &aId);

 private:

 	static TBool OnIdleCallBack(TAny* aAny);

 	void OnIdleCallBack(TBool aForceRedraw);

 	static TBool OnTickCallBack(TAny* aAny);

 	void OnTickCallBack();

 	static TBool OnKickBack(TAny* aAny);

 	void OnKickBack();

 private:

 	MWsGraphicDrawerEnvironment& iEnv;

 	static const TInt64 KRedrawGrace;

 	static const TInt64 KAnimationGrace;

 	static const TInt64 KDsaAnimationGrace;

 	CAsyncCallBack* iIdleInitiator;

 	CPeriodic* iTick;

 	CKickBack* iKickBack;

 	struct TSchedule

 		{

 		MWsScreen* iScreen; // used as a unique index, searching with FindInUnsignedKeyOrder

 		TBool iSchedule;

 		TTime iWhen;

 		TInt iGeneration;

 		};

 	RArray<TSchedule> iSchedule;

 	TInt iGeneration;

 	RArray<TGraphicDrawerId> iInvalidated;

 	TBool iInvalidateAll; // if we could not add to iInvalidated, we have to instead redraw everything

 	TTime iWhenDesired;

 	TBool iInactive;

 	TBool iInactiveDraws;

 	TTime iExpectedTime;

 	TBool iRedrawScheduled;

 	TInt64 iRedrawGracePeriod;

 	TInt64 iAnimationGracePeriod;

 	TInt64 iDsaAnimationGracePeriod;

 	TInactivityBehaviour iInactivityBehaviour;

 	};

 TInt CWindowServer::CDefaultAnimationScheduler::RemoveGraphicDrawer(const TGraphicDrawerId &aId)

 	{

 	TInt index=iInvalidated.Find(aId);

 	if (index!=KErrNotFound)

 		iInvalidated.Remove(index);

 	return index;

 	}	

 class CWindowServer::CDefaultAnimationScheduler::CKickBack: public CActive

 	{

 public:

 	CKickBack(const TCallBack& aCallBack);

 	void ConstructL();

 	void RequestKickBack();

 	~CKickBack();

 private:

 	static TInt IdleThreadFunc(TAny* aAny);

 	void Loop();

 	// from CActive

 	void RunL(); // fires when kicked back by the idle thread

 	void DoCancel();

 private:

 	RThread iWservThread;

 	RThread iIdleThread;

 	TRequestStatus iIdleStatus;

 	TCallBack iCallBack;

 	};

 CWindowServer::CDefaultAnimationScheduler::CKickBack::CKickBack(const TCallBack& aCallBack) :

 CActive(EPriorityNormal),

 iCallBack(aCallBack)

 	{

 	CActiveScheduler::Add(this);

 	}

 void CWindowServer::CDefaultAnimationScheduler::CKickBack::ConstructL()

 	{

 	_LIT(KIdleThreadName,"NearlyIdleKickBack");

 	const TInt KStackSize = 1024;

 	User::LeaveIfError(iWservThread.Open(iWservThread.Id()));

 	User::LeaveIfError(iIdleThread.Create(KIdleThreadName(),IdleThreadFunc,KStackSize,NULL,this));

 	iIdleThread.SetPriority(EPriorityAbsoluteVeryLow);

 	iIdleThread.Resume();

 	}

 void CWindowServer::CDefaultAnimationScheduler::CKickBack::RequestKickBack()

 	{

 	if (!IsActive())

 		{

 		iStatus = KRequestPending;

 		SetActive();

 		TRequestStatus * status = &iIdleStatus;

 		iIdleThread.RequestComplete(status, KErrNone);

 		}

 	}

 void CWindowServer::CDefaultAnimationScheduler::CKickBack::Loop()

 	{

 	FOREVER

 		{

 		// This is used here for performance reasons. 

 		User::WaitForRequest(iIdleStatus); 

 		iIdleStatus = KRequestPending;

 		if (IsActive()&& (iStatus == KRequestPending))

 			{

 			TRequestStatus * status = &iStatus;

 			iWservThread.RequestComplete(status,KErrNone);

 			}

 		}

 	}

 void CWindowServer::CDefaultAnimationScheduler::CKickBack::RunL()

 	{

 	iCallBack.CallBack();

 	}

 void CWindowServer::CDefaultAnimationScheduler::CKickBack::DoCancel()

 	{

 	}

 CWindowServer::CDefaultAnimationScheduler::CKickBack::~CKickBack()

 	{

 	Cancel();

 	iWservThread.Close();

 	iIdleThread.Kill(0);

 	iIdleThread.Close();

 	}

 TInt CWindowServer::CDefaultAnimationScheduler::CKickBack::IdleThreadFunc(TAny* aAny)

 	{

 	CKickBack* owner = reinterpret_cast<CKickBack*>(aAny);

 	ASSERT(owner);

 	if(owner)

 		{

 		owner->Loop();

 		}

 	return KErrNone;

 	}

 // If using the default animation scheduler on a device, these two numbers may be worth tweaking in the inifile

 // However, both are maximum periods - wserv will go faster than either if nothing else is using the system.

 const TInt64 CWindowServer::CDefaultAnimationScheduler::KRedrawGrace = 0; // do redraws immediately

 const TInt64 CWindowServer::CDefaultAnimationScheduler::KAnimationGrace = 35000; // insist upon 35ms grace for other threads to run when animating

 const TInt64 CWindowServer::CDefaultAnimationScheduler::KDsaAnimationGrace = 35000; // insist upon 35ms grace for other threads to run when animating during DSA

 CWindowServer::CDefaultAnimationScheduler::CDefaultAnimationScheduler(MWsGraphicDrawerEnvironment& aEnv):

 	iEnv(aEnv), iSchedule(1,_FOFF(TSchedule,iScreen))

 	{

 	}

 CWindowServer::CDefaultAnimationScheduler::~CDefaultAnimationScheduler()

 	{

 	iSchedule.Close();

 	iInvalidated.Close();

 	delete iKickBack;

 	delete iIdleInitiator;

 	delete iTick;

 	}

 void CWindowServer::CDefaultAnimationScheduler::ConstructL()

 	{

 	_LIT(KOnInactive,"ONINACTIVE");

 	_LIT(KStopAnimation,"STOPANIMATION");

 	_LIT(KStopAllDrawing,"STOPALLDRAWING");

 	_LIT(KIgnore,"IGNORE");

 	TPtrC inactivityBehaviourString;

 	WsIniFile->FindVar(KOnInactive,inactivityBehaviourString);

 	if(inactivityBehaviourString.CompareF(KStopAnimation)==0)

 		iInactivityBehaviour = EStopAnimation;

 	else if(inactivityBehaviourString.CompareF(KStopAllDrawing)==0)

 		iInactivityBehaviour = EStopAllDrawing;

 	else if(inactivityBehaviourString.CompareF(KIgnore)==0)

 		iInactivityBehaviour = EIgnore;

 	_LIT(KRedrawGracePeriod, "REDRAWGRACEPERIOD");

 	TInt tmp = KRedrawGrace;

 	WsIniFile->FindVar(KRedrawGracePeriod, tmp);

 	iRedrawGracePeriod = tmp;

 	_LIT(KAnimationGracePeriod, "ANIMATIONGRACEPERIOD");

 	tmp = KAnimationGrace;

 	WsIniFile->FindVar(KAnimationGracePeriod, tmp);

 	iAnimationGracePeriod = tmp;

 	_LIT(KDsaAnimationGracePeriod, "DSAANIMATIONGRACEPERIOD");

 	tmp = KDsaAnimationGrace;

 	WsIniFile->FindVar(KDsaAnimationGracePeriod, tmp);

 	iDsaAnimationGracePeriod = tmp;

 	iIdleInitiator = new(ELeave) CAsyncCallBack(TCallBack(OnIdleCallBack,this),EWsGraphicAnimateAwaitIdlePriority);

 	iTick = CPeriodic::NewL(EWsGraphicAnimatePriority);

 	_LIT(KDisableIdleAnimation, "DISABLEIDLEANIMATION");

 	if (!WsIniFile->FindVar(KDisableIdleAnimation))

 		{

 		iKickBack = new CKickBack(TCallBack(OnKickBack,this));

 		iKickBack->ConstructL();

 		}

 	}

 void CWindowServer::CDefaultAnimationScheduler::Invalidate(const TGraphicDrawerId& aId)

 	{

 	if(!iInvalidateAll)

 		{

 		switch(iInvalidated.InsertInOrder(aId,TLinearOrder<TGraphicDrawerId>(TGraphicDrawerId::Compare)))

 			{

 			case KErrNone:

 				break;

 			case KErrAlreadyExists:

 				break;

 			default:

 				iInvalidateAll = ETrue;

 				iInvalidated.Reset();

 			}

 		}

 	iIdleInitiator->CallBack();

 	}

 void CWindowServer::CDefaultAnimationScheduler::OnInactive()

 	{

 	iInactive = ETrue;

 	}

 void CWindowServer::CDefaultAnimationScheduler::OnActive()

 	{

 	iInactive = EFalse;

 	if(iInactiveDraws)

 		{

 		iInactiveDraws = EFalse;

 		iIdleInitiator->CallBack();

 		}

 	}

 void CWindowServer::CDefaultAnimationScheduler::ScheduleRedraw(MWsScreen& aScreen,const TTime& aWhen)

 	{

 	iRedrawScheduled = ETrue;

 	ScheduleAnimation(aScreen, aWhen);

 	}

 void CWindowServer::CDefaultAnimationScheduler::DoRedrawNow(MWsScreen& /*aScreen*/)

 	{

 	OnIdleCallBack(ETrue);

 	}

 void CWindowServer::CDefaultAnimationScheduler::DoRedrawNow(MWsScreen& /*aScreen*/, MWsAnimationScheduler::MScreenUpdateObserver& aObserver)

 	{

 	OnIdleCallBack(ETrue);

 	aObserver.ScreenUpdateComplete(KErrNone);

 	}	

 void CWindowServer::CDefaultAnimationScheduler::ScheduleAnimation(MWsScreen& aScreen,const TTime& aWhen)

 	{

 	TSchedule schedule;

 	schedule.iScreen = &aScreen;

 	schedule.iSchedule = ETrue;

 	schedule.iWhen = aWhen;

 	schedule.iGeneration = iGeneration;

 	TBool ok = EFalse;

 	const TInt idx = iSchedule.FindInUnsignedKeyOrder(schedule);

 	if(0 <= idx)

 		{

 		if(iSchedule[idx].iSchedule)

 			{

 			if(iSchedule[idx].iWhen > aWhen)

 				{

 				iSchedule[idx].iWhen = aWhen;

 				}

 			}

 		else

 			{

 			iSchedule[idx] = schedule;

 			}

 		iSchedule[idx].iGeneration = iGeneration;

 		ok = ETrue;

 		}

 	else

 		{

 		ok = (KErrNone == iSchedule.InsertInUnsignedKeyOrder(schedule));

 		}

 	if(ok)

 		{

 		//If the animation runs at very high rate which exceeds the rate WSERV can 

 		//perform the rendering, it is possible that WSERV animation loop will monopolize  

 		//processor time. 

   		User::After(0);	// to yeild from the animation loop 

 		iIdleInitiator->CallBack();

 		}

 	}

 void CWindowServer::CDefaultAnimationScheduler::UnscheduleAnimation(MWsScreen& aScreen)

 	{

 	TSchedule schedule;

 	schedule.iScreen = &aScreen;

 	const TInt idx = iSchedule.FindInUnsignedKeyOrder(schedule);

 	if(0 <= idx)

 		{

 		iSchedule[idx].iSchedule = EFalse;

 		}

 	}

 TBool CWindowServer::CDefaultAnimationScheduler::OnIdleCallBack(TAny* aAny)

 	{

 	CDefaultAnimationScheduler* self = reinterpret_cast<CDefaultAnimationScheduler*>(aAny);

 	ASSERT(self);

 	if(self)

 		{

 		self->OnIdleCallBack(EFalse);

 		}

 	return EFalse; //ignored by caller

 	}

 void CWindowServer::CDefaultAnimationScheduler::OnIdleCallBack(TBool aForceRedraw)

 	{

 	TBool wasActive = EFalse;

 	if (iTick->IsActive())

 		{

 		wasActive = ETrue;

 		iTick->Cancel(); // stop ticker, as we'll reschedule if necessary

 		}

 	if (aForceRedraw)

 		{

 		// Don't need to update iExpectedTime as we will not schedule a tick.

 		// Don't need to update iWhenDesired as we will not schedule a kick-back.

 		OnTickCallBack();

 		return;

 		}

 	TBool tick = (iInvalidateAll || iInvalidated.Count());

 	TTimeIntervalMicroSeconds next = 0LL;

 	const TInt count = iSchedule.Count();

 	TTime now;

 	now.UniversalTime();

 	if(count)

 		{

 		// work out the next wanted tick

 		TBool animTick = EFalse;

 		for(TInt i=0; i<count; i++)

 			{

 			if(iSchedule[i].iSchedule)

 				{

 				const TTime when = iSchedule[i].iWhen;

 				const TTimeIntervalMicroSeconds fromNow = when.MicroSecondsFrom(now);

 				if(!animTick || (fromNow < next))

 					{

 					animTick = ETrue;

 					tick = ETrue;

 					next = fromNow;

 					iWhenDesired = when;

 					}

 				}

 			}

 		}

 	if(tick)

 		{

 		TInt64 grace;

 		if (iRedrawScheduled)

 			grace = iRedrawGracePeriod;

 		else if (EFalse) // DSA active

 			grace = iDsaAnimationGracePeriod;

 		else

 			grace = iAnimationGracePeriod;

 		if (wasActive)

 			{

 			TInt64 minimum = iExpectedTime.MicroSecondsFrom(now).Int64();

 			if (minimum >= 0 && grace > minimum)

 				grace = minimum;

 			}

 		if (next.Int64() <= 0)

 			next = 0LL ;  // No kickback/tick is needed. Make sure next == default grace period.

 		if(next < grace)

 			{

 			next = grace;

 			if (iKickBack)

 				iKickBack->RequestKickBack();

 			}

 		else if (next > KHalfHour)

 			next = KHalfHour;

 		iExpectedTime=now + next;

 		if (next.Int64() > 0)

 			{

 			iTick->Start(next.Int64(),0,TCallBack(OnTickCallBack,this));

 			}

 		else

 			{

 			OnTickCallBack(); // scheduling for 0 doesn't actually execute immediately

 			}

 		}

 	}

 TBool CWindowServer::CDefaultAnimationScheduler::OnKickBack(TAny* aAny)

 	{

 	CDefaultAnimationScheduler* self = reinterpret_cast<CDefaultAnimationScheduler*>(aAny);

 	ASSERT(self);

 	if(self)

 		{

 		self->OnKickBack();

 		}

 	return EFalse; //ignored by caller

 	}

 void CWindowServer::CDefaultAnimationScheduler::OnKickBack()

 	{

 	if (iTick->IsActive())

 		{

 		iTick->Cancel();

 		TTime now;

 		now.UniversalTime();

 		TTimeIntervalMicroSeconds fromNow = iWhenDesired.MicroSecondsFrom(now);

 		if (fromNow < 0)

 			{

 			OnTickCallBack();

 			}

 		else

 			{

 			if (fromNow > KHalfHour)

 				fromNow = KHalfHour;

 			iTick->Start(fromNow.Int64(),0,TCallBack(OnTickCallBack, this));

 			}

 		}

 	}

 TBool CWindowServer::CDefaultAnimationScheduler::OnTickCallBack(TAny* aAny)

 	{

 	CDefaultAnimationScheduler* self = reinterpret_cast<CDefaultAnimationScheduler*>(aAny);

 	ASSERT(self);

 	if(self)

 		{

 		self->OnTickCallBack();

 		}

 	return EFalse;

 	}

 void CWindowServer::CDefaultAnimationScheduler::OnTickCallBack()

 	{

 	iTick->Cancel();

 	switch(iInactivityBehaviour)

 		{

 		case EStopAnimation :

 			// only client redraws if inactive. server side drawing stopped.

 			if(iInactive && !iRedrawScheduled) 

 				{

 				iInactiveDraws = ETrue;

 				return;

 				}

 			break;

 		case EStopAllDrawing :

 			// if screen off, stop both client and server side drawing.

 			if(iInactive) 

 				{

 				iInactiveDraws = ETrue;

 				return;

 				}

 			break;

 		case EIgnore :

 		default :

 			// ignore inactivity and draw as normal

 			break;

 		}

 	iRedrawScheduled = EFalse;

 	TTime now;

 	now.UniversalTime();

 	CWsActiveScheduler::Static()->AccumReclaimedIdleTime(Max(0LL,now.MicroSecondsFrom(iExpectedTime).Int64()));

 	TInt drewCount = 0;

 	TInt scheduledCount = 0;

 	/* first redraw any screens that are affected by invalidated graphic IDs */

 	if(iInvalidateAll || iInvalidated.Count())

 		{

 		// cancel idle callback if it's already scheduled as we're going to redraw all invalidated 

 		// request at this point and clear invalidated array

 		if (iIdleInitiator->IsActive())

 			iIdleInitiator->Cancel();

 		const TArray<TGraphicDrawerId> invalidArray = iInvalidated.Array();

 		const TInt screenCount = iEnv.ScreenCount();

 		for(TInt i=0; i<screenCount; i++)

 			{

 			MWsScreen* screen = iEnv.Screen(i);

 			if(screen)

 				{

 				drewCount++;

 				if(iInvalidateAll)

 					{

 					Redraw(*screen);

 					}

 				else

 					{

 					RedrawInvalid(*screen,invalidArray);

 					}

 				}

 			}

 		iInvalidateAll = EFalse;

 		iInvalidated.Reset();

 		}

 	/* iSchedule might resize during this call because an Animate() on a screen might reschedule another animation etc */

 	TInt generation = iGeneration++;

 	TBool drew;

 	do

 		{

 		drew = EFalse;

 		const TInt count = iSchedule.Count();

 		for(TInt i=0; i<count; i++)

 			{

 			if(iSchedule[i].iSchedule)

 				{

 				scheduledCount++;

 				if(iSchedule[i].iGeneration == generation)

 					{

 					iSchedule[i].iSchedule = EFalse; // denote not to tick; it can be rescheduled in the subsequent call to Animate()

 					Animate(*(iSchedule[i].iScreen));

 					drew = ETrue;

 					drewCount++;

 					break; // go back to outer do while(drew)

 					}

 				}

 			}

 		} while(drew);

 	__DEBUG_ONLY(

 		TBool idleIsActive = iIdleInitiator->IsActive();

 		if(scheduledCount || !drewCount)

 			{

 			TBool rescheduled = EFalse;

 			for(TInt i=0; i<iSchedule.Count(); i++)

 				{

 				rescheduled |= iSchedule[i].iSchedule;

 				}

 			if(!rescheduled)

 				{

 				//__DEBUGGER();

 				}

 			})

 	}

 // CWindowServer \\\\\\\\\\\\\\\\\\\\\\\\\\\

 CWindowServer *CWindowServer::NewL()

 //

 // Create a new CWindowServer.

 //

 	{

 	CWindowServer* self = new(ELeave) CWindowServer();

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CWindowServer::CWindowServer()

 //

 // Constructor.

 //

 	: CPolicyServer(EMainServerPriority,KWsServPolicy)

 	{

 	}

 CWindowServer::~CWindowServer()

 	{

 	iMemoryReleases.Reset();

 	WS_ASSERT_DEBUG(iDrawerMasterIndex.IsEmpty(), EWsPanicWsGraphic);

 	iDrawerMasterIndex.Close();

 	delete iDefaultAnimationScheduler;

 	iDefaultAnimationScheduler = NULL; // might be called from clients during server destruction

 	delete iPluginManager;

 	}

 void CWindowServer::ConstructL()

 	{

 	iPluginManager = CWsPluginManager::NewL(*this);

 	iDefaultAnimationScheduler = new(ELeave) CDefaultAnimationScheduler(*this);

 	iDefaultAnimationScheduler->ConstructL();

 	RegisterMemoryRelease(this);

 	}

 /** Creates a new client for this server. */

 CSession2* CWindowServer::NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const

 	{

 	TVersion v(KWservMajorVersionNumber,KWservMinorVersionNumber,KWservBuildVersionNumber);

 	if (User::QueryVersionSupported(v,aVersion)==EFalse)

 		User::Leave(KErrNotSupported);

 	RThread thread;

 	User::LeaveIfError(aMessage.Client(thread));

 	return(new(ELeave) CWsClient(thread));

 	}

 TInt CWindowServer::SessionCount()

 	{

 	iSessionIter.SetToFirst();

 	TInt count=0;

 	while(iSessionIter++)

 		count++;

 	return(count);

 	}

 const CWsGraphicDrawer* CWindowServer::ResolveGraphic(const TGraphicDrawerId& aId) const

 	{

 	return iDrawerMasterIndex.ResolveGraphic(aId);

 	}

 void CWindowServer::Invalidate(const TGraphicDrawerId& aId)

 	{

 	AnimationScheduler()->Invalidate(aId);

 	}

 TInt CWindowServer::ScreenCount() const

 	{

 	return CWsTop::NumberOfScreens();

 	}

 MWsScreen* CWindowServer::Screen(TInt aIndex)

 	{

 	if((aIndex >= 0) && (aIndex < ScreenCount()))

 		{

 		return CWsTop::Screen(aIndex);

 		}

 	return NULL;

 	}

 const MWsScreen* CWindowServer::Screen(TInt aIndex) const

 	{

 	if((aIndex >= 0) && (aIndex < ScreenCount()))

 		{

 		return CWsTop::Screen(aIndex);

 		}

 	return NULL;

 	}

 /**

 Custom Animation Scheduler

 */

 TBool CWindowServer::SetCustomAnimationScheduler(MWsAnimationScheduler* /*aScheduler*/)

 	{

 	return EFalse;

 	}

 TBool CWindowServer::HasCustomAnimationScheduler() const

 	{

 	return EFalse;

 	}

 TBool CWindowServer::ClearCustomAnimationScheduler(MWsAnimationScheduler* /*aCurrentScheduler*/)

 	{

 	return EFalse;

 	}

 MWsAnimationScheduler* CWindowServer::AnimationScheduler()

 	{

 	return iDefaultAnimationScheduler;

 	}

 TInt CWindowServer::RegisterEventHandler(CWsGraphicDrawer* aDrawer, MWsEventHandler* aHandler, TUint32 aEventMask)

 	{

 	if (!aDrawer || !aHandler || aEventMask==0)

 		return KErrArgument;

 	TInt err = TWindowServerEvent::RegisterDrawerHandler(aDrawer, aEventMask);

 	if (err != KErrNone)

 		return err;

 	aDrawer->SetEventHandler(aHandler);

 	return KErrNone;

 	}

 TInt CWindowServer::UnregisterEventHandler(CWsGraphicDrawer* aDrawer)

 	{

 	if (!aDrawer || (aDrawer && !aDrawer->HasEventHandler()))

 		return KErrArgument;

 	TInt err = TWindowServerEvent::UnregisterDrawerHandler(aDrawer);

 	if (err != KErrNone)

 		return err;

 	aDrawer->SetEventHandler(NULL);

 	return KErrNone;

 	}

 TInt CWindowServer::RegisterWsEventHandler(MWsEventHandler* aHandler, TUint32 aEventMask)

 	{

 	if (!aHandler || aEventMask==0)

 		return KErrArgument;

 	return TWindowServerEvent::RegisterWsEventHandler(aHandler, aEventMask);

 	}

 TInt CWindowServer::UnregisterWsEventHandler(MWsEventHandler* aHandler)

 	{

 	return TWindowServerEvent::UnregisterWsEventHandler(aHandler);

 	}

 TInt CWindowServer::RegisterRawEventHandler(MEventHandler* aHandler)

 	{

 	if (!aHandler)

 		return KErrArgument;

 	TRAPD(err, TWindowServerEvent::PotentialEventHandlerL(1));

 	if (err != KErrNone)

 		return err;

 	TWindowServerEvent::AddEventHandler(aHandler);

 	return KErrNone;

 	}

 void CWindowServer::UnregisterRawEventHandler(MEventHandler* aHandler)

 	{

 	TWindowServerEvent::RemoveEventHandler(aHandler);

 	TWindowServerEvent::PotentialEventHandlerL(-1); // can't leave for -1

 	}

 void CWindowServer::PostRawEvent(const TRawEvent & aEvent)

 	{

 	TWindowServerEvent::ProcessRawEvent(aEvent);

 	}

 void CWindowServer::PostKeyEvent(const TKeyEvent & aEvent)

 	{

 	TWindowServerEvent::ProcessKeyEvent(aEvent, 0);

 	}

 TAny* CWindowServer::ResolveObjectInterface(TUint aTypeId)

 	{

 	switch(aTypeId)

 		{

 		case MWsActiveSchedulerDebug::EWsObjectInterfaceId:

 			return static_cast<MWsActiveSchedulerDebug*>(CWsActiveScheduler::Static());

 		case MWsIniFile::EWsObjectInterfaceId:

 			return static_cast<MWsIniFile*>(WsIniFile);

 		case MWsRawEventServer::EWsObjectInterfaceId:

 			return static_cast<MWsRawEventServer*>(this);

 		}

 	if (iPluginManager)

 		return iPluginManager->ResolveObjectInterface(aTypeId);

 	return NULL;

 	}

 void CWindowServer::Log(TInt aPriority,const TDesC &aFmt,TInt aParam)

 	{

 	if (wsDebugLog)

 		{

 		wsDebugLog->MiscMessage(aPriority, aFmt, aParam);

 		}

 	}

 // CWsGraphicDrawer master index

 TInt CWindowServer::AddGraphicDrawer(CWsGraphicDrawer* aDrawer)

 	{

 	return iDrawerMasterIndex.Add(aDrawer);

 	}

 TInt CWindowServer::SwapGraphicDrawer(CWsGraphicDrawer* aDrawer)

 	{

 	return iDrawerMasterIndex.Swap(aDrawer);

 	}

 TInt CWindowServer::RemoveGraphicDrawer(const TGraphicDrawerId& aId)

 	{

 	iDefaultAnimationScheduler->RemoveGraphicDrawer(aId);

 	return iDrawerMasterIndex.Remove(aId);

 	}

 TInt CWindowServer::RemoveAllGraphicDrawers(const MWsClient& aOwner)

 	{

 	return iDrawerMasterIndex.RemoveAll(aOwner);

 	}

 CWsPluginManager* CWindowServer::PluginManager()

 	{

 	return iPluginManager;

 	}

 TInt CWindowServer::RegisterMemoryRelease(MWsMemoryRelease * aMemoryRelease)

 	{

 	return iMemoryReleases.Append(aMemoryRelease);

 	}

 void CWindowServer::UnregisterMemoryRelease(MWsMemoryRelease * aMemoryRelease)

 	{

 	for (TInt i = iMemoryReleases.Count() - 1; i >= 0; --i)

 		{

 		if (iMemoryReleases[i] == aMemoryRelease)

 			{

 			iMemoryReleases.Remove(i);

 			break;

 			}

 		}

 	}

 TBool CWindowServer::ReleaseMemory(TMemoryReleaseLevel aLevel)

 	{

 	return CWsWindow::ReleaseMemory(aLevel);

 	}

 TBool CWindowServer::ReleaseMemory()

 	{

 	TBool released = EFalse;

 	for (TInt level = MWsMemoryRelease::ELow; !released && level <= MWsMemoryRelease::EHigh; ++level)

 		{

 		for (TInt i = iMemoryReleases.Count() - 1; !released && i >= 0; --i)

 			{

 			released = iMemoryReleases[i]->ReleaseMemory(static_cast<TMemoryReleaseLevel>(level));

 			}

 		}

 	return released;

 	}