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

	}