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

			{