sl@0: // Copyright (c) 2006-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: // SCREEN_REDRAW.CPP
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include "ScreenRedraw.h"
sl@0: 
sl@0: #include <hal.h>
sl@0: 
sl@0: #include "debugbar.h"
sl@0: #include "screen.h"
sl@0: #include "inifile.h"
sl@0: #include "offscreenbitmap.h"
sl@0: #include "wspluginmanager.h"
sl@0: #include "pointer.h"
sl@0: #include "rootwin.h"
sl@0: #include "walkwindowtree.h"
sl@0: #include "wstop.h"
sl@0: #include "WsMemMgr.h"
sl@0: #include "Graphics/WsRenderStageFactory.h"
sl@0: #include "Graphics/WsRenderStage.h"
sl@0: #include "EVENT.H"
sl@0: 
sl@0: GLREF_D CDebugLogBase *wsDebugLog;
sl@0: 
sl@0: #ifdef USE_DEBUG_REGIONS
sl@0: #	define DEBUG_REGION(col,fill,reg) DebugRegion(col,fill,reg)
sl@0: #	define DEBUG_RECT(col,fill,rect) DebugRect(col,fill,rect)
sl@0: #else
sl@0: #	define DEBUG_REGION(col,fill,reg)
sl@0: #	define DEBUG_RECT(col,fill,rect)
sl@0: #endif
sl@0: 
sl@0: #if defined(__WINS__) && defined(_DEBUG)
sl@0: #	define DEBUGOSB { CWsOffScreenBitmap * ofb = iScreen.OffScreenBitmap(); if (ofb) ofb->Update(); }
sl@0: #else
sl@0: #	define DEBUGOSB
sl@0: #endif				
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: # define LOG_SCREEN_REDRAW_START {if (wsDebugLog) {_LIT(KLogScreenRedrawStart, ">> CScreenRedraw::OnAnimation()"); wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, KLogScreenRedrawStart);}}
sl@0: # define LOG_SCREEN_REDRAW_END {if (wsDebugLog) {_LIT(KLogScreenRedrawEnd, "<< CScreenRedraw::OnAnimation()"); wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, KLogScreenRedrawEnd);}}
sl@0: #else
sl@0: # define LOG_SCREEN_REDRAW_START
sl@0: # define LOG_SCREEN_REDRAW_END
sl@0: #endif
sl@0: 
sl@0: CScreenRedraw::TTimedRect::TTimedRect(const TRect& aRect, const TTime& aTime):
sl@0: 	iRect(aRect), iTime(aTime)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: TInt CScreenRedraw::TTimedRect::Compare(const TTimedRect& aOne,const TTimedRect& aOther)
sl@0: 	{
sl@0: 	if(aOne.iTime < aOther.iTime)
sl@0: 		return -1;
sl@0: 	else if(aOne.iTime > aOther.iTime)
sl@0: 		return 1;
sl@0: 	else
sl@0: 		return 0;
sl@0: 	}
sl@0: 
sl@0: CScreenRedraw * CScreenRedraw::NewL(CScreen& aScreen)
sl@0: 	{
sl@0: 	CScreenRedraw * self = new (ELeave) CScreenRedraw(aScreen);
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL();
sl@0: 	CleanupStack::Pop(self);
sl@0: 	return self;
sl@0: 	}
sl@0: 	
sl@0: CScreenRedraw::CScreenRedraw(CScreen& aScreen): iScreen(aScreen)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: CScreenRedraw::~CScreenRedraw()
sl@0: 	{
sl@0: 	CWsRenderStage * stage = iRenderStages;
sl@0: 	while (stage!=NULL)
sl@0:    		{
sl@0: 		CWsRenderStage *next=stage->Next();
sl@0:    		delete stage;
sl@0: 		stage=next;
sl@0:    		}
sl@0: 	iTimedDrawRect.Close();
sl@0: 	iInvalid.Close();
sl@0: 	iTopLayer.Close();
sl@0: 	iBannedRegion.Close();	
sl@0: 	}
sl@0: 
sl@0: void CScreenRedraw::ConstructL()
sl@0: 	{
sl@0: 	CWsPluginManager * pluginMgr = CWsTop::WindowServer()->PluginManager();
sl@0: 	
sl@0: 	// Setup the render stages for this screen:
sl@0: 	_LIT(KDefaultRenderStages, "std");
sl@0: 	_LIT(KDefaultFlickerFreeRenderStages, "flickerbuffer std");
sl@0: 	_LIT(KRenderStages,"RENDERSTAGES");
sl@0: 	TPtrC stagesString;
sl@0: 	const TBool customStages = WsIniFile->FindVar(iScreen.ScreenNumber(),KRenderStages,stagesString);
sl@0: 	
sl@0: 	// If noone specifies stages for this screen, assume the standard implementation:
sl@0: 	const TDesC * stages;
sl@0: 	if (customStages)
sl@0: 		stages = &stagesString;
sl@0: 	else if (iScreen.OffScreenBitmap())
sl@0: 		stages = &KDefaultFlickerFreeRenderStages();
sl@0: 	else
sl@0: 		stages = &KDefaultRenderStages();
sl@0: 	
sl@0: 	CWsRenderStage * lastStage = 0;
sl@0: 
sl@0: 	// Parse the string for implementation IDs:
sl@0: 	TLex lex(*stages);
sl@0: 	while(true)
sl@0: 		{
sl@0: 		TPtrC ptr = lex.NextToken();
sl@0: 		if (ptr.Length() > 0)
sl@0: 			{
sl@0: 			TInt err = KErrNone;
sl@0: 			MWsRenderStageFactory * factory = pluginMgr->FindNamedImplementation<MWsRenderStageFactory>(ptr);
sl@0: 			if (factory)
sl@0: 				{
sl@0: 				CWsRenderStage * stage = 0;
sl@0: 				TRAP(err, stage = factory->CreateStageL(static_cast<MWsScreen*>(&iScreen), this));
sl@0: 				if (err == KErrNone)
sl@0: 					{
sl@0: 					if (!stage)
sl@0: 						{
sl@0: 						err = KErrNotFound;
sl@0: 						}
sl@0: 					else
sl@0: 						{
sl@0: 						if (lastStage)
sl@0: 							lastStage->SetNext(stage);
sl@0: 						else
sl@0: 							iRenderStages = stage;
sl@0: 						lastStage = stage;
sl@0: 						}
sl@0: 					}
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				err = KErrNotFound;
sl@0: 				}
sl@0: 
sl@0: 			if (wsDebugLog)
sl@0: 				{
sl@0: 				TBuf<64> buf;
sl@0: 				if (err == KErrNone)
sl@0: 					{
sl@0: 					_LIT(KAddedRenderStage,"Added render stage: ");
sl@0: 					buf.Append(KAddedRenderStage);
sl@0: 					buf.Append(ptr);
sl@0: 					wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant,buf);
sl@0: 					}
sl@0: 				else
sl@0: 					{
sl@0: 					_LIT(KMissingRenderStage,"Failed to add render stage (%d): ");
sl@0: 					buf.Append(KMissingRenderStage);
sl@0: 					buf.Append(ptr);
sl@0: 					wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant,buf,err);
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			break;
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: const TTime& CScreenRedraw::Now() const
sl@0: 	{
sl@0: 	if(!iAnimating)
sl@0: 		{
sl@0: 		iNow.UniversalTime();
sl@0: 		}
sl@0: 	return iNow;
sl@0: 	}
sl@0: 
sl@0: void CScreenRedraw::ScheduleRender(const TTimeIntervalMicroSeconds& aFromNow)
sl@0: 	{
sl@0: 	iRenderScheduled = ETrue;
sl@0: 	TTime then(Now() + aFromNow);
sl@0: 	if ((!iScheduled) || then < iNext)
sl@0: 		iNext = then;
sl@0: 	iScheduled = ETrue;
sl@0: 	CWsTop::WindowServer()->AnimationScheduler()->ScheduleAnimation(iScreen,iNext);
sl@0: 	}
sl@0: 
sl@0: void CScreenRedraw::ScheduleRedraw()
sl@0: 	{
sl@0: 	iNext = Now();
sl@0: 	iScheduled = ETrue;
sl@0: 		
sl@0: 	// The other scheduler also removes future animations which this one encompasses.
sl@0: 	// We choose not to do the region calculations needed to achieve that here.
sl@0: 	MWsAnimationScheduler* animSched=CWsTop::WindowServer()->AnimationScheduler();
sl@0: 	if (animSched)
sl@0: 		{
sl@0: 		animSched->ScheduleRedraw(iScreen,iNext);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CScreenRedraw::ScheduleAnimation(const TRect& aRect,const TTimeIntervalMicroSeconds& aFromNow,const TTimeIntervalMicroSeconds& /*aFreq*/,const TTimeIntervalMicroSeconds& /*aStop*/)
sl@0: 	{
sl@0: 	TRect test(aRect);
sl@0: 	test.Intersection(iScreen.DrawableArea());
sl@0: 	if(!test.IsEmpty())
sl@0: 		{
sl@0: 		const TTime then(Now() + aFromNow);
sl@0: 		TTimedRect tRect(aRect, then);
sl@0: 
sl@0: 		const TInt error = iTimedDrawRect.InsertInOrderAllowRepeats(tRect,TTimedRect::Compare);
sl@0: 		if (KErrNone == error)
sl@0: 	   		{
sl@0: 			if (iScheduled)
sl@0: 				{
sl@0: 				if (then < iNext)
sl@0: 					{
sl@0: 					iNext = then;
sl@0: 					}
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				iNext = then;
sl@0: 				iScheduled = ETrue;
sl@0: 				}
sl@0: 			// remove further futures that are completely contained
sl@0: 			TInt count = iTimedDrawRect.Count();
sl@0: 			for(TInt i=0; i<count; i++)
sl@0: 				{
sl@0: 				const TTimedRect& future = iTimedDrawRect[i];
sl@0: 				if(future.iTime.Int64() > then.Int64())
sl@0: 					{
sl@0: 					TRect rect(aRect);
sl@0: 					rect.BoundingRect(future.iRect);
sl@0: 					if(rect == aRect) // future is completely contained within aRect
sl@0: 						{
sl@0: 						iTimedDrawRect.Remove(i);
sl@0: 						count--;
sl@0: 						i--;
sl@0: 						}
sl@0: 					}
sl@0: 				}
sl@0: 			CWsTop::WindowServer()->AnimationScheduler()->ScheduleAnimation(iScreen,iNext);
sl@0: 
sl@0: 			// Blue rectangles for scheduled animations
sl@0: 			DEBUG_RECT(TRgb(0x00, 0x00, 0xFF),TRgb(0x00, 0x00, 0xFF, 0x20),&aRect);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // This adds a region to the stored invalid region.
sl@0: // The invalid region is the area of the screen that needs to be redrawn in addition to any animations.
sl@0: // The draw region is the area of the screen on which only the top window needs to be redrawn.
sl@0: // If the top window has transparency, this can only be true when it has been made newly visible.
sl@0: // The value of aSchedule could be determined automatically from iAnimating, but passing it this way
sl@0: // allows us to have the assert, which is a very valuable assert.
sl@0: void CScreenRedraw::AddRedrawRegion(const TRegion& aRegion, TBool aSchedule, TRedrawDepth aDepth)
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(!iAnimating || !aSchedule, EWsPanicScheduledRedraw);
sl@0: 	
sl@0: 	if(aRegion.CheckError())
sl@0: 		{
sl@0: 		iInvalid.ForceError();
sl@0: 
sl@0: 		if (aSchedule)
sl@0: 			ScheduleRedraw();
sl@0: 		}
sl@0: 	else if(aRegion.Count()) // often called despite window not being visible
sl@0: 		{
sl@0: 		if (aDepth == ERedrawAll)
sl@0: 			{
sl@0: 			// red lines for an invalid region which is ready to be drawn
sl@0: 			DEBUG_REGION(TRgb(0xFF, 0x00, 0x00),TRgb(0xFF, 0x00, 0x00, 0x20),&aRegion);
sl@0: 				
sl@0: 			iInvalid.Union(aRegion);
sl@0: 			
sl@0: 			if (aSchedule)
sl@0: 				ScheduleRedraw();
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			// yellow lines for a valid region which we will draw on top of
sl@0: 			DEBUG_REGION(TRgb(0xFF, 0xFF, 0x00),TRgb(0xFF, 0xFF, 0x00, 0x20),&aRegion);
sl@0: 				
sl@0: 			iTopLayer.Union(aRegion);
sl@0: 			
sl@0: 			if (aSchedule)
sl@0: 				ScheduleRedraw();			
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // This causes any asynchronously scheduled redraw to happen immediately
sl@0: // It should be avoided where possible for performance reasons, but is 
sl@0: // needed whenever the redraw store is discarded for a window which still
sl@0: // has a redraw region pending.
sl@0: void CScreenRedraw::DoRedrawNow()
sl@0: 	{
sl@0: 	if(!iAnimating)
sl@0: 		CWsTop::WindowServer()->AnimationScheduler()->DoRedrawNow(iScreen);
sl@0: 	}
sl@0: 	
sl@0: #ifdef USE_DEBUG_REGIONS
sl@0: void CScreenRedraw::DebugRect(TRgb aColor, TRgb aFill, const TRect* aRect)
sl@0: 	{
sl@0: 	if (aRect)
sl@0: 		{
sl@0: 		CFbsBitGc * gc = iScreen.GetBitGc();
sl@0: 		gc->SetPenColor(aColor);
sl@0: 		gc->SetPenStyle(CGraphicsContext::ESolidPen);
sl@0: 		gc->SetPenSize(TSize(2,2));
sl@0: 		gc->SetBrushColor(aFill);
sl@0: 		gc->SetBrushStyle(CGraphicsContext::ESolidBrush);
sl@0: 		TRect smaller = *aRect;
sl@0: 		smaller.iBr.iX -= 1;
sl@0: 		smaller.iBr.iY -= 1;
sl@0: 		gc->DrawRect(smaller);
sl@0: 		iScreen.Update();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CScreenRedraw::DebugRegion(TRgb aColor, TRgb aFill, const TRegion * aRegion)
sl@0: 	{
sl@0: 	if (aRegion)
sl@0: 		{
sl@0: 		CFbsBitGc * gc = iScreen.GetBitGc();
sl@0: 		gc->SetPenColor(aColor);
sl@0: 		gc->SetPenStyle(CGraphicsContext::ESolidPen);
sl@0: 		gc->SetPenSize(TSize(2,2));
sl@0: 		gc->SetBrushColor(aFill);
sl@0: 		gc->SetBrushStyle(CGraphicsContext::ESolidBrush);
sl@0: 		for (const TRect *rect = aRegion->RectangleList(); rect - aRegion->RectangleList() < aRegion->Count(); ++rect)
sl@0: 			{
sl@0: 			TRect smaller = *rect;
sl@0: 			smaller.iBr.iX -= 1;
sl@0: 			smaller.iBr.iY -= 1;
sl@0: 			gc->DrawRect(smaller);
sl@0: 			}
sl@0: 		iScreen.Update();
sl@0: 		}
sl@0: 	}
sl@0: #endif 
sl@0: 
sl@0: void CScreenRedraw::OnAnimation()
sl@0: 	{
sl@0: 	LOG_SCREEN_REDRAW_START
sl@0: 	ASSERT(!iAnimating);
sl@0: 	ASSERT(iScheduled);
sl@0: 	iAnimating = ETrue;
sl@0: 	iScheduled = EFalse;
sl@0: 	TBool futureAnimationRequired = EFalse;	
sl@0: 
sl@0: 	CWsActiveScheduler::Static()->PrepareDraw();
sl@0: 	
sl@0: 	// Calculate any updates required by region changes:
sl@0: 	RegionUpdate();
sl@0: 
sl@0: 	// Add the timed rectangles to the invalid region:
sl@0: 	iNow.UniversalTime();
sl@0: 	TInt count(iTimedDrawRect.Count());
sl@0: 	while (0 < count)
sl@0: 		{
sl@0: 		if(iTimedDrawRect[0].iTime.Int64() <= iNow.Int64())
sl@0: 			{
sl@0: 			iInvalid.AddRect(iTimedDrawRect[0].iRect);
sl@0: 			iTimedDrawRect.Remove(0);
sl@0: 			count--;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			futureAnimationRequired = ETrue;	
sl@0: 			break;
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	// Animating rectangles could cause iInvalid to overlap iTopLayer,
sl@0: 	// in which case iTopLayer won't work.
sl@0: 	iTopLayer.SubRegion(iInvalid);
sl@0: 	iTopLayer.Intersect(iScreen.RootWindow()->WindowArea());
sl@0: 	iTopLayer.Tidy();
sl@0: 	// Anything in the top layer is implcitly invalid
sl@0: 	iInvalid.Union(iTopLayer);
sl@0: 	iInvalid.Intersect(iScreen.RootWindow()->WindowArea());
sl@0: 	
sl@0: /*
sl@0: 	if (const CDebugBar* dbg = iScreen.DebugBar())
sl@0: 		{
sl@0: 		iTopLayer.SubRect(dbg->Rect());
sl@0: 		iInvalid.SubRect(dbg->Rect());
sl@0: 		}
sl@0: */
sl@0: 
sl@0: 	iInvalid.Tidy();
sl@0: 
sl@0: 	if(iInvalid.CheckError()) //Will: agree with Andy, want bounding rects instead!
sl@0: 		{
sl@0: 		iTopLayer.Clear();
sl@0: 		iInvalid.Clear();
sl@0: 		iInvalid.Copy(iScreen.RootWindow()->WindowArea()); // assumed cannot fail, all regions can contain at least 1 rect..
sl@0: 		}
sl@0: 
sl@0: 	iInvalid.SubRegion( iBannedRegion );	
sl@0: 	iInvalid.Tidy();
sl@0: 	iTopLayer.SubRegion( iBannedRegion );
sl@0: 	iTopLayer.Tidy();
sl@0: 	
sl@0: 	STACK_REGION invalidCopy;
sl@0: 	invalidCopy.Copy(iInvalid);
sl@0: 	TWalkWindowTreeScheduleRegions regionScheduler(&invalidCopy, iTopLayer);
sl@0: 	TWalkWindowTreeScheduleFallback fallbackScheduler(iScreen.FallbackMap());
sl@0: 	TWalkWindowTreeSchedule * scheduler = &regionScheduler;
sl@0: 	
sl@0: 	// At this point, if the DEBUG_REGION is being used:
sl@0: 	// Red represents invalid regions that need to be redrawn completely.
sl@0: 	// Yellow represents regions that only need the top window to be drawn.
sl@0: 	// Blue represents regions which are being animated server side.
sl@0: 	if (iRenderScheduled || !iInvalid.IsEmpty())
sl@0: 		{
sl@0: 		iRenderScheduled = EFalse;
sl@0: 		// invalidCopy.ForceError(); //### DEBUG
sl@0: 		
sl@0: 		iScreen.RootWindow()->WalkWindowTree(regionScheduler,EWalkChildren);
sl@0: 		if (!regionScheduler.ScheduledRegionsOk())
sl@0: 			{
sl@0: 			// our region calculations for what to draw failed at some point.
sl@0: 			// From this point on we MUST NOT rely on allocating memory
sl@0: 			// Andy - localRedrawRegion allocates
sl@0: 			// Andy - setPenSize allocates (even if you don't call it)
sl@0: 			// Andy - all draw commands add to a gdi dirty region (which allocates)
sl@0: 			// Andy - combining client clipping regions with window clipping regions allocates
sl@0: 			scheduler = &fallbackScheduler;
sl@0: 			iScreen.FallbackMap()->Prepare();
sl@0: 			iScreen.RootWindow()->WalkWindowTree(fallbackScheduler,EWalkChildren);
sl@0: 			}
sl@0: 		
sl@0: 		CWsActiveScheduler::Static()->StartDraw();
sl@0: 		CWsMemoryManager::Static()->EnableReserve();
sl@0: 
sl@0: 		if (&fallbackScheduler == scheduler)
sl@0: 			iAnimationRegion = iScreen.FallbackMap()->Region();
sl@0: 		else
sl@0: 			iAnimationRegion = &iInvalid;
sl@0: 		
sl@0: 		// Redraw debug regions more brightly than before:
sl@0: 		DEBUG_REGION(TRgb(0xFF, 0x00, 0x00),TRgb(0xFF, 0x00, 0x00, 0x80),&iInvalid);
sl@0: 		DEBUG_REGION(TRgb(0xFF, 0xFF, 0x00),TRgb(0xFF, 0xFF, 0x00, 0x80),&iTopLayer);
sl@0: 		
sl@0: 		RWsRegion accumulatedDrawing;
sl@0: 		
sl@0: 		// Pipe the drawing into the first render stage:
sl@0: 		CFbsBitGc * stageGc = iRenderStages->Begin();
sl@0: 		
sl@0: 		for (CWsWindow * win = scheduler->HeadWindow(); win; win = win->NextScheduled())
sl@0: 			{
sl@0: 			const TRegion * targetRegion = scheduler->Region(win);
sl@0: 			const TRect * screenRect = 0;
sl@0: 			if ((&fallbackScheduler == scheduler) && !targetRegion->IsContainedBy(iScreen.RootWindow()->Abs()))
sl@0: 				{
sl@0: 				screenRect = &iScreen.RootWindow()->Abs();
sl@0: 				}
sl@0: 			if (!screenRect)
sl@0: 				{
sl@0: 				// Purple regions are about to be drawn
sl@0: 				DEBUG_REGION(TRgb(0x80, 0x00, 0x80),TRgb(0x80, 0x00, 0x80, 0x80),targetRegion);
sl@0: 				// Do the drawing
sl@0: 				stageGc->Reset();
sl@0: 				win->Render(stageGc, *targetRegion);
sl@0: 				accumulatedDrawing.Union(*targetRegion);
sl@0: 				// Green regions have been drawn
sl@0: 				DEBUG_REGION(TRgb(0x00, 0xFF, 0x00),TRgb(0x00, 0xFF, 0x00, 0x80),targetRegion);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				// Our region overlaps the edges of the screen, and we have no memory
sl@0: 				// to create a clipped one, so we will use a single-rect region for each rect
sl@0: 				// and call Draw multiple times.
sl@0: 				TRegionFix<1> rectRegion;
sl@0: 				for (const TRect * rect = targetRegion->RectangleList() + targetRegion->Count() - 1; rect >= targetRegion->RectangleList(); --rect)
sl@0: 					{
sl@0: 					rectRegion.Clear();
sl@0: 					TRect combined(*screenRect);
sl@0: 					combined.Intersection(*rect);
sl@0: 					rectRegion.AddRect(combined);
sl@0: 					// Purple regions are about to be drawn
sl@0: 					DEBUG_REGION(TRgb(0x80, 0x00, 0x80),TRgb(0x80, 0x00, 0x80, 0x80),&rectRegion);
sl@0: 					// Do the drawing
sl@0: 					stageGc->Reset();
sl@0: 					win->Render(stageGc, rectRegion);
sl@0: 					accumulatedDrawing.AddRect(combined);
sl@0: 					// Green regions have been drawn
sl@0: 					DEBUG_REGION(TRgb(0x00, 0xFF, 0x00),TRgb(0x00, 0xFF, 0x00, 0x80),&rectRegion);
sl@0: 					}
sl@0: 				}
sl@0: 			DEBUGOSB
sl@0: 			}
sl@0: 
sl@0: 		DEBUGOSB			
sl@0: 		iScreen.SpriteManager()->DrawFloatingSprites(stageGc,accumulatedDrawing); // we limit sprite drawing over only actually affected ares but necessary to all "planned" for redraw
sl@0: 		if (!accumulatedDrawing.CheckError() && iScreen.SpriteManager()->SpriteCount() == 0)
sl@0: 			{
sl@0: 			iAnimationRegion = &accumulatedDrawing;
sl@0: 			}
sl@0: 
sl@0: 		// Tell the render stage we've finished:
sl@0: 		iRenderStages->End();
sl@0: 		
sl@0: 		// We nolonger need the regions
sl@0: 		for (CWsWindow * win = scheduler->HeadWindow(); win; win = win->NextScheduled())
sl@0: 			{
sl@0: 			win->ClearScheduledRegion();
sl@0: 			}
sl@0: 			
sl@0: 		CWsMemoryManager::Static()->DisableReserve();
sl@0: 
sl@0: 		if (const CDebugBar* dbg = iScreen.DebugBar())
sl@0: 			{
sl@0: 			dbg->RedrawDebugBar();
sl@0: 			}
sl@0: 
sl@0: 		// At this point, if the DEBUG_REGION is being used, there should usually be only green regions
sl@0: 		// displayed.  If we see red or yellow, then something didn't get redrawn that should have been.
sl@0: 		// If we see purple then a window has disobeyed the const setting on the region to draw.
sl@0: 		// Red or yellow is valid - a window can decide it isn't ready to draw yet - purple is very bad.
sl@0: 		iScreen.Update();
sl@0: 		// At this point, if the DEBUG_REGION is being used, there should be no regions visible
sl@0: 		// of any colour.  If we see green, then it means an area of the screen was drawn to which
sl@0: 		// wasn't invalid, or the screen update call failed.  The former is more likely.
sl@0: 		// If we still see red or yellow it is a region that is not yet ready to draw.
sl@0: 
sl@0: 		const TRect* rect = iAnimationRegion->RectangleList();
sl@0: 		TInt pixels = 0;
sl@0: 		for(TInt r = iAnimationRegion->Count(); r>0; r--)
sl@0: 			{
sl@0: 			pixels += (rect->Width()*rect->Height());
sl@0: 			rect++;
sl@0: 			}
sl@0: 		CWsActiveScheduler::Static()->StopDraw(pixels);
sl@0: 		
sl@0: 		TWindowServerEvent::NotifyScreenDrawingEvent(iAnimationRegion);
sl@0: 
sl@0: 		iAnimationRegion = 0;
sl@0: 		accumulatedDrawing.Close();
sl@0: 		iInvalid.Clear();
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		CWsActiveScheduler::Static()->CancelPrepare();
sl@0: 		}
sl@0: 
sl@0: 	iInvalid.Clear();
sl@0: 	iTopLayer.Clear();
sl@0: 	invalidCopy.Close();
sl@0: 	iAnimating = EFalse;
sl@0: 	
sl@0: 	if (futureAnimationRequired && iTimedDrawRect.Count() > 0 && !iScheduled)
sl@0: 		{
sl@0: 		// If this flag is set then it means there were already some animations scheduled when we ran,
sl@0: 		// but they themselves didn't run.  We need to make sure we have _something_ scheduled.
sl@0: 		CWsTop::WindowServer()->AnimationScheduler()->ScheduleAnimation(iScreen, iTimedDrawRect[0].iTime);
sl@0: 		iScheduled = ETrue;
sl@0: 		}
sl@0: 	
sl@0: 	if(iObserver)
sl@0: 		{
sl@0: 		iObserver->ScreenUpdated(iScreen.ScreenNumber());
sl@0: 		iObserver=NULL; //once signalled we are never going to call it again
sl@0: 		}
sl@0: 	LOG_SCREEN_REDRAW_END
sl@0: 	}
sl@0: 
sl@0: //
sl@0: void CScreenRedraw::DiscardAllSchedules()
sl@0: 	{
sl@0: 	ASSERT(!iAnimating);
sl@0: 	
sl@0: 	iTimedDrawRect.Reset();
sl@0: 	iInvalid.Clear();
sl@0: 	iInvalid.Tidy();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Indicates that a window has moved or changed ordinal position so that the visible regions
sl@0: of all windows needs to be recalculated
sl@0: */
sl@0: void CScreenRedraw::ScheduleRegionUpdate(const TRegion* aDefinitelyDirty)
sl@0: 	{
sl@0: 	iRegionUpdateScheduled = ETrue;
sl@0: 	ScheduleRedraw();
sl@0: 	if(aDefinitelyDirty)
sl@0: 		{
sl@0: 		iInvalid.Union(*aDefinitelyDirty);
sl@0: 		// Cyan regions for invalidations caused by this:
sl@0: 		DEBUG_REGION(TRgb(0x00, 0xFF, 0xFF),TRgb(0x00, 0xFF, 0xFF, 0x20),aDefinitelyDirty);
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: Recalculates visible regions and schedules redraws or queues redraw events in response to
sl@0: any changes
sl@0: */
sl@0: void CScreenRedraw::RegionUpdate()
sl@0: 	{
sl@0: 	if (iRegionUpdateScheduled)
sl@0: 		{
sl@0: 		iRegionUpdateScheduled = EFalse;
sl@0: 		
sl@0: 		TWalkWindowTreeUpdateRegions updater(iScreen);
sl@0: 		updater.Walk();
sl@0: 
sl@0: 		WsPointer::ReLogCurrentWindow();
sl@0: 		CWsTop::TriggerRedraws(iScreen.RootWindow());
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CScreenRedraw::SetObserver(MWsScreenRedrawObserver* aObserver)
sl@0: 	{
sl@0: 	iObserver = aObserver;
sl@0: 	}
sl@0: 
sl@0: TBool CScreenRedraw::IsUpdatePending()
sl@0: 	{
sl@0: 	if(iScheduled || iAnimating)
sl@0: 		return ETrue;
sl@0: 	else 
sl@0: 		return EFalse;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Overidding MWsObjectProvider
sl@0: */
sl@0: TAny* CScreenRedraw::ResolveObjectInterface(TUint aTypeId)
sl@0: 	{
sl@0: 	TAny* interface = NULL;
sl@0: 
sl@0: 	switch (aTypeId)
sl@0: 		{
sl@0: 		case KWsScreenRedraw:
sl@0: 			interface = static_cast<MWsScreenRedraw*>(this);
sl@0: 			break;
sl@0: 		}
sl@0: 
sl@0: 	if (!interface)
sl@0: 		{
sl@0: 		interface = iRenderStages->ResolveObjectInterface(aTypeId);
sl@0: 		}
sl@0: 	
sl@0: 	return interface;
sl@0: 	}
sl@0: 
sl@0: const TRegion * CScreenRedraw::AnimationRegion() const
sl@0: 	{
sl@0: 	if (iAnimating)
sl@0: 		return iAnimationRegion;
sl@0: 	else
sl@0: 		return 0;
sl@0: 	}
sl@0: 
sl@0: void CScreenRedraw::UpdateDevice()
sl@0: 	{
sl@0: 	iScreen.Update();
sl@0: 	}
sl@0: 
sl@0: void CScreenRedraw::BanThisRegionUpdate( TRegion& aForbiddenRegion )
sl@0: 	{
sl@0: 	iBannedRegion.Union( aForbiddenRegion );
sl@0: 	iBannedRegion.Tidy();
sl@0: 	}
sl@0: 
sl@0: void CScreenRedraw::LiftRegionUpdateBan( TRegion& aFormerForbiddenRegion  )
sl@0: 	{
sl@0: 	iBannedRegion.SubRegion( aFormerForbiddenRegion );
sl@0: 	iBannedRegion.Tidy();
sl@0: 	}
sl@0: 
sl@0: void CScreenRedraw::AcceptFadeRequest( CWsWindow* aWin, TBool aFadeOn, TBool aFadeBehind, TBool aIncludeChildren )
sl@0: 	{
sl@0: 	if ( aFadeOn )
sl@0: 		{
sl@0: 		TWalkWindowTreeScheduleFadeNoRedraw walkerFadeNoRedraw;
sl@0: 		if ( aFadeBehind )
sl@0: 			{
sl@0: 			aWin->WalkWindowTree( walkerFadeNoRedraw, EWalkBehind );				
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			if(aWin->WinType() != EWinTypeGroup)
sl@0: 				{
sl@0: 				ScheduleRegionUpdate( aWin->VisibleRegionIfValid() );
sl@0: 				}
sl@0: 			
sl@0: 			if ( aIncludeChildren )
sl@0: 				{
sl@0: 				aWin->WalkWindowTree( walkerFadeNoRedraw, EWalkChildren );
sl@0: 				}				
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{	// fade off, just initiate redraw
sl@0: 		TWalkWindowTreeScheduleRedraws walkerRedraw( TWalkWindowTreeScheduleRedraws::ERedrawFilterOmitDSA ) ;
sl@0: 		if ( aFadeBehind )
sl@0: 			{
sl@0: 			aWin->WalkWindowTree( walkerRedraw, EWalkBehind );								
sl@0: 			}
sl@0: 		else
sl@0: 			{ // fade this win not behind
sl@0: 			if ( !aWin->IsDSAHost() )
sl@0: 				{
sl@0: 				AddRedrawRegion( aWin->VisibleRegion() );
sl@0: 				}
sl@0: 			if ( aIncludeChildren )
sl@0: 				{
sl@0: 				aWin->WalkWindowTree( walkerRedraw, EWalkChildren );
sl@0: 				}				
sl@0: 			}			
sl@0: 		}		
sl@0: 	ScheduleRegionUpdate(NULL);
sl@0: 	}