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: 
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: public:
sl@0: 	enum TInactivityBehaviour
sl@0: 		{
sl@0: 		EStopAnimation,
sl@0: 		EStopAllDrawing,
sl@0: 		EIgnore,
sl@0: 		};
sl@0: 	class CKickBack;
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: 	TInt RemoveGraphicDrawer(const TGraphicDrawerId &aId);
sl@0: 	
sl@0: private:
sl@0: 	static TBool OnIdleCallBack(TAny* aAny);
sl@0: 	void OnIdleCallBack(TBool aForceRedraw);
sl@0: 	static TBool OnTickCallBack(TAny* aAny);
sl@0: 	void OnTickCallBack();
sl@0: 	static TBool OnKickBack(TAny* aAny);
sl@0: 	void OnKickBack();
sl@0: private:
sl@0: 	MWsGraphicDrawerEnvironment& iEnv;
sl@0: 	static const TInt64 KRedrawGrace;
sl@0: 	static const TInt64 KAnimationGrace;
sl@0: 	static const TInt64 KDsaAnimationGrace;
sl@0: 	CAsyncCallBack* iIdleInitiator;
sl@0: 	CPeriodic* iTick;
sl@0: 	CKickBack* iKickBack;
sl@0: 	struct TSchedule
sl@0: 		{
sl@0: 		MWsScreen* iScreen; // used as a unique index, searching with FindInUnsignedKeyOrder
sl@0: 		TBool iSchedule;
sl@0: 		TTime iWhen;
sl@0: 		TInt iGeneration;
sl@0: 		};
sl@0: 	RArray<TSchedule> iSchedule;
sl@0: 	TInt iGeneration;
sl@0: 	RArray<TGraphicDrawerId> iInvalidated;
sl@0: 	TBool iInvalidateAll; // if we could not add to iInvalidated, we have to instead redraw everything
sl@0: 	TTime iWhenDesired;
sl@0: 	TBool iInactive;
sl@0: 	TBool iInactiveDraws;
sl@0: 	TTime iExpectedTime;
sl@0: 	TBool iRedrawScheduled;
sl@0: 	TInt64 iRedrawGracePeriod;
sl@0: 	TInt64 iAnimationGracePeriod;
sl@0: 	TInt64 iDsaAnimationGracePeriod;
sl@0: 	TInactivityBehaviour iInactivityBehaviour;
sl@0: 	};
sl@0: 	
sl@0: TInt CWindowServer::CDefaultAnimationScheduler::RemoveGraphicDrawer(const TGraphicDrawerId &aId)
sl@0: 	{
sl@0: 	TInt index=iInvalidated.Find(aId);
sl@0: 	if (index!=KErrNotFound)
sl@0: 		iInvalidated.Remove(index);
sl@0: 	return index;
sl@0: 	}	
sl@0: 	
sl@0: class CWindowServer::CDefaultAnimationScheduler::CKickBack: public CActive
sl@0: 	{
sl@0: public:
sl@0: 	CKickBack(const TCallBack& aCallBack);
sl@0: 	void ConstructL();
sl@0: 	void RequestKickBack();
sl@0: 	~CKickBack();
sl@0: private:
sl@0: 	static TInt IdleThreadFunc(TAny* aAny);
sl@0: 	void Loop();
sl@0: 	// from CActive
sl@0: 	void RunL(); // fires when kicked back by the idle thread
sl@0: 	void DoCancel();
sl@0: private:
sl@0: 	RThread iWservThread;
sl@0: 	RThread iIdleThread;
sl@0: 	TRequestStatus iIdleStatus;
sl@0: 	TCallBack iCallBack;
sl@0: 	};
sl@0: 	
sl@0: CWindowServer::CDefaultAnimationScheduler::CKickBack::CKickBack(const TCallBack& aCallBack) :
sl@0: CActive(EPriorityNormal),
sl@0: iCallBack(aCallBack)
sl@0: 	{
sl@0: 	CActiveScheduler::Add(this);
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::CDefaultAnimationScheduler::CKickBack::ConstructL()
sl@0: 	{
sl@0: 	_LIT(KIdleThreadName,"NearlyIdleKickBack");
sl@0: 	const TInt KStackSize = 1024;
sl@0: 	User::LeaveIfError(iWservThread.Open(iWservThread.Id()));
sl@0: 	User::LeaveIfError(iIdleThread.Create(KIdleThreadName(),IdleThreadFunc,KStackSize,NULL,this));
sl@0: 	iIdleThread.SetPriority(EPriorityAbsoluteVeryLow);
sl@0: 	iIdleThread.Resume();
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::CDefaultAnimationScheduler::CKickBack::RequestKickBack()
sl@0: 	{
sl@0: 	if (!IsActive())
sl@0: 		{
sl@0: 		iStatus = KRequestPending;
sl@0: 		SetActive();
sl@0: 		TRequestStatus * status = &iIdleStatus;
sl@0: 		iIdleThread.RequestComplete(status, KErrNone);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::CKickBack::Loop()
sl@0: 	{
sl@0: 	FOREVER
sl@0: 		{
sl@0: 		// This is used here for performance reasons. 
sl@0: 		User::WaitForRequest(iIdleStatus); 
sl@0: 		iIdleStatus = KRequestPending;
sl@0: 		if (IsActive()&& (iStatus == KRequestPending))
sl@0: 			{
sl@0: 			TRequestStatus * status = &iStatus;
sl@0: 			iWservThread.RequestComplete(status,KErrNone);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::CKickBack::RunL()
sl@0: 	{
sl@0: 	iCallBack.CallBack();
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::CKickBack::DoCancel()
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: CWindowServer::CDefaultAnimationScheduler::CKickBack::~CKickBack()
sl@0: 	{
sl@0: 	Cancel();
sl@0: 	iWservThread.Close();
sl@0: 	iIdleThread.Kill(0);
sl@0: 	iIdleThread.Close();
sl@0: 	}
sl@0: 	
sl@0: TInt CWindowServer::CDefaultAnimationScheduler::CKickBack::IdleThreadFunc(TAny* aAny)
sl@0: 	{
sl@0: 	CKickBack* owner = reinterpret_cast<CKickBack*>(aAny);
sl@0: 	ASSERT(owner);
sl@0: 	if(owner)
sl@0: 		{
sl@0: 		owner->Loop();
sl@0: 		}
sl@0: 	return KErrNone;
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 = 35000; // insist upon 35ms grace for other threads to run when animating
sl@0: const TInt64 CWindowServer::CDefaultAnimationScheduler::KDsaAnimationGrace = 35000; // insist upon 35ms grace for other threads to run when animating during DSA
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: 	iInvalidated.Close();
sl@0: 	delete iKickBack;
sl@0: 	delete iIdleInitiator;
sl@0: 	delete iTick;
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: 	_LIT(KDsaAnimationGracePeriod, "DSAANIMATIONGRACEPERIOD");
sl@0: 	tmp = KDsaAnimationGrace;
sl@0: 	WsIniFile->FindVar(KDsaAnimationGracePeriod, tmp);
sl@0: 	iDsaAnimationGracePeriod = tmp;
sl@0: 	
sl@0: 	iIdleInitiator = new(ELeave) CAsyncCallBack(TCallBack(OnIdleCallBack,this),EWsGraphicAnimateAwaitIdlePriority);
sl@0: 	iTick = CPeriodic::NewL(EWsGraphicAnimatePriority);
sl@0: 	
sl@0: 	_LIT(KDisableIdleAnimation, "DISABLEIDLEANIMATION");
sl@0: 	if (!WsIniFile->FindVar(KDisableIdleAnimation))
sl@0: 		{
sl@0: 		iKickBack = new CKickBack(TCallBack(OnKickBack,this));
sl@0: 		iKickBack->ConstructL();
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::CDefaultAnimationScheduler::Invalidate(const TGraphicDrawerId& aId)
sl@0: 	{
sl@0: 	if(!iInvalidateAll)
sl@0: 		{
sl@0: 		switch(iInvalidated.InsertInOrder(aId,TLinearOrder<TGraphicDrawerId>(TGraphicDrawerId::Compare)))
sl@0: 			{
sl@0: 			case KErrNone:
sl@0: 				break;
sl@0: 			case KErrAlreadyExists:
sl@0: 				break;
sl@0: 			default:
sl@0: 				iInvalidateAll = ETrue;
sl@0: 				iInvalidated.Reset();
sl@0: 			}
sl@0: 		}
sl@0: 	iIdleInitiator->CallBack();
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::CDefaultAnimationScheduler::OnInactive()
sl@0: 	{
sl@0: 	iInactive = ETrue;
sl@0: 	}
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: void CWindowServer::CDefaultAnimationScheduler::DoRedrawNow(MWsScreen& /*aScreen*/)
sl@0: 	{
sl@0: 	OnIdleCallBack(ETrue);
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::CDefaultAnimationScheduler::DoRedrawNow(MWsScreen& /*aScreen*/, MWsAnimationScheduler::MScreenUpdateObserver& aObserver)
sl@0: 	{
sl@0: 	OnIdleCallBack(ETrue);
sl@0: 	aObserver.ScreenUpdateComplete(KErrNone);
sl@0: 	}	
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.iSchedule = ETrue;
sl@0: 	schedule.iWhen = aWhen;
sl@0: 	schedule.iGeneration = iGeneration;
sl@0: 	TBool ok = EFalse;
sl@0: 	const TInt idx = iSchedule.FindInUnsignedKeyOrder(schedule);
sl@0: 	if(0 <= idx)
sl@0: 		{
sl@0: 		if(iSchedule[idx].iSchedule)
sl@0: 			{
sl@0: 			if(iSchedule[idx].iWhen > aWhen)
sl@0: 				{
sl@0: 				iSchedule[idx].iWhen = aWhen;
sl@0: 				}
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			iSchedule[idx] = schedule;
sl@0: 			}
sl@0: 		iSchedule[idx].iGeneration = iGeneration;
sl@0: 		ok = ETrue;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		ok = (KErrNone == iSchedule.InsertInUnsignedKeyOrder(schedule));
sl@0: 		}
sl@0: 	if(ok)
sl@0: 		{
sl@0: 		//If the animation runs at very high rate which exceeds the rate WSERV can 
sl@0: 		//perform the rendering, it is possible that WSERV animation loop will monopolize  
sl@0: 		//processor time. 
sl@0:   		User::After(0);	// to yeild from the animation loop 
sl@0: 
sl@0: 		iIdleInitiator->CallBack();
sl@0: 		}
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: 		{
sl@0: 		iSchedule[idx].iSchedule = EFalse;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TBool CWindowServer::CDefaultAnimationScheduler::OnIdleCallBack(TAny* aAny)
sl@0: 	{
sl@0: 	CDefaultAnimationScheduler* self = reinterpret_cast<CDefaultAnimationScheduler*>(aAny);
sl@0: 	ASSERT(self);
sl@0: 	if(self)
sl@0: 		{
sl@0: 		self->OnIdleCallBack(EFalse);
sl@0: 		}
sl@0: 	return EFalse; //ignored by caller
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::CDefaultAnimationScheduler::OnIdleCallBack(TBool aForceRedraw)
sl@0: 	{
sl@0: 	TBool wasActive = EFalse;
sl@0: 	if (iTick->IsActive())
sl@0: 		{
sl@0: 		wasActive = ETrue;
sl@0: 		iTick->Cancel(); // stop ticker, as we'll reschedule if necessary
sl@0: 		}
sl@0: 	if (aForceRedraw)
sl@0: 		{
sl@0: 		// Don't need to update iExpectedTime as we will not schedule a tick.
sl@0: 		// Don't need to update iWhenDesired as we will not schedule a kick-back.
sl@0: 		OnTickCallBack();
sl@0: 		return;
sl@0: 		}
sl@0: 	TBool tick = (iInvalidateAll || iInvalidated.Count());
sl@0: 	TTimeIntervalMicroSeconds next = 0LL;
sl@0: 	const TInt count = iSchedule.Count();
sl@0: 	TTime now;
sl@0: 	now.UniversalTime();
sl@0: 	if(count)
sl@0: 		{
sl@0: 		// work out the next wanted tick
sl@0: 		TBool animTick = EFalse;
sl@0: 		for(TInt i=0; i<count; i++)
sl@0: 			{
sl@0: 			if(iSchedule[i].iSchedule)
sl@0: 				{
sl@0: 				const TTime when = iSchedule[i].iWhen;
sl@0: 				const TTimeIntervalMicroSeconds fromNow = when.MicroSecondsFrom(now);
sl@0: 				if(!animTick || (fromNow < next))
sl@0: 					{
sl@0: 					animTick = ETrue;
sl@0: 					tick = ETrue;
sl@0: 					next = fromNow;
sl@0: 					iWhenDesired = when;
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	if(tick)
sl@0: 		{
sl@0: 		TInt64 grace;
sl@0: 		if (iRedrawScheduled)
sl@0: 			grace = iRedrawGracePeriod;
sl@0: 		else if (EFalse) // DSA active
sl@0: 			grace = iDsaAnimationGracePeriod;
sl@0: 		else
sl@0: 			grace = iAnimationGracePeriod;
sl@0: 		if (wasActive)
sl@0: 			{
sl@0: 			TInt64 minimum = iExpectedTime.MicroSecondsFrom(now).Int64();
sl@0: 			if (minimum >= 0 && grace > minimum)
sl@0: 				grace = minimum;
sl@0: 			}
sl@0: 
sl@0: 		if (next.Int64() <= 0)
sl@0: 			next = 0LL ;  // No kickback/tick is needed. Make sure next == default grace period.
sl@0: 
sl@0: 		if(next < grace)
sl@0: 			{
sl@0: 			next = grace;
sl@0: 			if (iKickBack)
sl@0: 				iKickBack->RequestKickBack();
sl@0: 			}
sl@0: 		else if (next > KHalfHour)
sl@0: 			next = KHalfHour;
sl@0: 		
sl@0: 		iExpectedTime=now + next;
sl@0: 		if (next.Int64() > 0)
sl@0: 			{
sl@0: 			iTick->Start(next.Int64(),0,TCallBack(OnTickCallBack,this));
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			OnTickCallBack(); // scheduling for 0 doesn't actually execute immediately
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: TBool CWindowServer::CDefaultAnimationScheduler::OnKickBack(TAny* aAny)
sl@0: 	{
sl@0: 	CDefaultAnimationScheduler* self = reinterpret_cast<CDefaultAnimationScheduler*>(aAny);
sl@0: 	ASSERT(self);
sl@0: 	if(self)
sl@0: 		{
sl@0: 		self->OnKickBack();
sl@0: 		}
sl@0: 	return EFalse; //ignored by caller
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::CDefaultAnimationScheduler::OnKickBack()
sl@0: 	{
sl@0: 	if (iTick->IsActive())
sl@0: 		{
sl@0: 		iTick->Cancel();
sl@0: 		TTime now;
sl@0: 		now.UniversalTime();
sl@0: 				
sl@0: 		TTimeIntervalMicroSeconds fromNow = iWhenDesired.MicroSecondsFrom(now);
sl@0: 
sl@0: 		if (fromNow < 0)
sl@0: 			{
sl@0: 			OnTickCallBack();
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			if (fromNow > KHalfHour)
sl@0: 				fromNow = KHalfHour;
sl@0: 			iTick->Start(fromNow.Int64(),0,TCallBack(OnTickCallBack, this));
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: TBool CWindowServer::CDefaultAnimationScheduler::OnTickCallBack(TAny* aAny)
sl@0: 	{
sl@0: 	CDefaultAnimationScheduler* self = reinterpret_cast<CDefaultAnimationScheduler*>(aAny);
sl@0: 	ASSERT(self);
sl@0: 	if(self)
sl@0: 		{
sl@0: 		self->OnTickCallBack();
sl@0: 		}
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::CDefaultAnimationScheduler::OnTickCallBack()
sl@0: 	{
sl@0: 	iTick->Cancel();
sl@0: 
sl@0: 	switch(iInactivityBehaviour)
sl@0: 		{
sl@0: 		case EStopAnimation :
sl@0: 			// only client redraws if inactive. server side drawing stopped.
sl@0: 			if(iInactive && !iRedrawScheduled) 
sl@0: 				{
sl@0: 				iInactiveDraws = ETrue;
sl@0: 				return;
sl@0: 				}
sl@0: 			break;
sl@0: 		case EStopAllDrawing :
sl@0: 			// if screen off, 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: 		default :
sl@0: 			// ignore inactivity and draw as normal
sl@0: 			break;
sl@0: 		}
sl@0: 		
sl@0: 	iRedrawScheduled = EFalse;
sl@0: 
sl@0: 	TTime now;
sl@0: 	now.UniversalTime();
sl@0: 	CWsActiveScheduler::Static()->AccumReclaimedIdleTime(Max(0LL,now.MicroSecondsFrom(iExpectedTime).Int64()));
sl@0: 		
sl@0: 	TInt drewCount = 0;
sl@0: 	TInt scheduledCount = 0;
sl@0: 	/* first redraw any screens that are affected by invalidated graphic IDs */
sl@0: 	if(iInvalidateAll || iInvalidated.Count())
sl@0: 		{
sl@0: 		// cancel idle callback if it's already scheduled as we're going to redraw all invalidated 
sl@0: 		// request at this point and clear invalidated array
sl@0: 		if (iIdleInitiator->IsActive())
sl@0: 			iIdleInitiator->Cancel();
sl@0: 		const TArray<TGraphicDrawerId> invalidArray = iInvalidated.Array();
sl@0: 		const TInt screenCount = iEnv.ScreenCount();
sl@0: 		for(TInt i=0; i<screenCount; i++)
sl@0: 			{
sl@0: 			MWsScreen* screen = iEnv.Screen(i);
sl@0: 			if(screen)
sl@0: 				{
sl@0: 				drewCount++;
sl@0: 				if(iInvalidateAll)
sl@0: 					{
sl@0: 					Redraw(*screen);
sl@0: 					}
sl@0: 				else
sl@0: 					{
sl@0: 					RedrawInvalid(*screen,invalidArray);
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		iInvalidateAll = EFalse;
sl@0: 		iInvalidated.Reset();
sl@0: 		}
sl@0: 	/* iSchedule might resize during this call because an Animate() on a screen might reschedule another animation etc */
sl@0: 	TInt generation = iGeneration++;
sl@0: 	TBool drew;
sl@0: 	do
sl@0: 		{
sl@0: 		drew = EFalse;
sl@0: 		const TInt count = iSchedule.Count();
sl@0: 		for(TInt i=0; i<count; i++)
sl@0: 			{
sl@0: 			if(iSchedule[i].iSchedule)
sl@0: 				{
sl@0: 				scheduledCount++;
sl@0: 				if(iSchedule[i].iGeneration == generation)
sl@0: 					{
sl@0: 					iSchedule[i].iSchedule = EFalse; // denote not to tick; it can be rescheduled in the subsequent call to Animate()
sl@0: 					Animate(*(iSchedule[i].iScreen));
sl@0: 					drew = ETrue;
sl@0: 					drewCount++;
sl@0: 					break; // go back to outer do while(drew)
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		} while(drew);
sl@0: 	__DEBUG_ONLY(
sl@0: 		TBool idleIsActive = iIdleInitiator->IsActive();
sl@0: 		if(scheduledCount || !drewCount)
sl@0: 			{
sl@0: 			TBool rescheduled = EFalse;
sl@0: 			for(TInt i=0; i<iSchedule.Count(); i++)
sl@0: 				{
sl@0: 				rescheduled |= iSchedule[i].iSchedule;
sl@0: 				}
sl@0: 			if(!rescheduled)
sl@0: 				{
sl@0: 				//__DEBUGGER();
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: 	: CPolicyServer(EMainServerPriority,KWsServPolicy)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: CWindowServer::~CWindowServer()
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: 	delete iPluginManager;
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::ConstructL()
sl@0: 	{
sl@0: 	iPluginManager = CWsPluginManager::NewL(*this);
sl@0: 	iDefaultAnimationScheduler = new(ELeave) CDefaultAnimationScheduler(*this);
sl@0: 	iDefaultAnimationScheduler->ConstructL();
sl@0: 	RegisterMemoryRelease(this);
sl@0: 	}
sl@0: 
sl@0: /** Creates a new client for this server. */
sl@0: CSession2* CWindowServer::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: 
sl@0: TInt CWindowServer::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: 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: 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: TInt CWindowServer::RegisterRawEventHandler(MEventHandler* aHandler)
sl@0: 	{
sl@0: 	if (!aHandler)
sl@0: 		return KErrArgument;
sl@0: 	TRAPD(err, TWindowServerEvent::PotentialEventHandlerL(1));
sl@0: 	if (err != KErrNone)
sl@0: 		return err;
sl@0: 	TWindowServerEvent::AddEventHandler(aHandler);
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::UnregisterRawEventHandler(MEventHandler* aHandler)
sl@0: 	{
sl@0: 	TWindowServerEvent::RemoveEventHandler(aHandler);
sl@0: 	TWindowServerEvent::PotentialEventHandlerL(-1); // can't leave for -1
sl@0: 	}
sl@0: 
sl@0: void CWindowServer::PostRawEvent(const TRawEvent & aEvent)
sl@0: 	{
sl@0: 	TWindowServerEvent::ProcessRawEvent(aEvent);
sl@0: 	}
sl@0: 	
sl@0: void CWindowServer::PostKeyEvent(const TKeyEvent & aEvent)
sl@0: 	{
sl@0: 	TWindowServerEvent::ProcessKeyEvent(aEvent, 0);
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: 		case MWsRawEventServer::EWsObjectInterfaceId:
sl@0: 			return static_cast<MWsRawEventServer*>(this);
sl@0: 		}
sl@0: 	
sl@0: 	if (iPluginManager)
sl@0: 		return iPluginManager->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: 	iDefaultAnimationScheduler->RemoveGraphicDrawer(aId);
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: CWsPluginManager* CWindowServer::PluginManager()
sl@0: 	{
sl@0: 	return iPluginManager;
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 i = iMemoryReleases.Count() - 1; i >= 0; --i)
sl@0: 		{
sl@0: 		if (iMemoryReleases[i] == aMemoryRelease)
sl@0: 			{
sl@0: 			iMemoryReleases.Remove(i);
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 i = iMemoryReleases.Count() - 1; !released && i >= 0; --i)
sl@0: 			{
sl@0: 			released = iMemoryReleases[i]->ReleaseMemory(static_cast<TMemoryReleaseLevel>(level));
sl@0: 			}
sl@0: 		}
sl@0: 	return released;
sl@0: 	}
sl@0: