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

// Window redraw code, three sorts of redrawing are supported

// CRedrawMsgWindow handles it via sending a redraw message to the client

// 

//

#include "redrawmsgwindow.h"

#include "gc.h"

#include "playbackgc.h"

#include "inifile.h"

#include "rootwin.h"

#include "wstop.h"

#include "ANIM.H"

#include "EVQUEUE.H"

#include <s32mem.h>

#include <gdi.h>

#include "panics.h"

#include "rootwin.h"

#include "EVENT.H"

#include "wsfont.h"

#include <Graphics/WSGRAPHICDRAWERINTERFACE.H>

#include <graphics/surface.h>

#include "windowelementset.h"

#include "drawresource.h"

#include "../debuglog/DEBUGLOG.H"

const TUint KDrawBufferGranularity = 240;

const TInt KRedrawRegionGranularity = 8;

const TInt KReadBufferMaxLen=0x100;

const TInt KRegionCompressThreshold = 6; // number of rectangles in region at which we try to compress it

TBool CWsRedrawMsgWindow::iAtomic = EFalse;

extern CDebugLogBase *wsDebugLog;

#ifndef _DEBUG

#define LOG_WINDOW_DRAW_COMMANDS_START(wswin,region)

#define LOG_WINDOW_DRAW_COMMANDS_END(wswin)

#define LOG_REDRAW_SEGMENT(segmentIndex,segmentType)

#define LOG_REDRAW_SEGMENT_REGION(region)

#define LOG_PLAYBACK_GC_COMMAND(opcode,data)

#else

#define LOG_WINDOW_DRAW_COMMANDS_START(wswin,region) LogDrawCommandsStart(wswin,region)

#define LOG_WINDOW_DRAW_COMMANDS_END(wswin) LogDrawCommandsEnd(wswin)

#define LOG_REDRAW_SEGMENT(segmentIndex,segmentType) LogRedrawSegment(segmentIndex, segmentType)

#define LOG_REDRAW_SEGMENT_REGION(region) {if(wsDebugLog){ LogRegion(region);}}

#define LOG_PLAYBACK_GC_COMMAND(opcode,data)    {if (wsDebugLog) {wsDebugLog->Command(WS_HANDLE_GC, opcode, data, NULL);}}

LOCAL_C void LogRedrawSegment(TUint aSegmentIndex, CWsRedrawMsgWindow::TRedrawSegmentType aSegmentType)

	{

	if (wsDebugLog)

		{

		TBuf<LogTBufSize> log;

		TTruncateOverflow overflow;

		_LIT(KLogRedrawSegment, ">> CRedrawSegment[%d] ");

		log.AppendFormat(KLogRedrawSegment, &overflow, aSegmentIndex);

		_LIT(KLogRedrawSegmentPending, "Pending");

		_LIT(KLogRedrawSegmentRedraw, "Redraw");

		switch(aSegmentType)

			{

			case CWsRedrawMsgWindow::ESegmentTypePendingRedraw :

				log.AppendFormat(KLogRedrawSegmentPending, &overflow);

				break;

			case CWsRedrawMsgWindow::ESegmentTypeRedraw :

				log.AppendFormat(KLogRedrawSegmentRedraw, &overflow);

				break;

			default :

				{

				}

			}

		wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

		}

	}

LOCAL_C void LogDrawCommandsStart(const CWsWindow* aWsWin, const TRegion* aRegion)

	{

	if (wsDebugLog)

		{

		_LIT(KLogDrawCommandsStart, ">> CWsRedrawMsgWindow::DrawCommandsL() [%S][app %d] RWindow[%d]");

		const TDesC& clientName = aWsWin->WsOwner()->Client().FullName();

		TBuf<LogTBufSize> log;

		TTruncateOverflow overflow;

		log.AppendFormat(KLogDrawCommandsStart, &overflow, &clientName, aWsWin->WsOwner()->ConnectionHandle(), aWsWin->LogHandle());

		wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

		LogRegion(aRegion);

		}

	}

