// 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 "../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

/** Max number of non-redraw segments allowed before starting to throw away the oldest */

const TInt KNonRedrawSegMaxLimit = 16;

/** The number of non-redraw segments to spare from deletion once their number 

    have grown beyond KNonRedrawSegMaxLimit */

const TInt KNonRedrawSegThreshold = 8;

TInt CWsRedrawMsgWindow::iNonRedrawAgeLimit = 0;

CWsRedrawMsgWindow::TAtomicityType CWsRedrawMsgWindow::iAtomicity = ENoAtomicity;

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

#   include "offscreenbitmap.h"

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

#else

#	define DEBUGOSB

#endif

#ifndef _DEBUG

#define LOG_WINDOW_REDRAW_START(wswin,region)

#define LOG_WINDOW_REDRAW_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_REDRAW_START(wswin,region) LogDrawCommandsStart(wswin,region)

#define LOG_WINDOW_REDRAW_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);}}

extern CDebugLogBase *wsDebugLog;

class TTruncateOverflow : public TDesOverflow

	{

	public:

	virtual void Overflow(TDes&) {};

	};

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

		_LIT(KLogRedrawSegmentNonRedraw, "NonRedraw");

		switch(aSegmentType)

			{

			case CWsRedrawMsgWindow::ESegmentTypePendingRedraw :

				log.AppendFormat(KLogRedrawSegmentPending, &overflow);

				break;

			case CWsRedrawMsgWindow::ESegmentTypeRedraw :

				log.AppendFormat(KLogRedrawSegmentRedraw, &overflow);

				break;

			case CWsRedrawMsgWindow::ESegmentTypeNonRedraw :

				log.AppendFormat(KLogRedrawSegmentNonRedraw, &overflow);

			break;

			default :

				{

				}

			}

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

		}

	}

LOCAL_C void LogRegion(const TRegion* aRegion)

	{

	TBuf<LogTBufSize> log;

	TTruncateOverflow overflow;

	TInt rectCount = (aRegion == NULL ? 0 : aRegion->Count());

	log.AppendFormat(_L("region [%d,"), &overflow, rectCount);

	if (rectCount > 0)

		{

		const TRect* rectangles = aRegion->RectangleList();

		TBuf<1> comma;

		for (TInt ii = 0; ii < rectCount; ii++)

			{

			TRect current = rectangles[ii];

			log.AppendFormat(_L("%S{{%d,%d},{%d,%d}}"), &overflow, &comma,

	                         current.iTl.iX,current.iTl.iY,current.iBr.iX,current.iBr.iY);

			comma = _L(",");

			}

		}

	else

		{

		log.AppendFormat(_L("NULL"), &overflow);

		}

	log.AppendFormat(_L("]"), &overflow);

	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::CRedrawSegment* CWsRedrawMsgWindow::CRedrawSegment::NewLC(const TRect& aRect, TRedrawSegmentType aNewRegionType)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aRect, aNewRegionType);

	return self;

	}

void CWsRedrawMsgWindow::StaticInitL()

	{

	_LIT(KNonRedrawAgeLimit, "NONREDRAWAGELIMIT");

	const TInt KDefaultNonRedrawAgeLimit = 1000000;

	if (!WsIniFile->FindVar(KNonRedrawAgeLimit, iNonRedrawAgeLimit))

		iNonRedrawAgeLimit = KDefaultNonRedrawAgeLimit;

	_LIT(KAtomicRedraws,"ATOMICREDRAWS");

	_LIT(KAtomicSegment,"SEGMENT");

	_LIT(KAtomicWindow,"WINDOW");

	TPtrC atomicityTypeString;

	if (WsIniFile->FindVar(KAtomicRedraws,atomicityTypeString))

		{

		if(atomicityTypeString.CompareF(KAtomicSegment)==0 || atomicityTypeString.Length()==0)

			iAtomicity = ESegment;

		else if(atomicityTypeString.CompareF(KAtomicWindow)==0)

			iAtomicity = EWindow;

		}

	}

void CWsRedrawMsgWindow::CRedrawSegment::ReleaseFontsAndBitmaps()

	{

	// release Bitmap and Font 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);

		}

	count = iFbsBitmapArray.Count();

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

		{

		delete iFbsBitmapArray[ii];

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

	{

	delete iDrawCommands;

	iRegion.Close();

	// Release Font and Bitmap handles, close arrays

	ReleaseFontsAndBitmaps();

	iFbsBitmapArray.Close();

	iWsBitmapArray.Close();

	iWsFontArray.Close();

	iDrawerArray.Close();

	}

void CWsRedrawMsgWindow::WindowClosing()

	{

	iWsWin->WsOwner()->RedrawQueue()->RemoveInvalid(this);

	}

TInt CWsRedrawMsgWindow::CRedrawSegment::SizeInBytes() const

	{

	TInt size = sizeof(CWsRedrawMsgWindow::CRedrawSegment);

	size += iDrawCommands->Size();

	size += iFbsBitmapArray.Count() * sizeof(CFbsBitmap);

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

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

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

	return size;

	}

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

	iCurrentSegment=NULL;

	}

/**

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;

		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 (iAtomicity==ENoAtomicity)

			PromoteLastPendingSegment();

		}

	}

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

	}

/**

If a draw command is received outside a begin/end redraw pair, then it is stored in a non-redraw

segment.  This function creates such a segment if it isn't already available.

*/

void CWsRedrawMsgWindow::HandleNonRedrawCommand(TWsGcOpcodes aOpcode)

	{

	// calling code should check the Window State

	WS_ASSERT_DEBUG(!InRedraw(), EWsPanicDrawCommandsInvalidState);

	// Attempting to draw part of a polygon in a new segment - only a very bad client can do this:

	TBool canCreate = !(aOpcode == EWsGcOpSegmentedDrawPolygonData || aOpcode == EWsGcOpDrawSegmentedPolygon);

	if ((!iCurrentSegment) && (!canCreate))

		{

		OwnerPanic(EWservPanicBadPolyData);

		}

	if (canCreate)

		AgeNonRedrawSegments();

	// If current redraw region is not for Non-Redraw drawing, add a region corresponding to the

	// full window to the redraw store.  Need to make sure that this is done 

	// before the AppendCommand, or bitmap/font handles are recorded, in StoreDrawCommandL

	TInt err = KErrNone;

	if ((!iCurrentSegment) || iCurrentSegment->iRedrawSegmentType != ESegmentTypeNonRedraw)

		{

		TRAP(err,CreateNewSegmentL(TRect(WsWin()->Size()), ESegmentTypeNonRedraw));

		}

	if (err != KErrNone)

		{

		Invalidate();

		}

	if(iWsWin->VisibleRegion().CheckError())

		iWsWin->Screen()->AddRedrawRegion(iWsWin->WindowArea());

	else if(iWsWin->VisibleRegion().Count())

		iWsWin->Screen()->AddRedrawRegion(iWsWin->VisibleRegion());

	else if(!iWsWin->HasBeenDrawnToScreen())

		CliWin()->ScheduleRegionUpdate(&iWsWin->VisibleRegion());

	}

/**

This function attempts to prevent non-redraw segments from growing indefinitely by requesting redraws 

and throwing away old ones.

*/

void CWsRedrawMsgWindow::AgeNonRedrawSegments()

  	{

	if (!iRedrawSegments.Count())

		return;

	//Count the number of non-redraw segs

	TInt nonRedrawSegCount = 0;

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

		{

		CRedrawSegment* segment = iRedrawSegments[i];

		if (segment->iRedrawSegmentType == ESegmentTypeNonRedraw)

			{

			++nonRedrawSegCount; 

			}

		}

	TBool callInvalidate = EFalse;

	//To prevent the number of non redraw segements to grow indefinitely,

	//delete the oldest if their number exceeds KNonRedrawSegMaxLimit

	if (nonRedrawSegCount > KNonRedrawSegMaxLimit)

		{

		TInt keep = KNonRedrawSegThreshold; // keep this many, the most recent ones

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

			{

			CRedrawSegment* segment = iRedrawSegments[i];

			if (segment->iRedrawSegmentType == ESegmentTypeNonRedraw)

				{

				if (keep-- > 0)

					{

					continue;

					}

				else if (segment!=iCurrentSegment) //never delete the current segment

					{

					callInvalidate = ETrue;

					iRedrawSegments.Remove(i);

					delete segment;

					}

				}

			}

		}

	if(iCurrentSegment && iCurrentSegment->iRedrawSegmentType == ESegmentTypeNonRedraw)

		{

		// If the current segment is an old non-redraw segment, try to get rid of it

		TTime now;

		now.UniversalTime();

		TTimeIntervalMicroSeconds age = now.MicroSecondsFrom(iCurrentSegment->iCreationTime);

		if (age > iNonRedrawAgeLimit)

			{

			// First, find any even older non redraw segments and discard them.

			for (TInt seg = iRedrawSegments.Count() - 2; seg >= 0; --seg)

				{

				CRedrawSegment * segment = iRedrawSegments[seg];

				if (segment->iRedrawSegmentType == ESegmentTypeNonRedraw)

					{

					age = now.MicroSecondsFrom(segment->iCreationTime);

					if ((age > iNonRedrawAgeLimit * 2) && (segment!=iCurrentSegment))

						{

						iRedrawSegments.Remove(seg);

						delete segment;

						}

					}

				}

			// Then force the creation of a new segment, so that the current one can be allowed to age and eventually vanish.

			iCurrentSegment->iCreationTime = now;

			iCurrentSegment = NULL;

			callInvalidate = ETrue;

			}

		}

	if(callInvalidate)

		Invalidate(); // Invalidate the window so that a complete redraw should occur

  	}

/**

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)

	{

	// Catch anyone calling this without first deciding where they want to draw

	WS_ASSERT_DEBUG(iWsWin->ScheduledRegion(), EWsPanicScheduledRedraw);

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

	// Andy - this allocates memory during drawing, which is bad in OOM conditions.

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

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

	iLocalRedrawRegion.Intersect(*iGlobalRedrawRegion);

	iLocalRedrawRegion.Tidy();

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

	if (iLocalRedrawRegion.IsEmpty())

		return NULL;

	else

		return &iLocalRedrawRegion;

	}

TInt CWsRedrawMsgWindow::SubtractRectFromSegmentArray(const TRect& aRect)

	{

	TInt numOfRegionsRemoved =0;

	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

				// Andy - This is an error condition and needs to check for infinite loops

				delete iRedrawSegments[regionNum];

				iRedrawSegments.Remove(regionNum);

				numOfRegionsRemoved++;

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

					numOfRegionsRemoved++;

					}

				else

					{

					if (region.Count() > KRegionCompressThreshold)

						{ // tidy up the rectangles

						region.Tidy();

						}

					}

				}

			}

		}

	return numOfRegionsRemoved;

	}

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

  Description: Clears out the command buffer if aError indicates an

               error has occurred whilst storing commands.

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

void CWsRedrawMsgWindow::DiscardStoredCommandsIfError(TInt aError)

	{

	if (aError != KErrNone)

		{

		// Discard stored commands by clearing out the command buffer

		DiscardStoredCommands();

		if (!(iFlags&ENoRepeatRedraw))

			Invalidate();

		iFlags |= ENoRepeatRedraw;

		}

	}

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

  Description: If the graphics context has changed and we are currently storing

               commands, store the data given by aCmdData.

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

TBool CWsRedrawMsgWindow::DrawCommand(CWsGc* aGc,const TAny *aCmdData)

	{

	// Store commands, clearing out buffer if error occurs.

	TRAPD(err,StoreDrawCommandL(aGc,aCmdData));

	DiscardStoredCommandsIfError(err);

	return EFalse;

	}

void CWsRedrawMsgWindow::GcAttributeChange(CWsGc* aGc,const TAny *aCmdData)

	{

	if (iLastDrawGc == aGc && iCurrentSegment)

		{

		TInt err = KErrNone;

		if (IsWsFontOperation(CWsClient::iCurrentCommand.iOpcode))

			{

			TWsGcCmdUnion pData;

			pData.any=aCmdData;

			TRAP(err,AddWsFontL(*pData.UInt));

			}

		if (KErrNone == err)

			TRAP(err,AppendCommandL(aCmdData));

		DiscardStoredCommandsIfError(err);

		}

	// INC135845: 

	// Retain the bitmap handle for the lifetime of the redraw store

	// If the client destroys it, we will still have a reference to it

	if (iCurrentSegment && CWsClient::iCurrentCommand.iOpcode == EWsGcOpUseBrushPattern)

		{

		TInt err = KErrNone;

		TWsGcCmdUnion pData;

		pData.any=aCmdData;

		TRAP(err, AddFbsBitmapsL(*pData.handle, 0));

		DiscardStoredCommandsIfError(err);

		}

	}

void CWsRedrawMsgWindow::GcDeactivate(CWsGc* aGc)

	{

	if (iLastDrawGc==aGc)

		iLastDrawGc=NULL;

	}

inline TBool CWsRedrawMsgWindow::IsFbsBitmapOperation(TInt aOpCode) const

	{

	WS_ASSERT_DEBUG((EWsGcOpGdiBlt3==EWsGcOpGdiBlt2+1)&&(EWsGcOpGdiBltMasked==EWsGcOpGdiBlt3+1)

				&&(EWsGcOpDrawBitmap2==EWsGcOpDrawBitmap+1)&&(EWsGcOpDrawBitmap3==EWsGcOpDrawBitmap2+1)&&(EWsGcOpDrawBitmapMasked==EWsGcOpDrawBitmap3+1),EWsPanicBitmapOpcodeInvalid);

	return (aOpCode>=EWsGcOpGdiBlt2&&aOpCode<=EWsGcOpGdiBltMasked)||(aOpCode>=EWsGcOpDrawBitmap&&aOpCode<=EWsGcOpDrawBitmapMasked)||(aOpCode==EWsGcOpGdiAlphaBlendBitmaps);

	}

inline TBool CWsRedrawMsgWindow::IsWsBitmapOperation(TInt aOpCode) const

	{

	WS_ASSERT_DEBUG((EWsGcOpGdiBlt3==EWsGcOpGdiBlt2+1)&&(EWsGcOpGdiBltMasked==EWsGcOpGdiBlt3+1)

				&&(EWsGcOpDrawBitmap2==EWsGcOpDrawBitmap+1)&&(EWsGcOpDrawBitmap3==EWsGcOpDrawBitmap2+1)&&(EWsGcOpDrawBitmapMasked==EWsGcOpDrawBitmap3+1),EWsPanicBitmapOpcodeInvalid);

	return (aOpCode>=EWsGcOpGdiWsBlt2&&aOpCode<=EWsGcOpGdiWsBltMasked)||(aOpCode==EWsGcOpGdiWsAlphaBlendBitmaps)||(aOpCode==EWsGcOpWsDrawBitmapMasked);

	}

inline TBool CWsRedrawMsgWindow::IsWsFontOperation(TInt aOpCode) const

	{

	return aOpCode==EWsGcOpUseFont;

	}

inline TBool CWsRedrawMsgWindow::IsDrawWsGraphicOperation(TInt aOpCode) const

	{

	return (aOpCode == EWsGcOpDrawWsGraphic) || (aOpCode == EWsGcOpDrawWsGraphicPtr);

	}

void CWsRedrawMsgWindow::ReplaceAndAppendCommandL(TInt aOpcode,const TAny* aCmdData)

	{

	const TInt KCharWidthInBytes = 2; // # of bytes for a Unicode character

	CWsClient* owner=iWsWin->WsOwner();

	WS_ASSERT_DEBUG(owner,EWsPanicDrawCommandsNullSession);

	// aCmdData doesn't contain data, it should be retrieved from client space using remote read

	TWsGcCmdUnion cmd;

	cmd.any=aCmdData;

	TUint16 newOpcode=EWsGcOpDrawText;

	TInt strLen=0;

	switch (aOpcode)

		{

		case EWsGcOpDrawTextPtr:

			newOpcode=EWsGcOpDrawText;

			strLen=cmd.DrawText->length;

			break;

		case EWsGcOpDrawTextVerticalPtr:

			newOpcode=EWsGcOpDrawTextVertical;

			strLen=cmd.DrawTextVertical->length;

			break;

		case EWsGcOpDrawBoxTextPtr:

			newOpcode=EWsGcOpDrawBoxText;

			strLen=cmd.BoxText->length;

			break;

		case EWsGcOpDrawBoxTextVerticalPtr:

			newOpcode=EWsGcOpDrawBoxTextVertical;

			strLen=cmd.DrawBoxTextVertical->length;

 			break;

		}

	TInt strSize = strLen * KCharWidthInBytes;

	TInt oldCmdLen=CWsClient::iCurrentCommand.iCmdLength;

	TInt newCmdLen=sizeof(TWsCmdHeaderBase)+oldCmdLen+strSize;

	// resize buffer

	ExpandCommandBufferL(newCmdLen);

	// update current command to reflect the new command and data

	CWsClient::iCurrentCommand.iOpcode=newOpcode;

	CWsClient::iCurrentCommand.iOpcode|=EWsGcOpFlagDrawOp;

	CWsClient::iCurrentCommand.iCmdLength=(TInt16)(oldCmdLen+strSize);

	// write command header

	CommandBufferWrite(&CWsClient::iCurrentCommand, sizeof(TWsCmdHeaderBase));

	// write command

	CommandBufferWrite(aCmdData, oldCmdLen);

	// remote read

	TBuf<KReadBufferMaxLen> buf;

	TInt len=KReadBufferMaxLen;

	TInt bufOffset=0;

	TInt toGo=strLen;

	while(toGo>0)

		{

		if (len>toGo)

			len=toGo;

		owner->RemoteRead(buf,bufOffset);

		CommandBufferWrite(buf.Ptr(), len * KCharWidthInBytes);

		bufOffset+=len;

		toGo-=len;

		}

	}

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

  Description: Stores drawing related commands into the command buffer

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

void CWsRedrawMsgWindow::StoreDrawCommandL(CWsGc* aGc,const TAny *aCmdData)

	{

	TWsGcOpcodes currentOpcode = static_cast<TWsGcOpcodes>(CWsClient::iCurrentCommand.iOpcode);

	// If we get an extra command after the redraw has finished then redraw strategy needs to know

	if (!InRedraw())

		{

#ifdef __WINS__

		TBool isDrawingCommand = (currentOpcode != EWsGcOpSegmentedDrawPolygonData) && (currentOpcode != EWsGcOpDrawSegmentedPolygon);

		if( CWsClient::DebugEnforceRedrawCallingConvention() && isDrawingCommand)

			CWsClient::PanicCurrentClient(EWservPanicWindowBeginRedrawNotCalled);

#endif

		HandleNonRedrawCommand(currentOpcode);

		}

	// If there is no current segment then we have discarded it at some point

	// since beginning this redraw.  

	if (iCurrentSegment)

		{

		TWsGcCmdUnion pData;

		pData.any = aCmdData;

		if (IsFbsBitmapOperation(currentOpcode))

			{

			TInt maskHandle = 0;

			TInt handle = aGc->FbsBitmapHandle(currentOpcode, pData, maskHandle);

			AddFbsBitmapsL(handle, maskHandle);

			}

		else if (IsWsBitmapOperation(currentOpcode))

			{

			TInt maskHandle = 0;

			TInt handle = aGc->WsBitmapHandle(currentOpcode, pData, maskHandle);

			AddWsBitmapsL(handle, maskHandle);

			}

		else if (IsDrawWsGraphicOperation(currentOpcode))

			{

			TGraphicDrawerId drawerId;

			drawerId.iId = pData.WsGraphic->iId;

			drawerId.iIsUid = (pData.WsGraphic->iFlags & EWsGraphicIdUid);

			iCurrentSegment->AddDrawerL(drawerId);

			}

		// If the graphics context has changed since last time store the new graphics

		// context attributes.

		if (aGc != iLastDrawGc)

			{

			StoreAllGcAttributesL(aGc);

			iLastDrawGc = aGc;

			}

		// For operation which requires remote read from client space, we must retrieve that data and store

		// it in command buffer at server side and change opcode if necessary e.g EWsGcOpDrawTextPtr to EWsGcOpDrawText

		// to avoid remote read during DoDrawing operation

		if (IsRemoteReadRequired(currentOpcode))

			ReplaceAndAppendCommandL(currentOpcode,aCmdData);

		else

			// Append the command data to the command buffer

			AppendCommandL(aCmdData, EWsGcOpFlagDrawOp);

		}

	}

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

  Description: Stores given drawing command data into the command buffer.

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

void CWsRedrawMsgWindow::AppendCommandL(const TAny* aCmdData, const TUint16 aOpcodeFlags)

	{

	if (CWsClient::iCurrentCommand.iOpcode == EWsGcOpSetClippingRegion)

		{

		// The client is defining a clipping region

		// make room for the header

		ExpandCommandBufferL(sizeof(TWsCmdHeaderBase));

		// Externalize the clipping region data from position after the header

		RBufWriteStream bufWriteStream;

		bufWriteStream.Open(*CurrentDrawCommandBuffer(), CurrentCommandBufferWritePos() + sizeof(TWsCmdHeaderBase));

		CleanupClosePushL(bufWriteStream);

		TInt dataLen = iLastDrawGc->ExternalizeClippingRegionL(bufWriteStream);

		// Setup the clipping region data header

		CWsClient::iCurrentCommand.iOpcode = EWsStoreClippingRegion;

		CWsClient::iCurrentCommand.iCmdLength = REINTERPRET_CAST(TInt16&,dataLen);

		// Store command header for clipping region data at current write position

		CommandBufferWrite(&CWsClient::iCurrentCommand,sizeof(TWsCmdHeaderBase));

		// Update write position for command data

		iCurrentSegment->iCurrentCommandBufferWritePos += dataLen;

		CleanupStack::PopAndDestroy(&bufWriteStream);

		}

	else

		{		

		TUint16 opcode = CWsClient::iCurrentCommand.iOpcode;

		CWsClient::iCurrentCommand.iOpcode |= aOpcodeFlags;

		// ensure room in command buffer

		ExpandCommandBufferL(sizeof(TWsCmdHeaderBase) + CWsClient::iCurrentCommand.iCmdLength);

		// Store command header to current position

		CommandBufferWrite(&CWsClient::iCurrentCommand, sizeof(TWsCmdHeaderBase));

		// If there's command data (other than header), store it

		if (CWsClient::iCurrentCommand.iCmdLength > 0)

			{

			CommandBufferWrite(aCmdData, CWsClient::iCurrentCommand.iCmdLength);

			}

		CWsClient::iCurrentCommand.iOpcode = opcode;

		}

	}

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

  Description: Stores graphics context information into the command buffer

               from the current write position.

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

void CWsRedrawMsgWindow::StoreAllGcAttributesL(CWsGc* aGc)

	{

	// In order for the externalize below to work correctly from

	// a non-zero position we have to create the header placeholder

	ExpandCommandBufferL(sizeof(TWsCmdHeaderBase));

	// Externalise GC attribute data. We do this before writing the

	// header as we do not know the size of the data yet and it is

	// part of the header.

	TInt numOfBytesAdded = aGc->ExternalizeL(*CurrentDrawCommandBuffer(),

				CurrentCommandBufferWritePos() + sizeof(TWsCmdHeaderBase));

	// Setup the header

	TWsCmdHeaderBase cmdHeader;

	cmdHeader.iCmdLength = (TInt16) numOfBytesAdded;		// as calculated above

	cmdHeader.iOpcode = (TInt16) EWsStoreAllGcAttributes;

	// Store the header for the GC data into the space we created

	CommandBufferWrite(&cmdHeader, sizeof(TWsCmdHeaderBase));

	// Update write position for command data

	iCurrentSegment->iCurrentCommandBufferWritePos += numOfBytesAdded;

	}

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

  Description: Loops through the whole of the current command buffer, processing

               each in turn.

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

void CWsRedrawMsgWindow::DrawCommandsL()

	{

	LOG_WINDOW_REDRAW_START(WsWin(), iGlobalRedrawRegion);

	WS_ASSERT_DEBUG(iMemoryLock > 0, EWsPanicMemoryLock);

	static TBuf8<EClientBufferMaxSize> buf;

	TInt regionCount = iRedrawSegments.Count();

	for (TInt regionNum = 0; regionNum < regionCount; ++regionNum)

		{

		CRedrawSegment* segment = iRedrawSegments[regionNum];

		LOG_REDRAW_SEGMENT(regionNum, segment->iRedrawSegmentType);

		if (segment->iRedrawSegmentType == ESegmentTypePendingRedraw)

			continue;

		// The amount of commands we process is given by the value of the

		// current write position rather than the size of the command buffer.

		// Note: the write position is incremented as each command is stored and

		// will typically be less than the buffer size.

		const TInt length = segment->iCurrentCommandBufferWritePos;

		// need to draw this region?

		const TRegion * localDrawRegion = 0;

		if (length)

		 	localDrawRegion = ReadRegion(regionNum);

		if (localDrawRegion)

			{

			CPlaybackGc::Instance()->SetTargetRegion(localDrawRegion);

			LOG_REDRAW_SEGMENT_REGION(localDrawRegion)

			TWsCmdHeaderBase header;

			TInt pos = 0; // Set to first command position in buffer

			CBufSeg* drawCmdBuffer = segment->iDrawCommands;