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

 // SCREEN_REDRAW.CPP

 // 

 //

 #include "ScreenRedraw.h"

 #include <hal.h>

 #include "debugbar.h"

 #include "screen.h"

 #include "inifile.h"

 #include "offscreenbitmap.h"

 #include "wspluginmanager.h"

 #include "pointer.h"

 #include "rootwin.h"

 #include "walkwindowtree.h"

 #include "wstop.h"

 #include "WsMemMgr.h"

 #include "Graphics/WsRenderStageFactory.h"

 #include "Graphics/WsRenderStage.h"

 #include "EVENT.H"

 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

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

 #	define DEBUGOSB { CWsOffScreenBitmap * ofb = iScreen.OffScreenBitmap(); if (ofb) ofb->Update(); }

 #else

 #	define DEBUGOSB

 #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

 CScreenRedraw::TTimedRect::TTimedRect(const TRect& aRect, const TTime& aTime):

 	iRect(aRect), iTime(aTime)

 	{

 	}

 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()

 	{

 	CWsRenderStage * stage = iRenderStages;

 	while (stage!=NULL)

    		{

 		CWsRenderStage *next=stage->Next();

    		delete stage;

 		stage=next;

    		}

 	iTimedDrawRect.Close();

 	iInvalid.Close();

 	iTopLayer.Close();

 	iBannedRegion.Close();	

 	}

 void CScreenRedraw::ConstructL()

 	{

 	CWsPluginManager * pluginMgr = CWsTop::WindowServer()->PluginManager();

 	// Setup the render stages for this screen:

 	_LIT(KDefaultRenderStages, "std");

 	_LIT(KDefaultFlickerFreeRenderStages, "flickerbuffer std");

 	_LIT(KRenderStages,"RENDERSTAGES");

 	TPtrC stagesString;

 	const TBool customStages = WsIniFile->FindVar(iScreen.ScreenNumber(),KRenderStages,stagesString);

 	// If noone specifies stages for this screen, assume the standard implementation:

 	const TDesC * stages;

 	if (customStages)

 		stages = &stagesString;

 	else if (iScreen.OffScreenBitmap())

 		stages = &KDefaultFlickerFreeRenderStages();

 	else

 		stages = &KDefaultRenderStages();

 	CWsRenderStage * lastStage = 0;

 	// Parse the string for implementation IDs:

 	TLex lex(*stages);

 	while(true)

 		{

 		TPtrC ptr = lex.NextToken();

 		if (ptr.Length() > 0)

 			{

 			TInt err = KErrNone;

 			MWsRenderStageFactory * factory = pluginMgr->FindNamedImplementation<MWsRenderStageFactory>(ptr);

 			if (factory)

 				{

 				CWsRenderStage * stage = 0;

 				TRAP(err, stage = factory->CreateStageL(static_cast<MWsScreen*>(&iScreen), this));

 				if (err == KErrNone)

 					{

 					if (!stage)

 						{

 						err = KErrNotFound;

 						}

 					else

 						{

 						if (lastStage)

 							lastStage->SetNext(stage);

 						else

 							iRenderStages = stage;

 						lastStage = stage;

 						}

 					}

 				}

 			else

 				{

 				err = KErrNotFound;

 				}

 			if (wsDebugLog)

 				{

 				TBuf<64> buf;

 				if (err == KErrNone)

 					{

 					_LIT(KAddedRenderStage,"Added render stage: ");

 					buf.Append(KAddedRenderStage);

 					buf.Append(ptr);

 					wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant,buf);

 					}

 				else

 					{

 					_LIT(KMissingRenderStage,"Failed to add render stage (%d): ");

 					buf.Append(KMissingRenderStage);

 					buf.Append(ptr);

 					wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant,buf,err);

 					}

 				}

 			}

 		else

 			{

 			break;

 			}

 		}

 	}

 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.

 	MWsAnimationScheduler* animSched=CWsTop::WindowServer()->AnimationScheduler();

 	if (animSched)

 		{

 		animSched->ScheduleRedraw(iScreen,iNext);

 		}

 	}

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

 	{

 	TRect test(aRect);

 	test.Intersection(iScreen.DrawableArea());

 	if(!test.IsEmpty())

 		{

 		const TTime then(Now() + aFromNow);

 		TTimedRect tRect(aRect, then);

 		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.iTime.Int64() > then.Int64())

 					{

 					TRect rect(aRect);

 					rect.BoundingRect(future.iRect);

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

 						{

 						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);

 			}

 		}

 	}

 // 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);

 			iTopLayer.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.

 void CScreenRedraw::DoRedrawNow()

 	{

 	if(!iAnimating)

 		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()

 	{

 	LOG_SCREEN_REDRAW_START

 	ASSERT(!iAnimating);

 	ASSERT(iScheduled);

 	iAnimating = ETrue;

 	iScheduled = EFalse;

 	TBool futureAnimationRequired = EFalse;	

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

 	// Calculate any updates required by region changes:

 	RegionUpdate();

 	// Add the timed rectangles to the invalid region:

 	iNow.UniversalTime();

 	TInt count(iTimedDrawRect.Count());

 	while (0 < count)

 		{

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

 			{

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

 			iTimedDrawRect.Remove(0);

 			count--;

 			}

 		else

 			{

 			futureAnimationRequired = ETrue;	

 			break;

 			}

 		}

 	// Animating rectangles could cause iInvalid to overlap iTopLayer,

 	// in which case iTopLayer won't work.

 	iTopLayer.SubRegion(iInvalid);

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

 	iTopLayer.Tidy();

 	// Anything in the top layer is implcitly invalid

 	iInvalid.Union(iTopLayer);

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

 /*

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

 		{

 		iTopLayer.SubRect(dbg->Rect());

 		iInvalid.SubRect(dbg->Rect());

 		}

 */

 	iInvalid.Tidy();

 	if(iInvalid.CheckError()) //Will: agree with Andy, want bounding rects instead!

 		{

 		iTopLayer.Clear();

 		iInvalid.Clear();

 		iInvalid.Copy(iScreen.RootWindow()->WindowArea()); // assumed cannot fail, all regions can contain at least 1 rect..

 		}

 	iInvalid.SubRegion( iBannedRegion );	

 	iInvalid.Tidy();

 	iTopLayer.SubRegion( iBannedRegion );

 	iTopLayer.Tidy();

 	STACK_REGION invalidCopy;

 	invalidCopy.Copy(iInvalid);

 	TWalkWindowTreeScheduleRegions regionScheduler(&invalidCopy, iTopLayer);

 	TWalkWindowTreeScheduleFallback fallbackScheduler(iScreen.FallbackMap());

 	TWalkWindowTreeSchedule * scheduler = &regionScheduler;

 	// 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())

 		{

 		iRenderScheduled = EFalse;

 		// invalidCopy.ForceError(); //### DEBUG

 		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

 			// Andy - localRedrawRegion allocates

 			// Andy - setPenSize allocates (even if you don't call it)

 			// Andy - all draw commands add to a gdi dirty region (which allocates)

 			// Andy - combining client clipping regions with window clipping regions allocates

 			scheduler = &fallbackScheduler;

 			iScreen.FallbackMap()->Prepare();

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

 			}

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

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

 		if (&fallbackScheduler == scheduler)

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

 		else

 			iAnimationRegion = &iInvalid;

 		// Redraw debug regions more brightly than before:

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

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

 		RWsRegion accumulatedDrawing;

 		// Pipe the drawing into the first render stage:

 		CFbsBitGc * stageGc = iRenderStages->Begin();

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

 			{

 			const TRegion * targetRegion = scheduler->Region(win);

 			const TRect * screenRect = 0;

 			if ((&fallbackScheduler == scheduler) && !targetRegion->IsContainedBy(iScreen.RootWindow()->Abs()))

 				{

 				screenRect = &iScreen.RootWindow()->Abs();

 				}

 			if (!screenRect)

 				{

 				// Purple regions are about to be drawn

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

 				// Do the drawing

 				stageGc->Reset();

 				win->Render(stageGc, *targetRegion);

 				accumulatedDrawing.Union(*targetRegion);

 				// Green regions have been drawn

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

 				}

 			else

 				{

 				// Our region overlaps the edges of the screen, and we have no memory

 				// to create a clipped one, so we will use a single-rect region for each rect

 				// and call Draw multiple times.

 				TRegionFix<1> rectRegion;

 				for (const TRect * rect = targetRegion->RectangleList() + targetRegion->Count() - 1; rect >= targetRegion->RectangleList(); --rect)

 					{

 					rectRegion.Clear();

 					TRect combined(*screenRect);

 					combined.Intersection(*rect);

 					rectRegion.AddRect(combined);

 					// Purple regions are about to be drawn

 					DEBUG_REGION(TRgb(0x80, 0x00, 0x80),TRgb(0x80, 0x00, 0x80, 0x80),&rectRegion);

 					// Do the drawing

 					stageGc->Reset();

 					win->Render(stageGc, rectRegion);

 					accumulatedDrawing.AddRect(combined);

 					// Green regions have been drawn

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

 					}

 				}

 			DEBUGOSB

 			}

 		DEBUGOSB			

 		iScreen.SpriteManager()->DrawFloatingSprites(stageGc,accumulatedDrawing); // we limit sprite drawing over only actually affected ares but necessary to all "planned" for redraw

 		if (!accumulatedDrawing.CheckError() && iScreen.SpriteManager()->SpriteCount() == 0)

 			{

 			iAnimationRegion = &accumulatedDrawing;

 			}

 		// Tell the render stage we've finished:

 		iRenderStages->End();

 		// We nolonger need the regions

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

 			{

 			win->ClearScheduledRegion();

 			}

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

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

 			{

 			dbg->RedrawDebugBar();

 			}

 		// 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 = 0;

 		accumulatedDrawing.Close();

 		iInvalid.Clear();

 		}

 	else

 		{

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

 		}

 	iInvalid.Clear();

 	iTopLayer.Clear();

 	invalidCopy.Close();

 	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::DiscardAllSchedules()

 	{

 	ASSERT(!iAnimating);

 	iTimedDrawRect.Reset();

 	iInvalid.Clear();

 	iInvalid.Tidy();

 	}

 /**

 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)

 	{

 	iRegionUpdateScheduled = ETrue;

 	ScheduleRedraw();

 	if(aDefinitelyDirty)

 		{

 		iInvalid.Union(*aDefinitelyDirty);

 		// Cyan regions for invalidations caused by this:

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

 		}

 	}

 /**

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

 any changes

 */

 void CScreenRedraw::RegionUpdate()

 	{

 	if (iRegionUpdateScheduled)

 		{

 		iRegionUpdateScheduled = EFalse;

 		TWalkWindowTreeUpdateRegions updater(iScreen);

 		updater.Walk();

 		WsPointer::ReLogCurrentWindow();

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

 		}

 	}

 void CScreenRedraw::SetObserver(MWsScreenRedrawObserver* aObserver)

 	{

 	iObserver = aObserver;

 	}

 TBool CScreenRedraw::IsUpdatePending()

 	{

 	if(iScheduled || iAnimating)

 		return ETrue;

 	else 

 		return EFalse;

 	}

 /**

  Overidding MWsObjectProvider

 */

 TAny* CScreenRedraw::ResolveObjectInterface(TUint aTypeId)

 	{

 	TAny* interface = NULL;

 	switch (aTypeId)

 		{

 		case KWsScreenRedraw:

 			interface = static_cast<MWsScreenRedraw*>(this);

 			break;

 		}

 	if (!interface)

 		{

 		interface = iRenderStages->ResolveObjectInterface(aTypeId);

 		}

 	return interface;

 	}

 const TRegion * CScreenRedraw::AnimationRegion() const

 	{

 	if (iAnimating)

 		return iAnimationRegion;

 	else

 		return 0;

 	}

 void CScreenRedraw::UpdateDevice()

 	{

 	iScreen.Update();

 	}

 void CScreenRedraw::BanThisRegionUpdate( TRegion& aForbiddenRegion )

 	{

 	iBannedRegion.Union( aForbiddenRegion );

 	iBannedRegion.Tidy();

 	}

 void CScreenRedraw::LiftRegionUpdateBan( TRegion& aFormerForbiddenRegion  )

 	{

 	iBannedRegion.SubRegion( aFormerForbiddenRegion );

 	iBannedRegion.Tidy();

 	}

 void CScreenRedraw::AcceptFadeRequest( CWsWindow* aWin, TBool aFadeOn, TBool aFadeBehind, TBool aIncludeChildren )

 	{

 	if ( aFadeOn )

 		{

 		TWalkWindowTreeScheduleFadeNoRedraw walkerFadeNoRedraw;

 		if ( aFadeBehind )

 			{

 			aWin->WalkWindowTree( walkerFadeNoRedraw, EWalkBehind );				

 			}

 		else

 			{

 			if(aWin->WinType() != EWinTypeGroup)

 				{

 				ScheduleRegionUpdate( aWin->VisibleRegionIfValid() );

 				}

 			if ( aIncludeChildren )

 				{

 				aWin->WalkWindowTree( walkerFadeNoRedraw, EWalkChildren );

 				}				

 			}

 		}

 	else

 		{	// fade off, just initiate redraw

 		TWalkWindowTreeScheduleRedraws walkerRedraw( TWalkWindowTreeScheduleRedraws::ERedrawFilterOmitDSA ) ;

 		if ( aFadeBehind )

 			{

 			aWin->WalkWindowTree( walkerRedraw, EWalkBehind );								

 			}

 		else

 			{ // fade this win not behind

 			if ( !aWin->IsDSAHost() )

 				{

 				AddRedrawRegion( aWin->VisibleRegion() );

 				}

 			if ( aIncludeChildren )

 				{

 				aWin->WalkWindowTree( walkerRedraw, EWalkChildren );

 				}				

 			}			

 		}		

 	ScheduleRegionUpdate(NULL);

 	}