LOCAL_C void LogDrawCommandsEnd(const CWsWindow* aWsWin)

	{

	if (wsDebugLog)

		{

		_LIT(KLogDrawCommandsEnd, "<< CWsRedrawMsgWindow::DrawCommandsL() [%S][app %d] RWindow[%d]");

		const TDesC& clientName = aWsWin->WsOwner()->Client().FullName();

		TBuf<LogTBufSize> log;

		TTruncateOverflow overflow;

		log.AppendFormat(KLogDrawCommandsEnd, &overflow, &clientName, aWsWin->WsOwner()->ConnectionHandle(), aWsWin->LogHandle());		

		wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, log);

		}

	}

#endif

//

// Redraw windows //

//

CWsRedrawMsgWindow::CRedrawSegment::CRedrawSegment(CWsRedrawMsgWindow& aRedraw) : iRedraw(aRedraw) 

	{

	}

CWsRedrawMsgWindow::CRedrawSegment* CWsRedrawMsgWindow::CRedrawSegment::NewLC(const TRect& aRect, TRedrawSegmentType aNewRegionType, CWsRedrawMsgWindow& aRedraw) 

	{

	CRedrawSegment* self = new (ELeave) CRedrawSegment(aRedraw);

	CleanupStack::PushL(self);

	self->ConstructL(aRect, aNewRegionType);

	return self;

	}

void CWsRedrawMsgWindow::StaticInitL()

	{

	// Note that the wsini.ini setting NONREDRAWAGELIMIT is obselete in

	// Wserv2 NGA.  The effective behaviour of the system is as if the

	// value was set to zero.

	_LIT(KAtomicRedraws, "ATOMICREDRAWS");

	if (WsIniFile->FindVar(KAtomicRedraws) || 

			WsIniFile->FindVar(KWSERVIniFileVarChangeTracking)) //ChangeTracking requires atomic redraws to be enabled to

		iAtomic = ETrue;										//prevent playing redraw-segemts before they are completed.

	else

		iAtomic = EFalse;

	}

static TInt FindBitmapRefByHandle(const TInt* aKey, const CFbsBitmapRef& aBitmapRef)

    { // compare handles

    return *aKey - aBitmapRef.Handle();

    }

static TInt InsertBitmapRefByHandle(const CFbsBitmapRef& aFirst, const CFbsBitmapRef& aSecond)

    {

    return aFirst.Handle() - aSecond.Handle();

    }

void CWsRedrawMsgWindow::CRedrawSegment::ReleaseFontsBitmapsDrawableSources()

	{

	// release Bitmap, Font and Drawable Source handles

	TInt count = iWsBitmapArray.Count();

	TInt ii;

	for (ii = count - 1; ii >= 0; ii--)

		{

		iWsBitmapArray[ii]->DecRefCount();

		iWsBitmapArray.Remove(ii);

		}

	count = iWsFontArray.Count();

	for (ii = count - 1; ii >= 0; --ii)

		{

		CWsFontCache::Instance()->ReleaseFont(iWsFontArray[ii]);

		iWsFontArray.Remove(ii);

		}

	iRedraw.CleanupBitmapRefArray(iBitmapHandleArray);

	iBitmapHandleArray.Close();

	count = iWsDrawableSourceArray.Count();

	for(ii = count - 1 ; ii >= 0; ii--)

		{

		iWsDrawableSourceArray[ii]->DecRefCount();

		iWsDrawableSourceArray.Remove(ii);

		}

	}

/* Set new rectangle and region type for initial or reset redraw region

 @leave KErrNoMemory no memory to update region details

 */

void CWsRedrawMsgWindow::CRedrawSegment::ConstructL(const TRect& aRect, TRedrawSegmentType aNewRegionType)

	{

	iDrawCommands = CBufSeg::NewL(KDrawBufferGranularity);

	iCreationTime.UniversalTime();

	iRegion.AddRect(aRect);

	if (iRegion.CheckError())

		{

		User::Leave(KErrNoMemory);

		}

	iRedrawSegmentType = aNewRegionType;

	}

CWsRedrawMsgWindow::CRedrawSegment::~CRedrawSegment()

	{

	if (iDrawCommands)

		{

		delete iDrawCommands;

		}

	iRegion.Close();

	// Release Font,  Bitmap and Drawable Source handles, close arrays

	ReleaseFontsBitmapsDrawableSources();

	iWsBitmapArray.Close();

	iWsFontArray.Close();

	iDrawerArray.Close();	

	iWsDrawableSourceArray.Close();

	}

TInt CWsRedrawMsgWindow::CRedrawSegment::SizeInBytes() const

	{

	TInt size = sizeof(CWsRedrawMsgWindow::CRedrawSegment);

	size += iDrawCommands->Size();

	size += iBitmapHandleArray.Count() * sizeof(TInt);

	size += iWsBitmapArray.Count() * sizeof(DWsBitmap);

	size += iWsFontArray.Count() * sizeof(CWsFbsFont);

	size += iDrawerArray.Count() * sizeof(TGraphicDrawerId);

	size += iWsDrawableSourceArray.Count() * sizeof(CWsDrawableSource);

	return size;

	}

TBool CWsRedrawMsgWindow::CRedrawSegment::AppendNonDuplicateBitmapHandleL(TInt aHandle)

    {

    TBool handleAppend = EFalse;

    TInt indexBitmapHandle = iBitmapHandleArray.Find(aHandle);

    if (indexBitmapHandle<0)

        {

        iBitmapHandleArray.AppendL(aHandle);

        handleAppend = ETrue;

        }

    return handleAppend;

    }

CWsRedrawMsgWindow::CWsRedrawMsgWindow(CWsWindow *aWin)

	:CWsWindowRedraw(aWin), iBackColor(aWin->RootWindow()->DefaultBackgroundColor()), iFlags(EBackgroundClear|EStoringEntireWindow),

	iRedrawSegments(KRedrawRegionGranularity),

	iCurrentSegment(0),

	iOSBStatus(ETrue)

	{

	}

void CWsRedrawMsgWindow::ConstructL()

	{

	CWsWindowRedraw::ConstructL();

	Invalidate(&WsWin()->Rel());

	iWsWin->WsOwner()->RedrawQueue()->ReCalcOrder();

	}

CWsRedrawMsgWindow::~CWsRedrawMsgWindow()

	{

	WS_ASSERT_DEBUG(iMemoryLock == 0, EWsPanicMemoryLock);

	RemoveFromRedrawQueueIfEmpty();	

	iInvalid.Close();

	iLocalRedrawRegion.Close();

	iRedrawSegments.ResetAndDestroy();

	TInt count = iFbsBitmapRefArray.Count();

	WS_ASSERT_DEBUG(count==0,EWsPanicBitmapArrayNotEmpty);

	iFbsBitmapRefArray.ResetAndDestroy();

	}

/**

These three functions actually check for a value they have already asserted on.  This is intentional.

*/

void CWsRedrawMsgWindow::ExpandCommandBufferL(TInt aLength)

	{

	WS_ASSERT_DEBUG(iCurrentSegment != NULL, EWsPanicRedrawSegmentsInvalidState);

	if (iCurrentSegment)

		{

		// need more space?

		if (iCurrentSegment->iCurrentCommandBufferWritePos + aLength > iCurrentSegment->iDrawCommands->Size())

			{

			iCurrentSegment->iDrawCommands->ResizeL(iCurrentSegment->iCurrentCommandBufferWritePos + aLength);

			}

		}

	}

void CWsRedrawMsgWindow::CommandBufferWrite(const TDesC8& aDes, TInt aLength)

	{

	WS_ASSERT_DEBUG(iCurrentSegment != NULL, EWsPanicRedrawSegmentsInvalidState);

	WS_ASSERT_DEBUG(iCurrentSegment->iCurrentCommandBufferWritePos + aLength <= iCurrentSegment->iDrawCommands->Size(), EWsPanicDrawCommandsInvalidState);

	if (iCurrentSegment)

		{

		iCurrentSegment->iDrawCommands->Write(iCurrentSegment->iCurrentCommandBufferWritePos, aDes, aLength);

		iCurrentSegment->iCurrentCommandBufferWritePos += aLength;

		}

	}

