sl@0: // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // Window server 'server' class
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include "server.h"
sl@0: #include "panics.h"
sl@0: #include "wstop.h"
sl@0: #include "EVENT.H"
sl@0: #include <bitdraw.h>
sl@0: #include <hal.h>
sl@0: #include "inifile.h"
sl@0: #include "wspluginmanager.h"
sl@0: #include "graphics/windowserverconstants.h"
sl@0: 
sl@0: GLREF_D CDebugLogBase *wsDebugLog;
sl@0: 
sl@0: const TUint KRangeCount = 1; 
sl@0: // We use a lot of 64 bit time calculations, but a periodic can only cope with signed 32 bit times
sl@0: // which gives them a limit of about 35 minutes.
sl@0: // Fortunately, our animtions are safe if redrawn early.  Every half an hour isn't going to hurt.
sl@0: const TTimeIntervalMicroSeconds KHalfHour = 30 * 60 * 1000 * 1000;
sl@0: 
sl@0: const TInt KWsServRanges[KRangeCount] = 
sl@0: 	{	
sl@0: 	0
sl@0: 	};
sl@0: 
sl@0: const TUint8 KElementsIndex[KRangeCount] =
sl@0: 	{
sl@0: 	CPolicyServer::EAlwaysPass,		
sl@0: 	};
sl@0: 
sl@0: const CPolicyServer::TPolicyElement KPolicyElements[] = 
sl@0: 	{ 
sl@0: 	{_INIT_SECURITY_POLICY_C1(ECapabilityPowerMgmt), CPolicyServer::EFailClient}, 
sl@0: 	{_INIT_SECURITY_POLICY_C1(ECapabilitySwEvent), CPolicyServer::EFailClient}, 
sl@0: 	{_INIT_SECURITY_POLICY_C1(ECapabilityWriteDeviceData), CPolicyServer::EFailClient} 
sl@0: 	};
sl@0: 
sl@0: const CPolicyServer::TPolicy KWsServPolicy =
sl@0: 	{
sl@0: 	CPolicyServer::EAlwaysPass, 
sl@0: 	KRangeCount,
sl@0: 	KWsServRanges,
sl@0: 	KElementsIndex,
sl@0: 	KPolicyElements 	
sl@0: 	};
sl@0:  	
sl@0: // CWindowServer::CDefaultAnimationScheduler \\\\\\\\\\\\\\\\\\\\\\\\\\\
sl@0: 
sl@0: class CWindowServer::CDefaultAnimationScheduler: public CBase, public MWsAnimationScheduler
sl@0: 	{
sl@0: 	// Associates a screen number with a CActiveSchedulerWait intance. This is used to
sl@0: 	// achieve synchronous update completion on a specific screen.
sl@0: 	class CScreenUpdateWait : public CActiveSchedulerWait
sl@0: 		{
sl@0: 		public:
sl@0: 			CScreenUpdateWait(TInt aScreenNumber) : iScreenNumber (aScreenNumber) {}
sl@0: 			TInt iScreenNumber;	
sl@0: 		};
sl@0: 	
sl@0: 	struct TScreenUpdateDetails
sl@0: 		{
sl@0: 		CWindowServer::CDefaultAnimationScheduler* iScheduler;
sl@0: 		TInt  iScreenNumber;
sl@0: 		};
sl@0: 	
sl@0: 	struct TSchedule
sl@0: 		{
sl@0: 		MWsScreen* iScreen; // used as a unique index, searching with FindInUnsignedKeyOrder
sl@0: 		TInt  iScreenNumber;
sl@0: 		TBool iScheduled;
sl@0: 		TTime iWhen;
sl@0: 		TBool iRedraw;
sl@0: 		};
sl@0: public:
sl@0: 	enum TInactivityBehaviour
sl@0: 		{
sl@0: 		EStopAnimation,
sl@0: 		EStopAllDrawing,
sl@0: 		EIgnore,
sl@0: 		};
sl@0: 	class CScreenState;
sl@0: 
sl@0: 	CDefaultAnimationScheduler(MWsGraphicDrawerEnvironment& aEnv);
sl@0: 	~CDefaultAnimationScheduler();
sl@0: 	void ConstructL();		//LeaveScan:  member of nested class declaration
sl@0: 	// implementing MWsAnimationScheduler
sl@0: 	void ScheduleAnimation(MWsScreen& aScreen,const TTime& aWhen);
sl@0: 	void UnscheduleAnimation(MWsScreen& aScreen);
sl@0: 	void Invalidate(const TGraphicDrawerId& aId);
sl@0: 	void OnInactive();
sl@0: 	void OnActive();
sl@0: 	void ScheduleRedraw(MWsScreen& aScreen,const TTime& aWhen);
sl@0: 	void DoRedrawNow(MWsScreen& aScreen);
sl@0: 	void DoRedrawNow(MWsScreen& aScreen, MWsAnimationScheduler::MScreenUpdateObserver& aObserver);
sl@0: 	void ClearScreenUpdateObserver(const MWsAnimationScheduler::MScreenUpdateObserver& aObserver);
sl@0: private:
sl@0: 	static TBool OnIdleCallBack(TAny* aAny);
sl@0: 	void ScheduleUpdate (TInt aScreenNumber, TBool aForce);
sl@0: 	void OnIdleCallBack(TBool aForce);
sl@0: 	static TBool InvokeDueAnimation(TAny* aAny);
sl@0: 	void RedrawAllInvalidatedRegions (TInt aScreen);
sl@0: 	TSchedule* GetScheduledScreenUpdate(TInt aScreen);
sl@0: 	void InvokeDueAnimation(TInt aScreen);
sl@0: 	void ProcessUpdateCompletion (TInt aScreenNumber);
sl@0: 	TInt ScreenNumber(MWsScreen& aScreen) const;
sl@0: 	TTimeIntervalMicroSeconds GetDueDelta (TBool aForceRedraw, TSchedule* aScheduledUpdate);
sl@0: private:
sl@0: 	RPointerArray<CScreenUpdateWait> iRedrawWaitLoop; 
sl@0: 	RPointerArray<CScreenState> iScreenState;
sl@0: 	MWsGraphicDrawerEnvironment& iEnv;
sl@0: 	static const TInt64 KRedrawGrace;
sl@0: 	static const TInt64 KAnimationGrace;
sl@0: 	CAsyncCallBack* iIdleInitiator;
sl@0: 	TBool iInRedrawNow;
sl@0: 	RArray<TSchedule> iSchedule;
sl@0: 	TBool iInactive;
sl@0: 	TBool iInactiveDraws;
sl@0: 	TBool iRedrawScheduled;
sl@0: 	TInt64 iRedrawGracePeriod;
sl@0: 	TInt64 iAnimationGracePeriod;
sl@0: 	TInactivityBehaviour iInactivityBehaviour;
sl@0: 	};
sl@0: 
sl@0: class CWindowServer::CDefaultAnimationScheduler::CScreenState : public CActive
sl@0: 	{
sl@0: public:
sl@0: 	static CScreenState* NewL (CDefaultAnimationScheduler* aScheduler, TInt aScreenOrdinal);
sl@0: 	~CScreenState();
sl@0: 	void SetActive ();
sl@0: 	
sl@0: 	void WaitForRedraws(MWsAnimationScheduler::MScreenUpdateObserver& aObserver, TInt aNumRedraws);
sl@0: 	void ClearScreenUpdateObserver(const MWsAnimationScheduler::MScreenUpdateObserver& aObserver);
sl@0: 	CPeriodic* iUpdateOn;
sl@0: 	TTime      iExpectedTickTime;
sl@0: 	TScreenUpdateDetails iScreenUpdateDetails;
sl@0: 	RArray<TGraphicDrawerId> iInvalidated;
sl@0: 	TBool 		iInvalidateAll;
sl@0: 	
sl@0: private:
sl@0: 	CScreenState (CDefaultAnimationScheduler* aScheduler, TInt aScreenOrdinal);
sl@0: 	void ConstructL ();
sl@0: 	void ReleaseRemainingClients();
sl@0: 	void ReleaseClientsWaitingFor(TUint aCurrentFrame);
sl@0: 	
sl@0: 	void RunL();
sl@0: 	void DoCancel() 
sl@0: 		{
sl@0: 		TRequestStatus* tmpTRS = &iStatus;
sl@0: 		User::RequestComplete(tmpTRS, KErrNone);
sl@0: 		};
sl@0: 	class TWaitingClient
sl@0: 		{
sl@0: 	public:
sl@0: 		TWaitingClient(MWsAnimationScheduler::MScreenUpdateObserver& aObserver, TInt aTargetFrame)
sl@0: 			: iObserver(aObserver), iTargetFrame(aTargetFrame)
sl@0: 			{
sl@0: 			}
sl@0: 		MWsAnimationScheduler::MScreenUpdateObserver& iObserver;
sl@0: 		TUint iTargetFrame;
sl@0: 		};
sl@0: 	TUint iFrameCount;
sl@0: 	RArray<TWaitingClient> iWaitingClients;
sl@0: 	};
sl@0: 
sl@0: // If using the default animation scheduler on a device, these two numbers may be worth tweaking in the inifile
sl@0: // However, both are maximum periods - wserv will go faster than either if nothing else is using the system.
sl@0: const TInt64 CWindowServer::CDefaultAnimationScheduler::KRedrawGrace = 0; // do redraws immediately
sl@0: const TInt64 CWindowServer::CDefaultAnimationScheduler::KAnimationGrace = 0; // do animation redraws immediately
sl@0: 	
sl@0: CWindowServer::CDefaultAnimationScheduler::CDefaultAnimationScheduler(MWsGraphicDrawerEnvironment& aEnv):
sl@0: 	iEnv(aEnv), iSchedule(1,_FOFF(TSchedule,iScreen))
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: CWindowServer::CDefaultAnimationScheduler::~CDefaultAnimationScheduler()
sl@0: 	{
sl@0: 	iSchedule.Close();
sl@0: 	delete iIdleInitiator;
sl@0: 	
sl@0: 	TInt screenCount = iScreenState.Count();
sl@0: 	for (TInt ii = 0; ii < screenCount; ii++)
sl@0: 		delete iScreenState[ii];
sl@0: 
sl@0: 	iScreenState.Close();
sl@0: 
sl@0: 	// Destroy the redraw wait loops associated each screen, and close
sl@0: 	// the associated Array objects.
sl@0: 	TInt waitLoopCount = iRedrawWaitLoop.Count();
sl@0: 	for (TInt waitLoop = 0; waitLoop < waitLoopCount; waitLoop++)
sl@0: 		delete iRedrawWaitLoop[waitLoop];
sl@0: 	iRedrawWaitLoop.Close();
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::CDefaultAnimationScheduler::ConstructL()
sl@0: 	{
sl@0: 	_LIT(KOnInactive,"ONINACTIVE");
sl@0: 	_LIT(KStopAnimation,"STOPANIMATION");
sl@0: 	_LIT(KStopAllDrawing,"STOPALLDRAWING");
sl@0: 	_LIT(KIgnore,"IGNORE");
sl@0: 	
sl@0: 	TPtrC inactivityBehaviourString;
sl@0: 	WsIniFile->FindVar(KOnInactive,inactivityBehaviourString);
sl@0: 	if(inactivityBehaviourString.CompareF(KStopAnimation)==0)
sl@0: 		iInactivityBehaviour = EStopAnimation;
sl@0: 	else if(inactivityBehaviourString.CompareF(KStopAllDrawing)==0)
sl@0: 		iInactivityBehaviour = EStopAllDrawing;
sl@0: 	else if(inactivityBehaviourString.CompareF(KIgnore)==0)
sl@0: 		iInactivityBehaviour = EIgnore;
sl@0: 		
sl@0: 	_LIT(KRedrawGracePeriod, "REDRAWGRACEPERIOD");
sl@0: 	TInt tmp = KRedrawGrace;
sl@0: 	WsIniFile->FindVar(KRedrawGracePeriod, tmp);
sl@0: 	iRedrawGracePeriod = tmp;
sl@0: 	
sl@0: 	_LIT(KAnimationGracePeriod, "ANIMATIONGRACEPERIOD");
sl@0: 	tmp = KAnimationGrace;
sl@0: 	WsIniFile->FindVar(KAnimationGracePeriod, tmp);
sl@0: 	iAnimationGracePeriod = tmp;
sl@0: 	
sl@0: 	iIdleInitiator = new(ELeave) CAsyncCallBack(TCallBack(OnIdleCallBack,this),EWsGraphicAnimateAwaitIdlePriority);
sl@0: 	
sl@0: 	TInt screenCount;
sl@0: 	User::LeaveIfError(HAL::Get( HAL::EDisplayNumberOfScreens, screenCount)); 
sl@0: 	for (TInt i = 0; i < screenCount; i++)
sl@0: 		{
sl@0: 		CScreenState* screenState = CScreenState::NewL (this, i);
sl@0: 		CleanupStack::PushL(screenState);
sl@0: 		iScreenState.AppendL (screenState);
sl@0: 		CleanupStack::Pop(screenState);
sl@0: 		}
sl@0: 		
sl@0: 	
sl@0: 	// Ensure that the wait loop array has some allocated slots, making it highly 
sl@0: 	// unlikely that Append() will fail due to OOM.
sl@0: 	iRedrawWaitLoop.ReserveL (8);
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::Invalidate(const TGraphicDrawerId& aId)
sl@0: 	{
sl@0: 	const TInt screenCount = iEnv.ScreenCount();
sl@0: 	for(TInt ii = 0; ii < screenCount; ii++)
sl@0: 		{
sl@0: 		CScreenState* screenState = iScreenState[ii];
sl@0: 		if(!screenState->iInvalidateAll)
sl@0: 			{
sl@0: 			switch(screenState->iInvalidated.InsertInOrder(aId,TLinearOrder<TGraphicDrawerId>(TGraphicDrawerId::Compare)))
sl@0: 				{
sl@0: 				case KErrNone:
sl@0: 				case KErrAlreadyExists:
sl@0: 					break;
sl@0: 				default:
sl@0: 					screenState->iInvalidateAll = ETrue;
sl@0: 					screenState->iInvalidated.Reset();
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	iIdleInitiator->CallBack();
sl@0: 	}
sl@0: 
sl@0: CWindowServer::CDefaultAnimationScheduler::CScreenState::CScreenState (CDefaultAnimationScheduler* aScheduler, TInt aScreenNumber):
sl@0: 	CActive(EComposeCompletePriority)
sl@0: 	{
sl@0: 	iScreenUpdateDetails.iScheduler = aScheduler;
sl@0: 	iScreenUpdateDetails.iScreenNumber = aScreenNumber;
sl@0: 	}
sl@0: 
sl@0: CWindowServer::CDefaultAnimationScheduler::CScreenState* 
sl@0: CWindowServer::CDefaultAnimationScheduler::CScreenState::NewL (CDefaultAnimationScheduler* aScheduler, TInt aScreenOrdinal)
sl@0: 	{
sl@0: 	CScreenState* self = new(ELeave)CScreenState(aScheduler, aScreenOrdinal);
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL();
sl@0: 	CleanupStack::Pop(self);
sl@0: 	return self;	
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::CScreenState::ConstructL ()
sl@0: 	{
sl@0: 	iUpdateOn = CPeriodic::NewL(EComposeCompletePriority);
sl@0: 	iWaitingClients.ReserveL(8);
sl@0: 	CActiveScheduler::Add(this);
sl@0: 	}
sl@0: 
sl@0: CWindowServer::CDefaultAnimationScheduler::CScreenState::~CScreenState()
sl@0: 	{
sl@0: 	CActive::Cancel();
sl@0: 	iInvalidated.Close();
sl@0: 	delete iUpdateOn;
sl@0: 	TInt i = iWaitingClients.Count();
sl@0: 	while(i--)
sl@0: 		{
sl@0: 		iWaitingClients[i].iObserver.ScreenUpdateComplete(KErrAbort);
sl@0: 		}
sl@0: 	iWaitingClients.Close();
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::CScreenState::SetActive()
sl@0: 	{
sl@0: 	CActive::SetActive ();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: This function is called from CWsClient d'tor to make sure we will not hang on to any deleted objects. 
sl@0: */
sl@0: void CWindowServer::CDefaultAnimationScheduler::CScreenState::ClearScreenUpdateObserver(const MWsAnimationScheduler::MScreenUpdateObserver& aObserver)
sl@0: 	{
sl@0: 	const TInt count = iWaitingClients.Count();
sl@0: 	for(TInt i = count-1 ; i >= 0; i--)
sl@0: 		{
sl@0: 		if( &aObserver == &(iWaitingClients[i].iObserver) )
sl@0: 			{
sl@0: 			TWaitingClient& client = iWaitingClients[i];
sl@0: 			client.iObserver.ScreenUpdateComplete(KErrCancel);
sl@0: 			iWaitingClients.Remove(i);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::CScreenState::WaitForRedraws(MWsAnimationScheduler::MScreenUpdateObserver& aObserver, TInt aNumRedraws)
sl@0: 	{
sl@0: 	const TUint targetFrame = iFrameCount + aNumRedraws;
sl@0: 	TWaitingClient request(aObserver, targetFrame);
sl@0: 	TInt err = iWaitingClients.Append(request);
sl@0: 	if(err != KErrNone)
sl@0: 		{
sl@0: 		//If OOM and already have 8 waiting clients we will not accept a 9th client
sl@0: 		aObserver.ScreenUpdateComplete(KErrNoMemory);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::CScreenState::ReleaseRemainingClients()
sl@0: 	{
sl@0: 	const TInt count = iWaitingClients.Count();
sl@0: 	for(TInt i = count-1; i >= 0; i--)
sl@0: 		{
sl@0: 		TWaitingClient& client = iWaitingClients[i];
sl@0: 		client.iObserver.ScreenUpdateComplete(KErrNone);
sl@0: 		iWaitingClients.Remove(i);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::CScreenState::ReleaseClientsWaitingFor(TUint aCurrentFrame)
sl@0: 	{
sl@0: 	const TInt count = iWaitingClients.Count();
sl@0: 	for(TInt i = count-1; i >= 0; i--)
sl@0: 		{
sl@0: 		TWaitingClient& client = iWaitingClients[i];
sl@0: 		if(aCurrentFrame == client.iTargetFrame)
sl@0: 			{
sl@0: 			client.iObserver.ScreenUpdateComplete(KErrNone);
sl@0: 			iWaitingClients.Remove(i);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /** 
sl@0: Invoked when the rendering pipline signals that it is ready to receive updates.
sl@0: */
sl@0: void CWindowServer::CDefaultAnimationScheduler::CScreenState::RunL() 
sl@0: 	{
sl@0: 	iFrameCount++;
sl@0: 	
sl@0: 	//Complete any clients waiting for this frame
sl@0: 	ReleaseClientsWaitingFor(iFrameCount);
sl@0: 	
sl@0: 	iScreenUpdateDetails.iScheduler->ProcessUpdateCompletion (iScreenUpdateDetails.iScreenNumber);
sl@0: 	
sl@0: 	if(!IsActive())
sl@0: 		{
sl@0: 		//No further pending frames, release all remaining clients
sl@0: 		ReleaseRemainingClients();
sl@0: 		}
sl@0: 	
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::ProcessUpdateCompletion (TInt aScreenNumber)
sl@0: 	{
sl@0: 	// Stop all waitloops related to the specified screen.
sl@0: 	TInt waitLoopCount = iRedrawWaitLoop.Count();
sl@0: 	for (TInt waitLoop = 0; waitLoop < waitLoopCount; waitLoop++)
sl@0: 		if (iRedrawWaitLoop[waitLoop]->IsStarted() && (iRedrawWaitLoop[waitLoop]->iScreenNumber == aScreenNumber))
sl@0: 			iRedrawWaitLoop[waitLoop]->AsyncStop();
sl@0: 	
sl@0: 	// Perform any outstanding redraws on the specified screen.
sl@0: 	ScheduleUpdate (aScreenNumber, ETrue);
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::DoRedrawNow(MWsScreen& aScreen, MWsAnimationScheduler::MScreenUpdateObserver& aObserver)
sl@0: 	{
sl@0: 	TInt screenNumber = ScreenNumber (aScreen);
sl@0: 	TInt redrawCount = 0;
sl@0: 	
sl@0: 	// redrawCount is the number of times we should wait for redraws to complete.
sl@0: 	// If a redraw is not currently active then we need to wait (at most) once: for
sl@0: 	// any outstanding scheduled update to complete.
sl@0: 	// If a redraw is currently active then we need to wait (at most) twice: once for
sl@0: 	// the current update to complete, and once for any outstanding scheduled update to complete.   
sl@0: 	if (!iScreenState[screenNumber]->IsActive())
sl@0: 		{
sl@0: 		// No animation in progress, so force a redraw of due updates.
sl@0: 		ScheduleUpdate(screenNumber, ETrue);
sl@0: 
sl@0: 		// If there is still nothing drawing, set redrawCount to zero to make sure we do not wait.
sl@0: 		if (!iScreenState[screenNumber]->IsActive())
sl@0: 			{
sl@0: 			redrawCount = 0;
sl@0: 			aObserver.ScreenUpdateComplete(KErrNone);
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			redrawCount = 1;
sl@0: 			iScreenState[screenNumber]->WaitForRedraws(aObserver, redrawCount);
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		redrawCount = 2;
sl@0: 		iScreenState[screenNumber]->WaitForRedraws(aObserver, redrawCount);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::ClearScreenUpdateObserver(const MWsAnimationScheduler::MScreenUpdateObserver& aObserver)
sl@0: 	{
sl@0: 	const TInt count = iScreenState.Count();
sl@0: 	for(TInt screenNumber=0; screenNumber<count; screenNumber++) 
sl@0: 		{
sl@0: 		iScreenState[screenNumber]->ClearScreenUpdateObserver(aObserver);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Switch to deactivate animation or drawing (based on setting of iInactivityBehaviour).
sl@0: See InvokeDueAnimation().
sl@0: */
sl@0: void CWindowServer::CDefaultAnimationScheduler::OnInactive()
sl@0: 	{
sl@0: 	iInactive = ETrue;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Switch to deactivate/activate animation or drawing (based on setting of iInactivityBehaviour).
sl@0: See InvokeDueAnimation().
sl@0: */	
sl@0: void CWindowServer::CDefaultAnimationScheduler::OnActive()
sl@0: 	{
sl@0: 	iInactive = EFalse;
sl@0: 	if(iInactiveDraws)
sl@0: 		{
sl@0: 		iInactiveDraws = EFalse;
sl@0: 		iIdleInitiator->CallBack();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::ScheduleRedraw(MWsScreen& aScreen,const TTime& aWhen)
sl@0: 	{
sl@0: 	iRedrawScheduled = ETrue;
sl@0: 	ScheduleAnimation(aScreen, aWhen);
sl@0: 	}
sl@0: 
sl@0: /** 
sl@0: Given a MWsScreen pointer, return an integer value representing the ordinal position
sl@0: of the screen in the Window Server.
sl@0: */
sl@0: TInt CWindowServer::CDefaultAnimationScheduler::ScreenNumber(MWsScreen& aScreen) const
sl@0: 	{
sl@0: 	TInt numberOfScreens = CWsTop::NumberOfScreens();
sl@0: 	TInt theScreen;
sl@0: 	
sl@0: 	for (theScreen = 0; theScreen < numberOfScreens; theScreen++)
sl@0: 		if (CWsTop::Screen(theScreen) == &aScreen) 
sl@0: 			break;
sl@0: 	
sl@0: 	WS_ASSERT_DEBUG(theScreen < numberOfScreens, EWsPanicWsGraphic);
sl@0: 	return theScreen;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Perform redraw and return only when completed.
sl@0: NOTE: This method uses CActiveSchedulerWait to run a "modal wait loop" while the
sl@0: 		redraw complete signal is pending. When the signal is received, AsyncStop() is
sl@0: 		invoked on all active wait loops for the signalling screen. 
sl@0: */
sl@0: void CWindowServer::CDefaultAnimationScheduler::DoRedrawNow(MWsScreen& aScreen)
sl@0: 	{	
sl@0: 	TInt screenNumber = ScreenNumber (aScreen);
sl@0: 	TInt redrawCount = 0;
sl@0: 	
sl@0: 	// redrawCount is the number of times we should wait for redraws to complete.
sl@0: 	// If a redraw is not currently active then we need to wait (at most) once: for
sl@0: 	// any outstanding scheduled update to complete.
sl@0: 	// If a redraw is currently active then we need to wait (at most) twice: once for
sl@0: 	// the current update to complete, and once for any outstanding scheduled update to complete.	
sl@0: 	if (!iScreenState[screenNumber]->IsActive())
sl@0: 		{		
sl@0: 		// No animation in progress, so force a redraw of due updates.
sl@0: 		ScheduleUpdate(screenNumber, ETrue);
sl@0: 		
sl@0: 		// If there is still nothing drawing, set redrawCount to zero to make sure we do not wait.
sl@0: 		if (!iScreenState[screenNumber]->IsActive())
sl@0: 			redrawCount = 0;
sl@0: 		else
sl@0: 			redrawCount = 1;
sl@0: 		}
sl@0: 	else
sl@0: 		redrawCount = 2;
sl@0: 	
sl@0: 	// Wait for the sepecified number of redraws.
sl@0: 	if (redrawCount)
sl@0: 		{
sl@0: 		// Allocate the wait loop on the stack so we are not subject to heap OOM.
sl@0: 		TBuf8<sizeof (CScreenUpdateWait)> buf;
sl@0: 		Mem::FillZ(&buf, sizeof (CScreenUpdateWait));
sl@0: 		CScreenUpdateWait* waitLoop = new (&buf) CScreenUpdateWait(screenNumber);
sl@0: 		if (iRedrawWaitLoop.Append(waitLoop) == KErrNone)
sl@0: 			{
sl@0: 			// Run the active scheduler while updates are active
sl@0: 			while (redrawCount-- && iScreenState[screenNumber]->IsActive())
sl@0: 				waitLoop->Start();
sl@0: 			
sl@0: 			iRedrawWaitLoop.Remove(iRedrawWaitLoop.Count() - 1);			
sl@0: 			}
sl@0: 		waitLoop->~CScreenUpdateWait();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Schedule an update for a specific screen at a given point in time.
sl@0: */ 
sl@0: void CWindowServer::CDefaultAnimationScheduler::ScheduleAnimation(MWsScreen& aScreen, const TTime& aWhen)
sl@0: 	{	
sl@0: 	TSchedule schedule;
sl@0: 	schedule.iScreen = &aScreen;
sl@0: 	schedule.iScheduled = ETrue;
sl@0: 	schedule.iWhen = aWhen;
sl@0: 	schedule.iScreenNumber = ScreenNumber (aScreen);
sl@0: 	schedule.iRedraw = iRedrawScheduled;
sl@0: 	iRedrawScheduled = EFalse;
sl@0: 	TBool ok = EFalse;
sl@0: 	const TInt idx = iSchedule.FindInUnsignedKeyOrder(schedule);
sl@0: 	if(0 <= idx)
sl@0: 		{
sl@0: 		TSchedule& currSchedule=iSchedule[idx];
sl@0: 		if(currSchedule.iScheduled)
sl@0: 			{
sl@0: 			if(currSchedule.iWhen > aWhen)
sl@0: 				{
sl@0: 				currSchedule.iWhen = aWhen;
sl@0: 				}
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			currSchedule = schedule;
sl@0: 			}
sl@0: 		ok = ETrue;
sl@0: 		}
sl@0: 	else
sl@0: 		ok = (KErrNone == iSchedule.InsertInUnsignedKeyOrder(schedule));
sl@0: 
sl@0: 	if(ok)
sl@0: 		iIdleInitiator->CallBack();
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::UnscheduleAnimation(MWsScreen& aScreen)
sl@0: 	{
sl@0: 	TSchedule schedule;
sl@0: 	schedule.iScreen = &aScreen;
sl@0: 	const TInt idx = iSchedule.FindInUnsignedKeyOrder(schedule);
sl@0: 	if(0 <= idx)
sl@0: 		iSchedule[idx].iScheduled = EFalse;
sl@0: 	}
sl@0: 
sl@0: TBool CWindowServer::CDefaultAnimationScheduler::OnIdleCallBack(TAny* aAny)
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(aAny, EWsPanicWsGraphic);
sl@0: 	
sl@0: 	if(aAny)
sl@0: 		static_cast<CDefaultAnimationScheduler*>(aAny)->OnIdleCallBack(EFalse);
sl@0: 
sl@0: 	return EFalse; //ignored by caller
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::OnIdleCallBack(TBool aForce)
sl@0: 	{
sl@0: 	const TInt screenCount = iEnv.ScreenCount();
sl@0: 	for(TInt ii = 0; ii < screenCount; ii++)
sl@0: 		ScheduleUpdate (ii, aForce);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: /** 
sl@0: @return The number of microseconds (from now) that the specified scheduled update should be run at. This
sl@0: takes into account any set grace period and protects the scheduler from entering an infinite loop servicing
sl@0: animations with back-to-back frame updates.
sl@0: */
sl@0: TTimeIntervalMicroSeconds CWindowServer::CDefaultAnimationScheduler::GetDueDelta (TBool aForceRedraw, TSchedule* aScheduledUpdate)
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(aScheduledUpdate, EWsPanicWsGraphic);
sl@0: 	WS_ASSERT_DEBUG(aScheduledUpdate->iScheduled, EWsPanicWsGraphic);
sl@0: 	
sl@0: 	TTime now;
sl@0: 	TInt64 grace = I64LIT(0); 
sl@0: 	TTimeIntervalMicroSeconds thisUpdateDueIn = I64LIT(0); //Microseconds from now
sl@0: 	
sl@0: 	// Only use grace periods if not forcing due updates.
sl@0: 	if (!aForceRedraw)
sl@0: 		{
sl@0: 		if (aScheduledUpdate->iRedraw)
sl@0: 			grace = iRedrawGracePeriod;
sl@0: 		else
sl@0: 			grace = iAnimationGracePeriod;
sl@0: 		}
sl@0: 	
sl@0: 	now.UniversalTime();
sl@0: 	thisUpdateDueIn = aScheduledUpdate->iWhen.MicroSecondsFrom(now);
sl@0: 	
sl@0: 	// Add the grace period if the update is due in less time than the grace period.
sl@0: 	if (thisUpdateDueIn < grace)
sl@0: 		thisUpdateDueIn = grace;
sl@0: 	else if (thisUpdateDueIn > KHalfHour)
sl@0: 		thisUpdateDueIn = KHalfHour;
sl@0: 	
sl@0: 	return thisUpdateDueIn;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Schedule an actual screen update at the point in time at which it is due. The due time may be modified by
sl@0: this method based on any "grace period" values.
sl@0:  
sl@0: @param aScreen		Screen number to update.
sl@0: @param aForceRedraw Force redraws that are due. This causes grace periods not to be used.
sl@0: */
sl@0: void CWindowServer::CDefaultAnimationScheduler::ScheduleUpdate (TInt aScreenNumber, TBool aForceRedraw)
sl@0: 	{	
sl@0: 	// Schedule updates for any invalidated regions.
sl@0: 	RedrawAllInvalidatedRegions (aScreenNumber);
sl@0: 	
sl@0: 	TSchedule* scheduledUpdate = GetScheduledScreenUpdate(aScreenNumber);
sl@0: 	if (scheduledUpdate)
sl@0: 		{
sl@0: 		WS_ASSERT_DEBUG(scheduledUpdate->iScheduled, EWsPanicWsGraphic);
sl@0: 		WS_ASSERT_DEBUG(aScreenNumber < iScreenState.Count(), EWsPanicWsGraphic);
sl@0: 		
sl@0: 		CScreenState& screenState = *iScreenState[aScreenNumber];
sl@0: 				
sl@0: 		// Initiate redraw if scheduled and not currently updating the display.
sl@0: 		if(!screenState.IsActive())
sl@0: 			{
sl@0: 			TTimeIntervalMicroSeconds thisUpdateDueIn =	
sl@0: 				GetDueDelta (aForceRedraw, scheduledUpdate);
sl@0: 			
sl@0: 			// Reschedule any preexisting update if this one is due earlier.
sl@0: 			// If this update is not due earlier than a preexisting update then 
sl@0: 			// there is nothing to do - just let the pending update occur.
sl@0: 			TTime now;
sl@0: 			now.UniversalTime();
sl@0: 			TBool performUpdate = ETrue;
sl@0: 			if(screenState.iUpdateOn->IsActive())
sl@0: 				{
sl@0: 				if (thisUpdateDueIn < screenState.iExpectedTickTime.MicroSecondsFrom(now))
sl@0: 					screenState.iUpdateOn->Cancel();
sl@0: 				else
sl@0: 					performUpdate = EFalse;
sl@0: 				}
sl@0: 			
sl@0: 			if (performUpdate)
sl@0: 				{
sl@0: 				if (thisUpdateDueIn.Int64() == 0) // Perform an immediate update if we are due.
sl@0: 					{
sl@0: 					screenState.iExpectedTickTime = now;
sl@0: 					InvokeDueAnimation(aScreenNumber);
sl@0: 					}
sl@0: 				else // Schedule the tick at the appropriate time.
sl@0: 					{
sl@0: 					WS_ASSERT_DEBUG(thisUpdateDueIn.Int64() > 0, EWsPanicWsGraphic);
sl@0: 					screenState.iExpectedTickTime = now + thisUpdateDueIn;
sl@0: 					screenState.iUpdateOn->Start(thisUpdateDueIn.Int64(),0,TCallBack(InvokeDueAnimation, &screenState.iScreenUpdateDetails));
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @return 	A pointer to the scheduled update details currently associated with the specified screen.
sl@0: 			If there is no scheduled update then NULL is returned.
sl@0: @note 		There is only ever one scheduled update per screen.
sl@0: */
sl@0: CWindowServer::CDefaultAnimationScheduler::TSchedule* CWindowServer::CDefaultAnimationScheduler::GetScheduledScreenUpdate(TInt aScreenNumber)
sl@0: 	{
sl@0: 	TSchedule* result = NULL;
sl@0: 	const TInt count = iSchedule.Count();
sl@0: 	for(TInt ii = 0; ii < count; ii++)
sl@0: 		{
sl@0: 		if (iSchedule[ii].iScreenNumber == aScreenNumber)
sl@0: 			{
sl@0: 			if (iSchedule[ii].iScheduled)
sl@0: 				result = &iSchedule[ii];
sl@0: 			break;
sl@0: 			}
sl@0: 		}
sl@0: 	
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Redraw invalidated graphic IDs. If invalid regions exist, this will cause ScheduleRedraw() to be invoked.
sl@0: */ 
sl@0: void CWindowServer::CDefaultAnimationScheduler::RedrawAllInvalidatedRegions (TInt aScreen)
sl@0: 	{	
sl@0: 	WS_ASSERT_DEBUG(iScreenState.Count() > aScreen, EWsPanicWsGraphic);
sl@0: 	
sl@0: 	CScreenState& screenState = *iScreenState[aScreen];
sl@0: 	if(screenState.iInvalidateAll || screenState.iInvalidated.Count())
sl@0: 		{		
sl@0: 		const TArray<TGraphicDrawerId> invalidArray = screenState.iInvalidated.Array();
sl@0: 		MWsScreen* screen = iEnv.Screen(aScreen);
sl@0: 		WS_ASSERT_DEBUG(screen, EWsPanicWsGraphic);
sl@0: 		if(screen)
sl@0: 			{
sl@0: 			if(screenState.iInvalidateAll)
sl@0: 				Redraw(*screen);
sl@0: 			else
sl@0: 				RedrawInvalid(*screen, screenState.iInvalidated.Array());
sl@0: 			}
sl@0: 		screenState.iInvalidateAll = EFalse;
sl@0: 		}
sl@0: 	screenState.iInvalidated.Reset();
sl@0: 	}
sl@0: 	
sl@0: TBool CWindowServer::CDefaultAnimationScheduler::InvokeDueAnimation(TAny* aAny)
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(aAny, EWsPanicWsGraphic);
sl@0: 	TScreenUpdateDetails* args = reinterpret_cast<TScreenUpdateDetails*>(aAny);
sl@0: 	if(args)
sl@0: 		args->iScheduler->InvokeDueAnimation (args->iScreenNumber);
sl@0: 
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::InvokeDueAnimation(TInt aScreen)
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(aScreen < iScreenState.Count(), EWsPanicWsGraphic);
sl@0: 	CScreenState& screenState = *iScreenState[aScreen];
sl@0: 	WS_ASSERT_DEBUG(!screenState.IsActive(), EWsPanicWsGraphic);
sl@0: 
sl@0: 	// All updates are driven through ScheduleRedraw() and ScheduleAnimation().
sl@0: 	screenState.iUpdateOn->Cancel();
sl@0: 	
sl@0: 	TSchedule* scheduledUpdate = GetScheduledScreenUpdate(aScreen);	
sl@0: 	if (scheduledUpdate)
sl@0: 		{
sl@0: 		WS_ASSERT_DEBUG(scheduledUpdate->iScheduled, EWsPanicWsGraphic);
sl@0: 		
sl@0: 		// Honour any flags that indicate we should not redraw. 
sl@0: 		switch(iInactivityBehaviour)
sl@0: 			{
sl@0: 			case EStopAnimation :
sl@0: 				// Stop server side drawing. Only the client may redraw if iInactive is set. 
sl@0: 				if(iInactive && !scheduledUpdate->iRedraw)
sl@0: 					{
sl@0: 					iInactiveDraws = ETrue;
sl@0: 					return;
sl@0: 					}
sl@0: 				break;
sl@0: 			case EStopAllDrawing :
sl@0: 				// Stop both client and server side drawing.
sl@0: 				if(iInactive) 
sl@0: 					{
sl@0: 					iInactiveDraws = ETrue;
sl@0: 					return;
sl@0: 					}
sl@0: 				break;
sl@0: 			case EIgnore :
sl@0: 				break;
sl@0: 			default :
sl@0: 				WS_ASSERT_DEBUG(EFalse, EWsPanicWsGraphic);
sl@0: 				break;
sl@0: 			}
sl@0: 	
sl@0: 		scheduledUpdate->iScheduled = EFalse;
sl@0: 		screenState.SetActive();
sl@0: 		Animate(*scheduledUpdate->iScreen, &(screenState.iStatus));
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // CWindowServer::CServer \\\\\\\\\\\\\\\\\\\\\\
sl@0: 
sl@0: class CWindowServer::CServer : public CPolicyServer
sl@0: 	{
sl@0: public:
sl@0: 	static CServer* NewL()
sl@0: 		{
sl@0: 		return new(ELeave) CServer;
sl@0: 		}
sl@0: 	void StartL()
sl@0: 		{
sl@0: 		CPolicyServer::StartL(KWSERVServerName);
sl@0: 		}
sl@0: 	TInt SessionCount()
sl@0: 		{
sl@0: 		iSessionIter.SetToFirst();
sl@0: 		TInt count=0;
sl@0: 		while(iSessionIter++)
sl@0: 			++count;
sl@0: 		return(count);
sl@0: 		}
sl@0: 
sl@0: public: //from CPolicyServer
sl@0: 	/** Creates a new client for this server. */
sl@0: 	CSession2* NewSessionL(const TVersion& aVersion, const RMessage2& aMessage) const
sl@0: 		{
sl@0: 		TVersion v(KWservMajorVersionNumber, KWservMinorVersionNumber, KWservBuildVersionNumber);
sl@0: 		if (User::QueryVersionSupported(v, aVersion)==EFalse)
sl@0: 			User::Leave(KErrNotSupported);
sl@0: 		RThread thread;
sl@0: 		User::LeaveIfError(aMessage.Client(thread));
sl@0: 		return(new(ELeave) CWsClient(thread));
sl@0: 		}
sl@0: private:
sl@0: 	CServer() : CPolicyServer(EMainServerPriority, KWsServPolicy)
sl@0: 	{}
sl@0: 	};
sl@0: 
sl@0: 
sl@0: // CWindowServer \\\\\\\\\\\\\\\\\\\\\\\\\\\
sl@0: 
sl@0: CWindowServer *CWindowServer::NewL()
sl@0: //
sl@0: // Create a new CWindowServer.
sl@0: //
sl@0: 	{
sl@0: 	CWindowServer* self = new(ELeave) CWindowServer();
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL();
sl@0: 	CleanupStack::Pop(self);
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: CWindowServer::CWindowServer()
sl@0: //
sl@0: // Constructor.
sl@0: //
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: CWindowServer::~CWindowServer()
sl@0: 	{
sl@0: 	delete iServer;
sl@0: 
sl@0: 	iMemoryReleases.Reset();
sl@0: 	WS_ASSERT_DEBUG(iDrawerMasterIndex.IsEmpty(), EWsPanicWsGraphic);
sl@0: 	iDrawerMasterIndex.Close();
sl@0: 	
sl@0: 	delete iDefaultAnimationScheduler;
sl@0: 	iDefaultAnimationScheduler = NULL; //might be called from clients during server destruction	
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::ConstructL()
sl@0: 	{
sl@0: 	iServer = CServer::NewL();
sl@0: 	CWsTop::PluginManager()->InitializePluginsL(*this); // plugins are loaded and own by CWsTop
sl@0: 	iDefaultAnimationScheduler = new(ELeave) CDefaultAnimationScheduler(*this);
sl@0: 	iDefaultAnimationScheduler->ConstructL();
sl@0: 	RegisterMemoryRelease(this);
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::StartL()
sl@0: 	{
sl@0: 	iServer->StartL();
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::SetPinClientDescriptors(TBool aPin)
sl@0: 	{
sl@0: 	iServer->SetPinClientDescriptors(aPin);
sl@0: 	}
sl@0: 
sl@0: TInt CWindowServer::SessionCount()
sl@0: 	{
sl@0: 	return iServer->SessionCount();
sl@0: 	}
sl@0: 
sl@0: const CWsGraphicDrawer* CWindowServer::ResolveGraphic(const TGraphicDrawerId& aId) const
sl@0: 	{
sl@0: 	return iDrawerMasterIndex.ResolveGraphic(aId);
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::Invalidate(const TGraphicDrawerId& aId)
sl@0: 	{
sl@0: 	AnimationScheduler()->Invalidate(aId);
sl@0: 	}
sl@0: 	
sl@0: TInt CWindowServer::ScreenCount() const
sl@0: 	{
sl@0: 	return CWsTop::NumberOfScreens();
sl@0: 	}
sl@0: 
sl@0: MWsScreen* CWindowServer::Screen(TInt aIndex)
sl@0: 	{
sl@0: 	if((aIndex >= 0) && (aIndex < ScreenCount()))
sl@0: 		{
sl@0: 		return CWsTop::Screen(aIndex);
sl@0: 		}
sl@0: 	return NULL;
sl@0: 	}
sl@0: 	
sl@0: const MWsScreen* CWindowServer::Screen(TInt aIndex) const
sl@0: 	{
sl@0: 	if((aIndex >= 0) && (aIndex < ScreenCount()))
sl@0: 		{
sl@0: 		return CWsTop::Screen(aIndex);
sl@0: 		}
sl@0: 	return NULL;
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: Custom Animation Scheduler
sl@0: */
sl@0: TBool CWindowServer::SetCustomAnimationScheduler(MWsAnimationScheduler* /*aScheduler*/)
sl@0: 	{
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 
sl@0: TBool CWindowServer::HasCustomAnimationScheduler() const
sl@0: 	{
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 
sl@0: TBool CWindowServer::ClearCustomAnimationScheduler(MWsAnimationScheduler* /*aCurrentScheduler*/)
sl@0: 	{
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 	
sl@0: MWsAnimationScheduler* CWindowServer::AnimationScheduler()
sl@0: 	{
sl@0: 	return iDefaultAnimationScheduler;
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::PrepareShutdown()
sl@0: 	{
sl@0: 	//Stop the renderloop, i.e. prevent any further calls to MWsAnimationScheduler::Animate() 
sl@0: 	delete iDefaultAnimationScheduler;
sl@0: 	iDefaultAnimationScheduler = NULL;
sl@0: 	}
sl@0: 
sl@0: TInt CWindowServer::RegisterEventHandler(CWsGraphicDrawer* aDrawer, MWsEventHandler* aHandler, TUint32 aEventMask)
sl@0: 	{
sl@0: 	if (!aDrawer || !aHandler || aEventMask==0)
sl@0: 		return KErrArgument;
sl@0: 	TInt err = TWindowServerEvent::RegisterDrawerHandler(aDrawer, aEventMask);
sl@0: 	if (err != KErrNone)
sl@0: 		return err;
sl@0: 	aDrawer->SetEventHandler(aHandler);
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 	
sl@0: TInt CWindowServer::UnregisterEventHandler(CWsGraphicDrawer* aDrawer)
sl@0: 	{
sl@0: 	if (!aDrawer || (aDrawer && !aDrawer->HasEventHandler()))
sl@0: 		return KErrArgument;
sl@0: 	TInt err = TWindowServerEvent::UnregisterDrawerHandler(aDrawer);
sl@0: 	if (err != KErrNone)
sl@0: 		return err;
sl@0: 	aDrawer->SetEventHandler(NULL);
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 	
sl@0: TInt CWindowServer::RegisterWsEventHandler(MWsEventHandler* aHandler, TUint32 aEventMask)
sl@0: 	{
sl@0: 	if (!aHandler || aEventMask==0)
sl@0: 		return KErrArgument;
sl@0: 	return TWindowServerEvent::RegisterWsEventHandler(aHandler, aEventMask);
sl@0: 	}
sl@0: 	
sl@0: TInt CWindowServer::UnregisterWsEventHandler(MWsEventHandler* aHandler)
sl@0: 	{
sl@0: 	return TWindowServerEvent::UnregisterWsEventHandler(aHandler);
sl@0: 	}
sl@0: 	
sl@0: TAny* CWindowServer::ResolveObjectInterface(TUint aTypeId)
sl@0: 	{
sl@0: 	switch(aTypeId)
sl@0: 		{
sl@0: 		case MWsActiveSchedulerDebug::EWsObjectInterfaceId:
sl@0: 			return static_cast<MWsActiveSchedulerDebug*>(CWsActiveScheduler::Static());
sl@0: 		case MWsIniFile::EWsObjectInterfaceId:
sl@0: 			return static_cast<MWsIniFile*>(WsIniFile);
sl@0: 		}
sl@0: 	
sl@0: 	if (CWsPluginManager *plugMgr=CWsTop::PluginManager())
sl@0: 		return plugMgr->ResolveObjectInterface(aTypeId);
sl@0: 	
sl@0: 	return NULL;
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::Log(TInt aPriority,const TDesC &aFmt,TInt aParam)
sl@0: 	{
sl@0: 	if (wsDebugLog)
sl@0: 		{
sl@0: 		wsDebugLog->MiscMessage(aPriority, aFmt, aParam);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // CWsGraphicDrawer master index
sl@0: 
sl@0: TInt CWindowServer::AddGraphicDrawer(CWsGraphicDrawer* aDrawer)
sl@0: 	{
sl@0: 	return iDrawerMasterIndex.Add(aDrawer);
sl@0: 	}
sl@0: 
sl@0: TInt CWindowServer::SwapGraphicDrawer(CWsGraphicDrawer* aDrawer)
sl@0: 	{
sl@0: 	return iDrawerMasterIndex.Swap(aDrawer);
sl@0: 	}
sl@0: 	
sl@0: TInt CWindowServer::RemoveGraphicDrawer(const TGraphicDrawerId& aId)
sl@0: 	{
sl@0: 	return iDrawerMasterIndex.Remove(aId);
sl@0: 	}
sl@0: 
sl@0: TInt CWindowServer::RemoveAllGraphicDrawers(const MWsClient& aOwner)
sl@0: 	{
sl@0: 	return iDrawerMasterIndex.RemoveAll(aOwner);
sl@0: 	}
sl@0: 
sl@0: TInt CWindowServer::RegisterMemoryRelease(MWsMemoryRelease * aMemoryRelease)
sl@0: 	{
sl@0: 	return iMemoryReleases.Append(aMemoryRelease);
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::UnregisterMemoryRelease(MWsMemoryRelease * aMemoryRelease)
sl@0: 	{
sl@0: 	for (TInt ii = iMemoryReleases.Count() - 1; ii >= 0; --ii)
sl@0: 		{
sl@0: 		if (iMemoryReleases[ii] == aMemoryRelease)
sl@0: 			{
sl@0: 			iMemoryReleases.Remove(ii);
sl@0: 			break;
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TBool CWindowServer::ReleaseMemory(TMemoryReleaseLevel aLevel)
sl@0: 	{
sl@0: 	return CWsWindow::ReleaseMemory(aLevel);
sl@0: 	}
sl@0: 
sl@0: TBool CWindowServer::ReleaseMemory()
sl@0: 	{
sl@0: 	TBool released = EFalse;
sl@0: 	for (TInt level = MWsMemoryRelease::ELow; !released && level <= MWsMemoryRelease::EHigh; ++level)
sl@0: 		{
sl@0: 		for (TInt ii = iMemoryReleases.Count() - 1; !released && ii >= 0; --ii)
sl@0: 			{
sl@0: 			released = iMemoryReleases[ii]->ReleaseMemory(static_cast<TMemoryReleaseLevel>(level));
sl@0: 			}
sl@0: 		}
sl@0: 	return released;
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::DestroySessionsForShutdown()
sl@0: 	{
sl@0: 	delete iServer;
sl@0: 	iServer = NULL;
sl@0: 	}
sl@0: