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

//

#include "ScreenRedraw.h"

#include <hal.h>

#include "debugbar.h"

#include "inifile.h"

#include "screen.h"

#include "pointer.h"

#include "rootwin.h"

#include "walkwindowtree.h"

#include "wstop.h"

#include "WsMemMgr.h"

#include "renderstagemanager.h"

#include "graphics/WsRenderStageFactory.h"

#include "graphics/WsRenderStage.h"

#include "graphics/wsgraphicscontext.h"

#include "EVENT.H"

#ifdef USE_DEBUG_FRAME_CAPTURE

#include <graphics/wsscreendevice.h>

#include "../debuglog/debuglog.h"

#endif

GLREF_D CDebugLogBase *wsDebugLog;

#ifdef USE_DEBUG_REGIONS

#	define DEBUG_REGION(col,fill,reg) DebugRegion(col,fill,reg)

#	define DEBUG_RECT(col,fill,rect) DebugRect(col,fill,rect)

#else

#	define DEBUG_REGION(col,fill,reg)

#	define DEBUG_RECT(col,fill,rect)

#endif

#ifdef _DEBUG

# define LOG_SCREEN_REDRAW_START {if (wsDebugLog) {_LIT(KLogScreenRedrawStart, ">> CScreenRedraw::OnAnimation()"); wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, KLogScreenRedrawStart);}}

# define LOG_SCREEN_REDRAW_END {if (wsDebugLog) {_LIT(KLogScreenRedrawEnd, "<< CScreenRedraw::OnAnimation()"); wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, KLogScreenRedrawEnd);}}

#else

# define LOG_SCREEN_REDRAW_START

# define LOG_SCREEN_REDRAW_END

#endif

#ifdef USE_DEBUG_FRAME_CAPTURE

#	ifdef __WINS__

	_LIT(KDefaultFrameCaptureLocation, "c:\\");

#	else

	_LIT(KDefaultFrameCaptureLocation, "e:\\");

#	endif

#endif //USE_DEBUG_FRAME_CAPTURE

CScreenRedraw::TTimedRect::TTimedRect(TAnimType aType, const TRect& aRect, const TTime& aTime, CWsWindow* aWindow)

	: iType(aType), iRect(aRect), iTime(aTime), iWindow(aWindow)

	{

	}

TInt CScreenRedraw::TTimedRect::Compare(const TTimedRect& aOne,const TTimedRect& aOther)

	{

	if(aOne.iTime < aOther.iTime)

		return -1;

	else if(aOne.iTime > aOther.iTime)

		return 1;

	else

		return 0;

	}

CScreenRedraw * CScreenRedraw::NewL(CScreen& aScreen)

	{

	CScreenRedraw * self = new (ELeave) CScreenRedraw(aScreen);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CScreenRedraw::CScreenRedraw(CScreen& aScreen): iScreen(aScreen)

	{

	}

CScreenRedraw::~CScreenRedraw()

	{

	CRenderStageManager::Release(iRenderStages);

	iRenderStages = NULL;

	iTimedDrawRect.Close();

	iInvalid.Reset();

	iTopElement.Reset();

	iQuickFadeList.Reset();

#ifdef USE_DEBUG_FRAME_CAPTURE

	delete iDebugBitmap;

	delete iDebugBitmapDevice;

	delete iDebugBitmapGc;

#endif //USE_DEBUG_FRAME_CAPTURE

	}

void CScreenRedraw::ConstructL()

	{

	LEAVE_LOG_INSTALL_C;

	iRenderStages = CRenderStageManager::ConnectL(

						iScreen.ScreenNumber(),

						static_cast<MWsScreen*>(&iScreen),

						this

						);

	LEAVE_LOG_UNINSTALL_C;

	WS_ASSERT_ALWAYS(iRenderStages, EWsPanicNoRenderStagePipeline);

	iRenderStageTextCursor = static_cast<MWsTextCursor*>(iRenderStages->ResolveObjectInterface(KMWsTextCursor));

	WS_ASSERT_ALWAYS(iRenderStageTextCursor, EWsPanicTextCursorInterfaceMissing);

#ifdef USE_DEBUG_FRAME_CAPTURE

	_LIT(KWSERVIniFileVarFrameCapture,"FRAMECAPTURE");

	iFrameCapture = WsIniFile->FindVar(KWSERVIniFileVarFrameCapture);

	// Location to save captured images

	if (!WsIniFile->FindVar(KWSERVIniFileVarFrameCapture, iFrameCaptureLocation) || iFrameCaptureLocation.Length() == 0)

		{

		iFrameCaptureLocation.Set(KDefaultFrameCaptureLocation);

		}

#endif //USE_DEBUG_FRAME_CAPTURE

	}

MWsTextCursor* CScreenRedraw::RenderStageTextCursor() const

	{

	return iRenderStageTextCursor;

	}

const TTime& CScreenRedraw::Now() const

	{

	if(!iAnimating)

		{

		iNow.UniversalTime();

		}

	return iNow;

	}

void CScreenRedraw::ScheduleRender(const TTimeIntervalMicroSeconds& aFromNow)

	{

	iRenderScheduled = ETrue;

	TTime then(Now() + aFromNow);

	if ((!iScheduled) || then < iNext)

		iNext = then;

	iScheduled = ETrue;

	CWsTop::WindowServer()->AnimationScheduler()->ScheduleAnimation(iScreen,iNext);

	}

void CScreenRedraw::ScheduleRedraw()

	{

	iNext = Now();

	iScheduled = ETrue;

	// The other scheduler also removes future animations which this one encompasses.

	// We choose not to do the region calculations needed to achieve that here.

	CWindowServer* server = CWsTop::WindowServer();

	ASSERT(server);

	MWsAnimationScheduler* sched = server->AnimationScheduler();

	if(sched)

		sched->ScheduleRedraw(iScreen,iNext);

	else

		RDebug::Printf("CWsTop::WindowServer()->RedrawScheduler() is NULL!!!");			

	}

/**

@param aRect in screen coordinates 

*/

void CScreenRedraw::ScheduleAnimation(TAnimType aType, const TRect& aRect,const TTimeIntervalMicroSeconds& aFromNow,const TTimeIntervalMicroSeconds& /*aFreq*/,const TTimeIntervalMicroSeconds& /*aStop*/, CWsWindow* aWindow)

	{

	TRect scheduledRect(aRect);

	TRect test(aRect);

	// In changetracking mode, animation is either scheduled via a window dirty region (aWindow non-NULL)

	// or via a sprite manager dirty region (aWindow NULL) if scheduling a floating sprite

	if (iScreen.ChangeTracking())

		{

		if (aWindow)

			{

			// scheduling a window dirty rect for a window/anim/sprite

			test.Intersection(aWindow->Abs());

			scheduledRect.Move(-aWindow->Origin()); // convert to window coordinates

			}

		// else, // scheduling a sprite manager dirty rect for a floating sprite

		}

	else

		{

		// scheduling a screen dirty rect

		test.Intersection(iScreen.DrawableArea());

		aWindow = NULL; // ensure all future timed draw screen rects are checked below

		}

	if(!test.IsEmpty())

		{

		const TTime then(Now() + aFromNow);

		TTimedRect tRect(aType, scheduledRect, then, aWindow);

		const TInt error = iTimedDrawRect.InsertInOrderAllowRepeats(tRect,TTimedRect::Compare);

		if (KErrNone == error)

	   		{

			if (iScheduled)

				{

				if (then < iNext)

					{

					iNext = then;

					}

				}

			else

				{

				iNext = then;

				iScheduled = ETrue;

				}

			// remove further futures that are completely contained

			TInt count = iTimedDrawRect.Count();

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

				{

				const TTimedRect& future = iTimedDrawRect[i];

				if (future.iWindow != aWindow) // only check futures for the window/floating sprite/screen we're scheduling

					continue;

				if(future.iTime.Int64() > then.Int64())

					{

					TRect rect(scheduledRect);

					rect.BoundingRect(future.iRect);

					if(rect == scheduledRect) // future is completely contained within scheduledRect

						{

						iTimedDrawRect.Remove(i);

						count--;

						i--;

						}

					}

				}

			CWsTop::WindowServer()->AnimationScheduler()->ScheduleAnimation(iScreen,iNext);

			// Blue rectangles for scheduled animations

			DEBUG_RECT(TRgb(0x00, 0x00, 0xFF),TRgb(0x00, 0x00, 0xFF, 0x20),&aRect);

			}

		}

	}

TBool CScreenRedraw::IsScheduled(TAnimType aType, const TRect& aRect, CWsWindow* aWindow) const

	{

	TRect rect(aRect);

	if(aWindow)

		{

		rect.Move(-aWindow->Origin()); //convert to window coordinates

		}

	const TInt count(iTimedDrawRect.Count());

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

		{

		if ((iTimedDrawRect[i].iType == aType) && 

				(iTimedDrawRect[i].iRect == rect) && 

				(iTimedDrawRect[i].iWindow == aWindow))

			{

			return ETrue;

			}

		}

	return EFalse;

	}

// This adds a region to the stored invalid region.

// The invalid region is the area of the screen that needs to be redrawn in addition to any animations.

// The draw region is the area of the screen on which only the top window needs to be redrawn.

// If the top window has transparency, this can only be true when it has been made newly visible.

// The value of aSchedule could be determined automatically from iAnimating, but passing it this way

// allows us to have the assert, which is a very valuable assert.

void CScreenRedraw::AddRedrawRegion(const TRegion& aRegion, TBool aSchedule, TRedrawDepth aDepth)

	{

	WS_ASSERT_DEBUG(!iAnimating || !aSchedule, EWsPanicScheduledRedraw);

	if(aRegion.CheckError())

		{

		iInvalid.ForceError();

		if (aSchedule)

			ScheduleRedraw();

		}

	else if(aRegion.Count()) // often called despite window not being visible

		{

		if (aDepth == ERedrawAll)

			{

			// red lines for an invalid region which is ready to be drawn

			DEBUG_REGION(TRgb(0xFF, 0x00, 0x00),TRgb(0xFF, 0x00, 0x00, 0x20),&aRegion);

			iInvalid.Union(aRegion);

			if (aSchedule)

				ScheduleRedraw();

			}

		else

			{

			// yellow lines for a valid region which we will draw on top of

			DEBUG_REGION(TRgb(0xFF, 0xFF, 0x00),TRgb(0xFF, 0xFF, 0x00, 0x20),&aRegion);

			iTopElement.Union(aRegion);

			if (aSchedule)

				ScheduleRedraw();			

			}

		}

	}

// This causes any asynchronously scheduled redraw to happen immediately

// It should be avoided where possible for performance reasons, but is 

// needed whenever the redraw store is discarded for a window which still

// has a redraw region pending.

// @note This method always attempts to DoRedrawNow(), even if currently

//		 animating. In this context, animation is a frame update. With NGA

// 		 that update completes at some point in the future. If you get a request

//		 to DoRedrawNow() the expectation is that all updates scheduled on or 

//		 before that point in time will have completed by the time the call 

//		 returns. An update may have been scheduled during a current (asynchronous)

//		 Animate call...the animation scheduler has this knowledge, so let it

//		 decide what to do.

void CScreenRedraw::DoRedrawNow()

	{

	CWsTop::WindowServer()->AnimationScheduler()->DoRedrawNow(iScreen);

	}

#ifdef USE_DEBUG_REGIONS

void CScreenRedraw::DebugRect(TRgb aColor, TRgb aFill, const TRect* aRect)

	{

	if (aRect)

		{

		CFbsBitGc * gc = iScreen.GetBitGc();

		gc->SetPenColor(aColor);

		gc->SetPenStyle(CGraphicsContext::ESolidPen);

		gc->SetPenSize(TSize(2,2));

		gc->SetBrushColor(aFill);

		gc->SetBrushStyle(CGraphicsContext::ESolidBrush);

		TRect smaller = *aRect;

		smaller.iBr.iX -= 1;

		smaller.iBr.iY -= 1;

		gc->DrawRect(smaller);

		iScreen.Update();

		}

	}

void CScreenRedraw::DebugRegion(TRgb aColor, TRgb aFill, const TRegion * aRegion)

	{

	if (aRegion)

		{

		CFbsBitGc * gc = iScreen.GetBitGc();

		gc->SetPenColor(aColor);

		gc->SetPenStyle(CGraphicsContext::ESolidPen);

		gc->SetPenSize(TSize(2,2));

		gc->SetBrushColor(aFill);

		gc->SetBrushStyle(CGraphicsContext::ESolidBrush);

		for (const TRect *rect = aRegion->RectangleList(); rect - aRegion->RectangleList() < aRegion->Count(); ++rect)

			{

			TRect smaller = *rect;

			smaller.iBr.iX -= 1;

			smaller.iBr.iY -= 1;

			gc->DrawRect(smaller);

			}

		iScreen.Update();

		}

	}

#endif 

void CScreenRedraw::OnAnimation(TRequestStatus* aFinished)

	{

	LOG_SCREEN_REDRAW_START

	WS_ASSERT_ALWAYS(!iAnimating,EWsPanicAnimationAlreadyAnimating);

	WS_ASSERT_ALWAYS(iScheduled,EWsPanicAnimationNotScheduled);

	iAnimating = ETrue;

	iScheduled = EFalse;

	const TBool changeTracking = iScreen.ChangeTracking();

 	const TRegionFix<1> fallbackRegion(iScreen.RootWindow()->Abs());

	CWsActiveScheduler::Static()->PrepareDraw();

	// Calculate any updates required by region changes:

	RegionUpdate();

	// Use the timed rectangles to mark screen, window or floating sprite as dirty

	RWsRegionBuf<10> floatingSpriteDirtyRegion;

 	const TBool futureAnimationRequired = ScheduleTimedRects(floatingSpriteDirtyRegion);

 	if (floatingSpriteDirtyRegion.CheckError())

 		{

 		floatingSpriteDirtyRegion.Reset();

 		floatingSpriteDirtyRegion.Copy(fallbackRegion);

 		}

 	TWalkWindowTreeSchedule* scheduler = NULL;

 	TWalkWindowListSchedule windowScheduler(iScheduledWindowList, iInvalid); //ChangeTracking

	if (!changeTracking)

		{

		// Animating rectangles could cause iInvalid to overlap iTopElement, in which case iTopElement won't work.

		iTopElement.SubRegion(iInvalid);

		iTopElement.Intersect(iScreen.RootWindow()->WindowArea());

		iTopElement.Tidy();

		// Anything in the top element is implicitly invalid

		iInvalid.Union(iTopElement);

		iInvalid.Intersect(iScreen.RootWindow()->WindowArea());

		iInvalid.Tidy();

		if(iInvalid.CheckError())

			{

			iTopElement.Reset();

			iInvalid.Reset();

			iInvalid.Copy(fallbackRegion);

			}

		}

	else 

		{

		// In ChangeTracking mode, iInvalid is only used to tell the render stage

		// which part of the screen needs updating.

		iInvalid.Reset();

		iInvalid.Copy(floatingSpriteDirtyRegion);

		scheduler = &windowScheduler;

		windowScheduler.WalkWindowList();

		CWsTop::TriggerRedraws(iScreen.RootWindow()); //In case WalkWindowList did queue a request for the client to provide draw commands

		iInvalid.Tidy();

		if(iInvalid.CheckError())

			{

			iInvalid.Reset();

			iInvalid.Copy(fallbackRegion);

			}

		}

	// At this point, if the DEBUG_REGION is being used:

	// Red represents invalid regions that need to be redrawn completely.

	// Yellow represents regions that only need the top window to be drawn.

	// Blue represents regions which are being animated server side.

	if (iRenderScheduled || !iInvalid.IsEmpty() || iQuickFadeList.Count() > 0)  

		{

		iRenderScheduled = EFalse;

		TWalkWindowTreeScheduleRegions regionScheduler(iInvalid, iTopElement); //!ChangeTeacking

		TWalkWindowTreeScheduleFallback fallbackScheduler(iScreen.FallbackMap());//!ChangeTeacking

		RWsRegionBuf<20> animationRegion;

		if (!changeTracking)

			{	

			animationRegion.Copy(iInvalid);

			AddQuickFadeableRegions(animationRegion);

			if (animationRegion.CheckError())

				{

				animationRegion.Reset();

				animationRegion.Copy(fallbackRegion);

				}

			iAnimationRegion = &animationRegion; //iAnimationRegion must be reset to NULL before the call stack unwinds.

			scheduler = &regionScheduler;

			iScreen.RootWindow()->WalkWindowTree(regionScheduler,EWalkChildren);

			if (!regionScheduler.ScheduledRegionsOk())

				{

				// our region calculations for what to draw failed at some point.

				// From this point on we MUST NOT rely on allocating memory

				scheduler = &fallbackScheduler;

				iScreen.FallbackMap()->Prepare();

				iScreen.RootWindow()->WalkWindowTree(fallbackScheduler,EWalkChildren);

				iAnimationRegion = iScreen.FallbackMap()->Region();

				}

			}

		else

			{

			iAnimationRegion = &iInvalid;

			}

		CWsActiveScheduler::Static()->StartDraw();

		CWsMemoryManager::Static()->EnableReserve();

		// Redraw debug regions more brightly than before:

		DEBUG_REGION(TRgb(0xFF, 0x00, 0x00),TRgb(0xFF, 0x00, 0x00, 0x80),iAnimationRegion);

		DEBUG_REGION(TRgb(0xFF, 0xFF, 0x00),TRgb(0xFF, 0xFF, 0x00, 0x80),&iTopElement);

		// Pipe the drawing into the first render stage:

		iRenderStages->Begin(iAnimationRegion);

		RWsRegionBuf<10> accumulatedDrawing;

		MWsGraphicsContext * stageGc = static_cast<MWsGraphicsContext*>(iRenderStages->ResolveObjectInterface(KMWsGraphicsContext));

		for (CWsWindow * win = scheduler->HeadWindow(); (win!=NULL); win = win->NextScheduled())

			{

			if(!changeTracking)

					accumulatedDrawing.Union(scheduler->WindowRegion(*win));

			Render(*win, *stageGc, *scheduler);

			}

		if(!changeTracking && !accumulatedDrawing.CheckError())

			{

			//Fade any region of the screen scheduled for fading which has not been redrawn,

			DoQuickFade(stageGc, accumulatedDrawing);

			}

		accumulatedDrawing.Reset();

		//We limit floating sprite drawing to regions already touched

		iScreen.SpriteManager()->DrawFloatingSprites(stageGc, iScreen.ChangeTracking() ? floatingSpriteDirtyRegion : *iAnimationRegion);

		iRenderStages->End(aFinished);

		stageGc = NULL; //we're not allowed to draw outside Begin()/End()

#if defined(__WINS__) && defined(_DEBUG)

		MWsDebugBar * debugBar = static_cast<MWsDebugBar*>(iRenderStages->ResolveObjectInterface(KMWsDebugBar));

		if (debugBar) //optional for the licensees

			{

			if (CDebugBar* dbg = iScreen.DebugBar())

				{	

				RArray<TPtrC> debugText;

				dbg->DebugBarInfo(debugText);

				debugBar->DrawDebugBar(debugText.Array());

				debugText.Close();

				}

			}

#endif

		iScheduledWindowList = NULL;

		CWsMemoryManager::Static()->DisableReserve();

#ifdef USE_DEBUG_FRAME_CAPTURE

		if (iFrameCapture)

			{

			CaptureFrame(iAnimationRegion);

			}

#endif

		// DEBUG_REGION does not work with render stages.

		// These comments refer to what used to happen.

		// At this point, if the DEBUG_REGION is being used, there should usually be only green regions

		// displayed.  If we see red or yellow, then something didn't get redrawn that should have been.

		// If we see purple then a window has disobeyed the const setting on the region to draw.

		// Red or yellow is valid - a window can decide it isn't ready to draw yet - purple is very bad.

		//iScreen.Update();

		// At this point, if the DEBUG_REGION is being used, there should be no regions visible

		// of any colour.  If we see green, then it means an area of the screen was drawn to which

		// wasn't invalid, or the screen update call failed.  The former is more likely.

		// If we still see red or yellow it is a region that is not yet ready to draw.

		const TRect* rect = iAnimationRegion->RectangleList();

		TInt pixels = 0;

		for(TInt r = iAnimationRegion->Count(); r>0; r--)

			{

			pixels += (rect->Width()*rect->Height());

			rect++;

			}

		CWsActiveScheduler::Static()->StopDraw(pixels);

		TWindowServerEvent::NotifyScreenDrawingEvent(iAnimationRegion);

		iAnimationRegion = NULL; //iAnimationRegion must be reset to NULL before the call stack unwinds.

		iInvalid.Reset();

		animationRegion.Reset();

		}

	else

		{

		// There was nothing to compose. Signal that composition is complete.

		if (aFinished) 

			{

			*aFinished = KRequestPending;

			User::RequestComplete(aFinished, KErrNone);

			}

		CWsActiveScheduler::Static()->CancelPrepare();

		}

	floatingSpriteDirtyRegion.Reset();

	iInvalid.Reset();

	iTopElement.Reset();

	iAnimating = EFalse;

	if (futureAnimationRequired && iTimedDrawRect.Count() > 0 && !iScheduled)

		{

		// If this flag is set then it means there were already some animations scheduled when we ran,

		// but they themselves didn't run.  We need to make sure we have _something_ scheduled.

		CWsTop::WindowServer()->AnimationScheduler()->ScheduleAnimation(iScreen, iTimedDrawRect[0].iTime);

		iScheduled = ETrue;

		}

	if(iObserver)

		{

		iObserver->ScreenUpdated(iScreen.ScreenNumber());

		iObserver=NULL; //once signalled we are never going to call it again

		}

	LOG_SCREEN_REDRAW_END

	}

void CScreenRedraw::AddQuickFadeableRegions(TRegion& aRegion)

	{

	if (iQuickFadeList.Count() > 0)

		{

		for (TInt idx = iQuickFadeList.Count() - 1; idx >= 0; idx --)

			{

			CWsWindow* win = iQuickFadeList[ idx ];

			if ( !win->IsDSAHost() )

				{

				aRegion.Union(win->QuickFadeRegion() );

				}

			}

		aRegion.Tidy();

		}

	}

void CScreenRedraw::DoQuickFade(MWsGraphicsContext* aGc, TRegion& aAccumulatedDrawing)

	{

	if ( iQuickFadeList.Count() > 0 )

		{

		for ( TInt idx = iQuickFadeList.Count() - 1; idx >= 0 ; idx -- )

			{

			CWsWindow* win = iQuickFadeList[ idx ];

			if ( !win->IsDSAHost() )

				{				

				STACK_REGION winFadeRgn;				

				winFadeRgn.Copy( win->QuickFadeRegion() );

				winFadeRgn.SubRegion( aAccumulatedDrawing );

				winFadeRgn.Tidy();

				if ( !winFadeRgn.IsEmpty() && !winFadeRgn.CheckError() )

					{ // now fade any region that has not been redrawn (via win->Render())

					win->Fade( aGc, winFadeRgn );

					aAccumulatedDrawing.Union( winFadeRgn );	      		

					}		      	

	  			winFadeRgn.Close();

				}

			}

		iQuickFadeList.Reset();

		}

	}

/**

This function will iterate the timed rectangles and find any animation or sprite 

that are due to be scheduled for render now. Then schedule them and remove them 

from iTimedDrawRect.

@return ETrue if iTimedDrawRect still contains future animations

*/

TBool CScreenRedraw::ScheduleTimedRects(TRegion& aScheduledFloatingSpriteRegion)

 	{

	iNow.UniversalTime();

	TInt count(iTimedDrawRect.Count());

	TBool futureAnimationRequired = EFalse;

	while (0 < count)

		{

		if(iTimedDrawRect[0].iTime.Int64() <= iNow.Int64())

			{

			if (iScreen.ChangeTracking())

				{

				switch(iTimedDrawRect[0].iType)

					{

					case ECrpAnim:

						{

						CWsWindow* win = iTimedDrawRect[0].iWindow;

						WS_ASSERT_DEBUG(win,EWsPanicWindowNull);

						if(!win->IsTrackingVisibleRegion() || (win->IsTrackingVisibleRegion() && !win->VisibleRegion().IsEmpty()))

							{

							TRegionFix<1> region;

							region.AddRect(iTimedDrawRect[0].iRect);

							win->AddDirtyWindowRegion(region);

							ScheduleWindow(win);

							}

						break;

						}

					case EWindowAnim:

					case ESpriteAnim:

					case ETextCursor:

					case EWindowSprite:

						{

						CWsWindow* win = iTimedDrawRect[0].iWindow;

						WS_ASSERT_DEBUG(win,EWsPanicWindowNull);

						if(!win->IsTrackingVisibleRegion() || (win->IsTrackingVisibleRegion() && !win->VisibleRegion().IsEmpty()))

							{

							TRegionFix<1> region;

							region.AddRect(iTimedDrawRect[0].iRect);

							win->AddDirtySpriteRegion(region);

							ScheduleWindow(win);

							}

						break;

						}

					case EFloatingSprite:

					case EFloatingSpriteAnim:

						{

						aScheduledFloatingSpriteRegion.AddRect(iTimedDrawRect[0].iRect);

						break;

						}

					}

				TRect screenRect(iTimedDrawRect[0].iRect);

				if(iTimedDrawRect[0].iWindow)

					{

					screenRect.Move(iTimedDrawRect[0].iWindow->Origin()); // convert to screen coordinates

					}	

				}

			else

				{ 

				// schedule a screen dirty rect

				iInvalid.AddRect(iTimedDrawRect[0].iRect);

				}

			iTimedDrawRect.Remove(0);

			count--;

			}

		else

			{

			futureAnimationRequired = ETrue;	

			break;

			}

		}

	return futureAnimationRequired;

 	}

void CScreenRedraw::Render(CWsWindow& aWin, MWsGraphicsContext& aGc, const TWalkWindowTreeSchedule& aScheduler)

	{

	const TRegion* windowRegion = &(aScheduler.WindowRegion(aWin));

	const TRegion* spriteRegion = &(aScheduler.SpriteRegion(aWin));

	if(windowRegion->IsEmpty() && spriteRegion->IsEmpty()) 

	    return; //Don't call CWsWindow::Render if there is nothing that can be rendered 

	//Make sure we don't try to draw outside screen

	STACK_REGION clippedWindowRegion;

	if(!windowRegion->IsContainedBy(iScreen.RootWindow()->Abs()))

		{

		TRegionFix<1> screen(iScreen.RootWindow()->Abs());

		clippedWindowRegion.Intersection(*windowRegion, screen);

		windowRegion = &clippedWindowRegion;

		}

	STACK_REGION clippedSpriteRegion;

	if(!spriteRegion->IsContainedBy(iScreen.RootWindow()->Abs()))

		{

		TRegionFix<1> screen(iScreen.RootWindow()->Abs());

		clippedSpriteRegion.Intersection(*spriteRegion, screen);

		spriteRegion = &clippedSpriteRegion;

		}	

	if(!windowRegion->CheckError() && !spriteRegion->CheckError())

		{

		// Purple regions are about to be drawn

		DEBUG_REGION(TRgb(0x80, 0x00, 0x80),TRgb(0x80, 0x00, 0x80, 0x80), windowRegion);

		DEBUG_REGION(TRgb(0x80, 0x00, 0x80),TRgb(0x80, 0x00, 0x80, 0x80), spriteRegion);

		aWin.Render(aGc, *windowRegion, *spriteRegion); //When not in ChangeTracking mode, both windowRegion and spriteRegion points to the same region

		aWin.ClearScheduledRegion();

		aWin.ClearScheduledSpriteRegion();

		// Green regions have been drawn

		DEBUG_REGION(TRgb(0x00, 0xFF, 0x00),TRgb(0x00, 0xFF, 0x00, 0x80), windowRegion);

		DEBUG_REGION(TRgb(0x00, 0xFF, 0x00),TRgb(0x00, 0xFF, 0x00, 0x80), spriteRegion);

		}

	else

		{

		OomRender(aWin, aGc, aScheduler);		

		}

	clippedSpriteRegion.Close();

	clippedWindowRegion.Close();

	}

void CScreenRedraw::OomRender(CWsWindow& aWin, MWsGraphicsContext& aGc, const TWalkWindowTreeSchedule& aScheduler)

	{	

	const TRegion* windowRegion = &(aScheduler.WindowRegion(aWin));

	const TRegion* spriteRegion = &(aScheduler.SpriteRegion(aWin));

	WS_ASSERT_DEBUG(!(windowRegion->IsEmpty() && spriteRegion->IsEmpty()), EWsPanicRegionNull);

	TRect validWindow(aWin.Abs());

	validWindow.Intersection(iScreen.RootWindow()->Abs());

    TRegionFix<1> fallbackRegion(validWindow);

    if(windowRegion->CheckError())

        windowRegion = &fallbackRegion;

    if(spriteRegion->CheckError())

        spriteRegion = &fallbackRegion;

    // Purple regions are about to be drawn

    DEBUG_REGION(TRgb(0x80, 0x00, 0x80),TRgb(0x80, 0x00, 0x80, 0x80), windowRegion);

    DEBUG_REGION(TRgb(0x80, 0x00, 0x80),TRgb(0x80, 0x00, 0x80, 0x80), spriteRegion);

    aWin.Render(aGc, *windowRegion, *spriteRegion); //When not in ChangeTracking mode, both windowRegion and spriteRegion points to the same region

    aWin.ClearScheduledRegion();

    aWin.ClearScheduledSpriteRegion();

    // Green regions have been drawn

    DEBUG_REGION(TRgb(0x00, 0xFF, 0x00),TRgb(0x00, 0xFF, 0x00, 0x80), windowRegion);

    DEBUG_REGION(TRgb(0x00, 0xFF, 0x00),TRgb(0x00, 0xFF, 0x00, 0x80), spriteRegion);	

	}

//

void CScreenRedraw::DiscardAllSchedules()

	{

	ASSERT(!iAnimating);

	iTimedDrawRect.Reset();

	iInvalid.Reset();

	}

/**

Indicates that a window has moved or changed ordinal position so that the visible regions

of all windows needs to be recalculated

*/

void CScreenRedraw::ScheduleRegionUpdate(const TRegion* aDefinitelyDirty)

	{

	if (iScreen.ChangeTracking() && iScreen.WindowVisibilityNotifier())

		return;

	iRegionUpdateScheduled = ETrue;

	ScheduleRedraw();

	if(!iScreen.ChangeTracking() && aDefinitelyDirty)

		{

		iInvalid.Union(*aDefinitelyDirty);

		// Cyan regions for invalidations caused by this:

		DEBUG_REGION(TRgb(0x00, 0xFF, 0xFF),TRgb(0x00, 0xFF, 0xFF, 0x20),aDefinitelyDirty);

		}

	}

/**

Only used in CHANGETRACKING mode.

Windows are scheduled to:

- if required, ask client to validate (from lower loop)

- render the dirty window region

*/

void CScreenRedraw::ScheduleWindow(CWsWindow* aWindow)

	{

	// Add a scheduled window to the linked list, ignoring duplicates

	CWsWindow* win = iScheduledWindowList;

	while (win && win != aWindow)

		{

		win = win->NextScheduled();

		}

	if (!win)

		{

		aWindow->SetNextScheduled(iScheduledWindowList);

		iScheduledWindowList = aWindow;

		}

	ScheduleRedraw();

	}

void CScreenRedraw::RemoveFromScheduledList(CWsWindow* aWindow)

	{

	// Search for the window

	CWsWindow* win = iScheduledWindowList;

	CWsWindow* previous = NULL;

	while (win && win != aWindow)

		{

		previous = win;

		win = win->NextScheduled();

		}

	if (win)

		{

		// Found it, remove from list

		if (win == iScheduledWindowList)

			{

			iScheduledWindowList = win->NextScheduled();

			}

		else

			{

			previous->SetNextScheduled(win->NextScheduled());

			}

		}

	}

void CScreenRedraw::RemoveFromTimedDrawList(CWsWindow* aWindow)

	{

	if(aWindow)

		{	

		TInt count(iTimedDrawRect.Count());

		TInt index = 0;

		while(index < count)

			{

			if (iTimedDrawRect[index].iWindow == aWindow)

				{

				iTimedDrawRect.Remove(index);

				--count;

				}

			else

				{

				++index;

				}

			}

		}

	}

/**

Recalculates visible regions and schedules redraws or queues redraw events in response to

any changes

*/

void CScreenRedraw::RegionUpdate()

	{

	TBool somethingScheduled = EFalse;

	if (iVisibilityUpdateScheduled)

		{

		iVisibilityUpdateScheduled = EFalse;

		somethingScheduled = ETrue;

		MWsWindowVisibilityNotifier* const notifier = iScreen.WindowVisibilityNotifier();

		if(notifier)

			{

			notifier->SendVisibilityChanges(); // Should result in one callback to SetWindowVisibility for each window subscribing for visible region updates

			}

		}

	if (iRegionUpdateScheduled)

		{

		iRegionUpdateScheduled = EFalse;

		somethingScheduled = ETrue;

		TWalkWindowTreeUpdateRegions updater(iScreen);

		updater.Walk();

		for ( TInt idx = iQuickFadeList.Count() - 1; idx >= 0; idx-- )

			{

			CWsWindow* win = iQuickFadeList[ idx ];

			const TRegion& quickFadeRegion = win->QuickFadeRegion();

			//If QuickFadeRegion().IsEmpty() we should remove the window from iQuickFadeList.

			//And if this window has not been drawn to the screen, then it is not possible to quick fade it.

			if (quickFadeRegion.IsEmpty() || !win->HasBeenDrawnToScreen())

				{

				iQuickFadeList.Remove( idx );

				}

			}

		}

	if (somethingScheduled)

		{

		TWsPointer::ReLogPointersCurrentWindows();

		CWsTop::TriggerRedraws(iScreen.RootWindow());

		}

	}

/**

To be called by MWsWindowVisibilityNotifier (when running in ChangeTracking mode) 

in response to MWsWindowVisibilityNotifier::SendVisibilityChanges()  

*/

void CScreenRedraw::SetWindowVisibility(const MWsWindow& aWindow, const TRegion& aVisibleRegion)

	{

	CWsWindow& win = static_cast<CWsWindow&>(const_cast<MWsWindow&>(aWindow));

	WS_ASSERT_DEBUG(win.IsTrackingVisibleRegion(), EWsPanicVisibleRegionTracking);

	WS_ASSERT_DEBUG(!aVisibleRegion.CheckError(), EWsPanicRegion);

	if(aVisibleRegion.IsEmpty() && !win.VisibleRegion().IsEmpty())

		{

		win.ClearVisibleRegion();

		}

	else if(!aVisibleRegion.IsEmpty() && !aVisibleRegion.CheckError())

		{

		// Assert that aVisibleRegion is contained by aWin

		TRect bounds = win.AbsRect();

		bounds.Resize(1,1);

		WS_ASSERT_DEBUG(bounds.Contains(aVisibleRegion.BoundingRect().iTl), EWsPanicRegion);

		WS_ASSERT_DEBUG(bounds.Contains(aVisibleRegion.BoundingRect().iBr), EWsPanicRegion);

		win.SetVisibleRegion(aVisibleRegion, NULL);

		}

	else if(aVisibleRegion.CheckError())

		{

		const TRegionFix<1> fallback(win.Abs());

		win.SetVisibleRegion(fallback, NULL);

		}

	}

/**

To be called by MWsWindowVisibilityNotifier (when running in ChangeTracking mode) when the 

iVisibleRegion is changed for a window that subscribes for this information. The visible region 

of the window has not been updated yet at the time of this function call, but the new metrics will be retrieved 

from MWsWindowVisibilityNotifier (through a call to MWsWindowVisibilityObserver::SetWindowVisibility())

and set to each window next time OnAnimation is called.   

*/

void CScreenRedraw::VisibilityChanged()

	{

	iVisibilityUpdateScheduled = ETrue;

	ScheduleRedraw();

	}

void CScreenRedraw::SetObserver(MWsScreenRedrawObserver* aObserver)

	{

	iObserver = aObserver;

	}

/**

Returns ETrue if an update or animation is scheduled.

Note: Now that WSERV surface and composition updates are asynchronous (with NGA)

it is possible for this method to return EFalse, even if the last update has

not been completed by the rendering pipeline. This is dependant on the configuration

and implementation of render stages that make up the rendering pipeline.

If in doubt, it is best to call CScreenRedraw::DoRedrawNow(), which will not return