void CWsRedrawMsgWindow::CommandBufferWrite(const TAny* aPtr,TInt aLength)

	{

	WS_ASSERT_DEBUG(iCurrentSegment != NULL, EWsPanicRedrawSegmentsInvalidState);

	WS_ASSERT_DEBUG(iCurrentSegment->iCurrentCommandBufferWritePos + aLength <= iCurrentSegment->iDrawCommands->Size(), EWsPanicDrawCommandsInvalidState);

	if (iCurrentSegment)

		{

		iCurrentSegment->iDrawCommands->Write(iCurrentSegment->iCurrentCommandBufferWritePos, aPtr, aLength);

		iCurrentSegment->iCurrentCommandBufferWritePos += aLength;

		}

	}

/*------------------------------------------------------------------------------

  Description: Processes draw commands. These are received as opcodes.

 -----------------------------------------------------------------------------*/

TBool CWsRedrawMsgWindow::CommandL(TInt aOpcode, TWsWinCmdUnion &aCmd)

	{

	switch(aOpcode)

		{

		case EWsWinOpEnableOSB:

			iOSBStatus = ETrue;

			break;

		case EWsWinOpDisableOSB:

			iOSBStatus = EFalse;

			break;

		case EWsWinOpSetBackgroundColor:

			iBackColor = *aCmd.rgb;

			iFlags |= EBackgroundClear;

			break;

		case EWsWinOpSetNoBackgroundColor:

			iFlags &= ~EBackgroundClear;

			break;

		case EWsWinOpInvalidate:

			Invalidate(aCmd.rect);

			break;

		case EWsWinOpInvalidateFull:

			Invalidate();

			break;

		case EWsWinOpBeginRedraw:

			BeginRedraw(aCmd.rect);

			ValidateRect(aCmd.rect);

			break;

		case EWsWinOpBeginRedrawFull:

			BeginRedraw(NULL);

			ValidateRect(NULL);

			break;

		case EWsWinOpEndRedraw:

			EndRedraw();

			break;

		case EWsWinOpGetInvalidRegionCount:

			{

			SetReply(iInvalid.Count());

			}

			break;

		case EWsWinOpGetInvalidRegion:

			{

			if ((*aCmd.Int) <= 0)

				OwnerPanic(EWservPanicInvalidRegionCount);

			if ((!iInvalid.CheckError()) && iInvalid.Count() == (*aCmd.Int))

				{

				CWsClient::ReplyBuf(iInvalid.RectangleList(),(*aCmd.Int) * sizeof(TRect));

				SetReply(EFalse);

				}

			else

				SetReply(ETrue);

			}

			break;

		case EWsWinOpStoreDrawCommands:

			/* If the client asks us not to store commands, we still store the commands

			for the region of the window which can be seen through the parent, but

			won't attempt to obtain the entire window.

			*/

			if (*aCmd.Bool)

				{

				SetScope(EStoreEntireWindow);

				}

			else

				{

				// Clients that turn their redraw store off will still get one,

				// but it will only attempt to store the current viewport.

				SetScope(EStoreViewport);

				}

			break;

		case EWsWinOpHandleTransparencyUpdate:	// deprecated

		case EWsWinOpSetTransparencyBitmap:		// deprecated

		case EWsWinOpSetTransparencyFactor:		// deprecated

		case EWsWinOpSetTransparencyBitmapCWs:	// deprecated

			break;	// do nothing.

		case EWsWinOpIsRedrawStoreEnabled:

			SetReply(ETrue);

			break;

		case EWsWinOpClearRedrawStore:

			DiscardStoredCommands();

			break;

		case EWsWinOpSetBackgroundSurface:

			SetBackgroundSurfaceL(*aCmd.Surface);

			break;

		case EWsWinOpSetBackgroundSurfaceConfig:

			SetBackgroundSurfaceL(aCmd.SurfaceConfigurationAndTrigger->surfaceConfig, aCmd.SurfaceConfigurationAndTrigger->triggerRedraw, EFalse);

			break;

		case EWsWinOpRemoveBackgroundSurface:

			RemoveBackgroundSurface(*aCmd.Bool);

			break;

		case EWsWinOpGetBackgroundSurfaceConfig:

			{

			TSurfaceConfiguration tempConfiguration = *aCmd.SurfaceConfiguration;

			GetBackgroundSurfaceL(tempConfiguration);

			TInt tempSize = aCmd.SurfaceConfiguration->Size();

			if (sizeof(TSurfaceConfiguration)<tempSize)

				tempSize = sizeof(TSurfaceConfiguration);

			CWsClient::ReplyBuf(&tempConfiguration,tempSize);

			}

			break;

		default:

			return(EFalse);

		}

	return(ETrue);

	}

/**

*/

void CWsRedrawMsgWindow::BeginRedraw(const TRect* aRect)

	{

	if(InRedraw())

		OwnerPanic(EWservPanicDrawCommandsInvalidState);

	iFlags|=EBeginEndRedraw;

	TRAPD(err,DoBeginRedrawL(aRect));

	DiscardStoredCommandsIfError(err);

	}

void CWsRedrawMsgWindow::DoBeginRedrawL(const TRect* aRect)

	{

	const TRect redrawRect = (aRect ? *aRect : TRect(WsWin()->Size()));

	if (redrawRect.IsEmpty())

		{

		//Skip empty rects since they are not added to the region

		iCurrentSegment = NULL;

		}

	else

		{

		CreateNewSegmentL(redrawRect, CWsRedrawMsgWindow::ESegmentTypePendingRedraw);

		if (!iAtomic)

			PromotePendingSegment();

		}

	}

void CWsRedrawMsgWindow::Invalidate(const TRect * aRect)

	{

	//The memory allocation in this function can trigger a call to ReleaseMemory(), which would

	//recursively call this function again. This would cause a memory leak. To avoid this

	//we call Lock() to block ReleaseMemory() from this object while executing this function.

    Lock();

	if (!aRect)

		{

		iInvalid.Clear();

		iInvalid.Copy(iWsWin->WindowArea());

		iInvalid.Offset(-iWsWin->Origin());

		}

	else if((!aRect->IsEmpty()) && aRect->IsNormalized())

		{

		iInvalid.AddRect(*aRect);

		iInvalid.Tidy();

		}

	if (iWsWin->IsVisible())

		{

		QueueRedraw();

		iWsWin->WsOwner()->TriggerRedraw(); //wtf isn't the redrawq already scheduling itself?

		}

    Unlock();

	}

/**

Obtains a region from the redraw store, intersects it with the global redraw region which

we have been asked to draw to, and returns the intersection.

*/

const TRegion * CWsRedrawMsgWindow::ReadRegion(const TInt aRegionNum)

	{

	// We are drawing to the global region, and we have a region in the redraw store to clip to.

	// We want the intersection of these to actually draw to.

	iLocalRedrawRegion.Copy(iRedrawSegments[aRegionNum]->iRegion);

	iLocalRedrawRegion.Offset(WsWin()->Origin());

	iLocalRedrawRegion.Intersect(*iRedrawRegion);

	iLocalRedrawRegion.Tidy();

	// If the resulting region is empty there is no point drawing its corresponding commands

	if (iLocalRedrawRegion.IsEmpty())

		return NULL;

	else

		return &iLocalRedrawRegion;

	}

void CWsRedrawMsgWindow::SubtractRectFromSegmentArray(const TRect& aRect)

	{

	for (TInt regionNum = iRedrawSegments.Count() - 1; regionNum >= 0; --regionNum)

		{

		if (iRedrawSegments[regionNum]->iRedrawSegmentType != ESegmentTypePendingRedraw)

			{

			RWsRegion& region = iRedrawSegments[regionNum]->iRegion;

			region.SubRect(aRect);

			if (region.CheckError())

				{

				// Ouch. Drop the now broken segment and ask for a full redraw

				delete iRedrawSegments[regionNum];

				iRedrawSegments.Remove(regionNum);

				Invalidate();

				}

			else

				{

				// check if region has zero uncovered rectangles left

				if (region.IsEmpty())

					{ // delete draw commands, release bitmaps and fonts

					delete iRedrawSegments[regionNum];

					iRedrawSegments.Remove(regionNum);

					}

				else

					{

					if (region.Count() > KRegionCompressThreshold)

						{ // tidy up the rectangles

						region.Tidy();

						}

					}

				}

			}

		}

	// coverity[extend_simple_error]	

	}

/*------------------------------------------------------------------------------

  Description: Clears out the command buffer if aError indicates an