// 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 "graphics/WSGRAPHICMSGBUF.H"

#include "DrawSection.h"

#include "CommandBuffer.h"

#include "BitmapCache.h"

#include "FontsCache.h"

#include "DrawableCache.h"

#include <graphics/wsgraphicscontext.h>

#include <graphics/wsdrawablesourceprovider.h>

#include <graphics/wsdrawresource.h>

#include "../SERVER/bitgditomwsgraphicscontextmappings.h"

const TInt KBufferSize = 1024;

EXPORT_C CCommandBuffer* CCommandBuffer::NewL()

	{

	CCommandBuffer* buffer = new (ELeave) CCommandBuffer;

	CleanupStack::PushL(buffer);

	buffer->ConstructL();

	CleanupStack::Pop(buffer);

	return buffer;

	}

CCommandBuffer::CCommandBuffer()

	{

	}

EXPORT_C CCommandBuffer::~CCommandBuffer()

	{	

	iDrawSections.ResetAndDestroy();

	iDrawSections.Close();

	iBufReadStream.Close();

	iClippingRegion.Close();

	iIntersectedRegion.Close();

	delete iRecordSegBuf;

	delete iBitmapCache;

	delete iFontCache;

	}

void CCommandBuffer::ConstructL()

	{

	iBitmapCache = new (ELeave)	CBitmapCache;

	iRecordSegBuf = CBufSeg::NewL(KBufferSize);

	iFontCache =  new (ELeave) CFontsCache;

	}

/**

Resets the entire commandbuffer.

*/

void CCommandBuffer::Reset()

	{

	if(iRecordSegBuf)

		iRecordSegBuf->Reset();

	iError =  KErrNone;	

	iOrigin = TPoint(0,0);

	iClippingRegion.Clear();

	iDrawSections.ResetAndDestroy();	

	}

/**

Externalizes commandbuffer sections into a format which makes it possible to send over IPC.

If ETrue is sent as a parameter to this method, the entire commandbuffer will be externalized,

otherwise only sections which has not been externalized before will be externalized. Note that if only

not externalized sections is asked for, the flag will be reset on that section so next call

to ExternalizeLC will not externalize that section.

@param aMsgBuf A buffer used to externalize the commandbuffer to.

@param aEntireBuffer If ETrue, the entire commandbuffer will be externalized, otherwise only sections which has not been externalized before.

*/

void CCommandBuffer::ExternalizeL(RWsGraphicMsgBuf& aMsgBuf, TBool aEntireBuffer)

	{

	// Add drawsections to aMsgBuf

	const TInt sectionCount = iDrawSections.Count();

	for(TInt j = 0; j < sectionCount; j++)	

		{

		CDrawSection* section = iDrawSections[j];

		if(aEntireBuffer || !section->HasBeenExternalized())

			{

			section->ExternalizeL(aMsgBuf);

			section->SetHasBeenExternalized(ETrue);

			}

		}

	}

/**

Internalizes the entire commandbuffer from buffer containing information about all drawsections and drawcommands.

@param aBuf A buffer containing information about all drawsections and drawcommands.

*/

EXPORT_C void CCommandBuffer::InternalizeL(const TDesC8& aBuf)

	{

	// Reset the commandbuffer

	iRecordSegBuf->Reset();

	InternalizeAppendL(aBuf);

	}

/**

Internalizes and appends from a buffer containing information about some drawsections and drawcommands.

@param aBuf A buffer containing information about some drawsections and drawcommands.

*/

EXPORT_C void CCommandBuffer::InternalizeAppendL(const TDesC8& aBuf)

	{

	// Reset the commandbuffer

	TWsGraphicMsgBufParser parser(aBuf);

	// Load drawsections

	const TInt count = parser.Count();

	for(TInt i = 0; i < count; i++)

		{

		CDrawSection* drawSection = CDrawSection::NewL();;

		CleanupStack::PushL(drawSection);

		User::LeaveIfError(drawSection->LoadL(parser, i));

		iDrawSections.AppendL(drawSection);

		CleanupStack::Pop(drawSection);

		}

	// Tidy the iDrawSection array so completely blocked sections will be removed

	Tidy();

	}

/**

@return the current active clipping region of the commandbuffer.

*/	

EXPORT_C const TRegion& CCommandBuffer::ClippingRegion() const

	{

	return *iActiveMasterClippingRegion;

	}

/**

Prepares to record new drawcommands for a drawsection.

This method is called from CRemoteGc::Activate().

*/

void CCommandBuffer::Prepare(const TRect& aDrawRect)

	{

	iDrawSectionRect = aDrawRect;

	iError = KErrNone;

  	if(iRecordSegBuf)

  		iRecordSegBuf->Delete(0, iRecordSegBuf->Size()); // Reset record buffer

  	else

  		TRAP(iError, iRecordSegBuf = CBufSeg::NewL(KBufferSize));

	}

/**

Finishes the recording of drawcommands for a drawsection. 

This method is called from CRemoteGc::Deactivate().

@param aDrawRect The drawrect of the recorded drawcommands.

@param aBoundingRect The boundingrect of the recorded drawcommands.

*/

TInt CCommandBuffer::Finish(const TRect& aDrawRect, const TRect& aBoundingRect, TBool aHasBitmapCommand)

	{

	// If some error occured during the recording of this section, dont add the section

	if(!iError)

		{

		CDrawSection* drawSection = NULL;

		TRAP(iError, drawSection = CDrawSection::NewL(aDrawRect, aBoundingRect, aHasBitmapCommand))

		if(iError)

			return iError;

		// If boundingRect is empty clear the drawcommands added

		if(aBoundingRect.IsEmpty())

			iRecordSegBuf->Delete(0, iRecordSegBuf->Size());

		iRecordSegBuf->Compress();

		drawSection->SetBuffer(iRecordSegBuf); //Takes ownership of the memory allocated by iRecordSegBuf			

		iRecordSegBuf = NULL;		

		if(CheckForDuplicate(*drawSection))

			{

			delete drawSection;

			return KErrAlreadyExists;

			}

		iError = iDrawSections.Append(drawSection);

		if(iError)

			delete drawSection;

		else

			{

			Tidy();

			if(iDrawSections.Count() == 0 || AllSectionsExternalized())

				return KErrGeneral;

			}

		}

	return iError;

	}

/**

Remove drawsections that is completely blocked by another drawsection. 

*/

void CCommandBuffer::Tidy()

	{

	RRegion region;

	TInt count = 0;

	for(TInt i = 0; i < (count = iDrawSections.Count()); i++)

		{		

		TRect rect1 = iDrawSections[i]->DrawRect();

		region.Clear();

		region.AddRect(rect1);

		for(TInt j = i + 1; j < count; j++)

			{

			TRect rect2 = iDrawSections[j]->DrawRect();

			region.SubRect(rect2);

			}

		if(region.IsEmpty())

			{

			delete iDrawSections[i];

			iDrawSections.Remove(i--);

			}

		}

	region.Close();

	// coverity[extend_simple_error]

	}

/** 

@return ETrue if all sections in the commandbuffer have been externalized, otherwise EFalse. 

*/ 

TBool CCommandBuffer::AllSectionsExternalized() const 

	{ 

	const TInt count = iDrawSections.Count(); 

	for(TInt i = 0; i < count; i++) 

		{ 

		if(!iDrawSections[i]->HasBeenExternalized()) 

			return EFalse; 

		} 

	return ETrue; 

	} 

/**

Checks if there exists any duplicate of aDrawSection already in the iDrawSection array.

@param aDrawSection The drawsection to look for a duplicate of.

@return ETrue if a duplicate was found, otherwise EFalse.

*/

TBool CCommandBuffer::CheckForDuplicate(const CDrawSection& aDrawSection) const

	{

	const TInt count = iDrawSections.Count();

	for(TInt i = 0; i < count; i++)

		{

		if(!iDrawSections[i]->IsIdentical(aDrawSection))

			continue;

		// Check if there is some drawsection that overlaps the section we found identical, 

		// if that is the case it is not a duplicate

		for(TInt j = i + 1; j < count; j++)

			{

			TRect compareRect = iDrawSections[j]->DrawRect();

			if(aDrawSection.DrawRect().Intersects(compareRect)) 

				return EFalse; //Found a drawrect that overlapped, no duplicate exists then

			}

		// Found duplicate

		return ETrue;

		}

	return EFalse;

	}

/**

Updates the clippingregion for a specific drawsection.

@param aDrawSectionIndex The index in iDrawSections of the drawsection to update the clippingregion for.

*/

void CCommandBuffer::UpdateClippingRegion(TInt aDrawSectionIndex)

	{

	__ASSERT_DEBUG(aDrawSectionIndex < iDrawSections.Count(), User::Invariant());

	iDrawSectionClippingRegion.Clear();

	if (iMasterClippingRegion)

		{

		iDrawSectionClippingRegion.Copy(*iMasterClippingRegion);

		}

	else

		{

		TRect rect = iMasterClippingRect;

		rect.Move(iMasterOrigin);

		iDrawSectionClippingRegion.AddRect(rect);

		}

	const TInt count = iDrawSections.Count();

	for(TInt i = aDrawSectionIndex + 1; i < count; ++i)

		{

		TRect rect = iDrawSections[i]->DrawRect();

		rect.Move(iMasterOrigin);

		iDrawSectionClippingRegion.SubRect(rect);

		}

	if (iDrawSectionClippingRegion.CheckError())

		iActiveMasterClippingRegion = iMasterClippingRegion;

	else

		iActiveMasterClippingRegion = &iDrawSectionClippingRegion;

	}

/**

Writes data of a specific length to the recordbuffer.

@param aPtr The data to write.

@param aLength The length of the data to write.

*/

void CCommandBuffer::Write(const TUint8* aPtr, TUint aLength)

	{

	if(iError)

		return;

	TRAP(iError, iRecordSegBuf->InsertL(iRecordSegBuf->Size(), aPtr, aLength))

	if(iError)

		return;

	}

/**

Writes text to the recordbuffer.

@param aText The text to write to the recordbuffer.

*/

void CCommandBuffer::WriteText(const TDesC8 &aText)

	{

	if(iError)

		return;

	// Append the total size of the text

	Write<TInt>(aText.Size());

	if(iError)

		return;			

	TRAP(iError, DoWriteTextL(aText));	

	}

/**

Writes text to the recordbuffer.

@param aText The text to write to the recordbuffer.

*/

void CCommandBuffer::WriteText(const TDesC16 &aText)

	{

	if(iError)

		return;

	// Append the total size of the text

	Write<TInt>(aText.Size());

	if(iError)

		return;			

	TPtrC8 textPtr(reinterpret_cast<const TUint8*>(aText.Ptr()),aText.Size());

	TRAP(iError, DoWriteTextL(textPtr));	

	}

/**

Writes text to the recordbuffer.

@param aText The text to write to the recordbuffer.

*/	

void CCommandBuffer::DoWriteTextL(const TDesC8 &aText)

	{

	iRecordSegBuf->InsertL(iRecordSegBuf->Size(), aText, aText.Size());		

	}

/**

Reads data with a specific length from iBufReadStream.

@param aPtr The read data is written to this paramenter.

@param aLength The length of the data to be read.

*/

void CCommandBuffer::ReadL(TUint8* aPtr, TUint aLength)

	{

	iBufReadStream.ReadL(aPtr, aLength);

	}

/**

Reads text from iBufReadStream.

@param aText The read text is put into this 8-bit buffer.

*/	

void CCommandBuffer::ReadTextLC(TPtrC8& aText)

	{

	DoReadTextLC(aText,EFalse);

	}

/**

Reads text from iBufReadStream.

@param aText The read text is put into this 16-bit buffer.

*/	

void CCommandBuffer::ReadTextLC(TPtrC16& aText)

	{

	TPtrC8 text8;

	DoReadTextLC(text8,ETrue);

	aText.Set(reinterpret_cast<const TUint16*>(text8.Ptr()),text8.Size()/2);

	}

/**

Reads text from iBufReadStream; used by ReadTextLC

@internalComponent

*/	

void CCommandBuffer::DoReadTextLC(TPtrC8& aText,TBool a16Bit)

	{

	ASSERT(iBufRead);

	TInt textSize;

	ReadL<TInt>(textSize); // Read the length of the text

	if(0 > textSize)

		{

		User::Leave(KErrArgument);

		}

	// attempt to do it inline

	const TInt pos = iBufReadStream.Source()->TellL(MStreamBuf::ERead).Offset();

	if(!a16Bit || !(pos & 1)) // check 16bit-aligned

		{

		const TPtrC8 remaining = iBufRead->Ptr(pos);

		if(remaining.Size() >= textSize) // can do inline!

			{

			CleanupStack::PushL((TAny*)NULL); // have to push something

			iBufReadStream.Source()->SeekL(MStreamBuf::ERead,textSize);

			aText.Set(remaining.Ptr(),textSize);

			return;

			}

		}

	// have to copy into a continuous segment

	HBufC8* buf = HBufC8::NewLC(textSize);

	TPtr8 textPtr8(buf->Des());

	iBufReadStream.ReadL(textPtr8,textSize);

	aText.Set(*buf);

	}

/**

Compares the commands in one buffer to those in another

@param aBuffer The buffer to compare to

@return ETrue if they are an exact match, EFalse otherwise

*/

EXPORT_C TBool CCommandBuffer::IsIdentical(const CCommandBuffer & aBuffer) const

	{

	for(TInt i = 0; i < iDrawSections.Count(); ++i)

		{

		if (!iDrawSections[i]->IsIdentical(*aBuffer.iDrawSections[i]))

			return EFalse;

		}

	return ETrue;

	}

/**

	@internalTechnology

*/

EXPORT_C TInt CCommandBuffer::Play(const TPoint& /*aPosition*/, const TRect& /*aDrawRect*/, const MWsGraphicResolver& /*aWsGraphicResolver*/, CBitmapContext& /*aContext*/) //Stub implementation to maintain compatibility with classic wserv

	{

	ASSERT(0);

	return KErrNotSupported;

	}

/**

	@internalTechnology

*/

EXPORT_C TInt CCommandBuffer::Play(const TPoint& /*aMasterOrigin*/, const TRegion* /*aMasterClippingRegion*/, const TRect& /*aMasterClippingRect*/, const MWsGraphicResolver& /*aWsGraphicResolver*/, CBitmapContext& /*aBitmapContext*/) //Stub implementation to maintain compatibility with WSERV2

	{

	ASSERT(0);

	return KErrNotSupported;

	}

/**

Draws draw commands that are within a specific rect to a graphics context with a specific offset.

@post The draw commands have been executed on the provided graphics context

@param aOffset The offset applied on all drawing operations.

@param aClippingRegion The region to which all draw commands are clipped

@param aSourceRect Draws only draw commands that are within this rect relative to the original coordinate system, i.e. before Position is applied

@param aWsGraphicResolver The resolver to be used for DrawGraphic() calls.

@param aGraphicsContext The graphics context to draw to.

@publishedPartner

*/

EXPORT_C TInt CCommandBuffer::Play(const TPoint& aOffset, const TRegion* aClippingRegion, const TRect& aSourceRect, const MWsGraphicResolver& aWsGraphicResolver, MWsGraphicsContext& aGraphicsContext)

	{

	iMasterOrigin = aOffset;

	iMasterClippingRegion = aClippingRegion;

	iMasterClippingRect = aSourceRect;

	Reset(aGraphicsContext);

	TRAPD(err, {

		iDrawableCache = new(ELeave) CRenderStageDrawableCache(aGraphicsContext.ObjectInterface<MWsDrawableSourceProvider>());

		DoPlayL(aWsGraphicResolver, aGraphicsContext);

		});

	delete iDrawableCache;

	iDrawableCache = NULL;

	return err;

	}

/**

Draws draw commands that are within a specific rect to a graphics context with a specific offset.

@post The draw commands have been executed on the provided graphics context

@param aOffset The offset applied on all drawing operations.

@param aClippingRegion The region to which all draw commands are clipped

@param aSourceRect Draws only draw commands that are within this rect relative to the original coordinate system, i.e. before Position is applied

@param aWsSession The session used to create the graphics context (WindowsGc)

@param aWindowGc The graphics context to draw to.

@publishedPartner

*/

EXPORT_C TInt CCommandBuffer::Play(const TPoint& aOffset, const TRegion* aClippingRegion, const TRect& aSourceRect, RWsSession& aWsSession, CWindowGc& aWindowGc)

	{

	iMasterOrigin = aOffset;

	iMasterClippingRegion = aClippingRegion;

	iMasterClippingRect = aSourceRect;

	Reset(aWindowGc);

	//Create a null version of MWsGraphicResolver which will never be used in this instance of the call to Play

	MWsGraphicResolver* graphicResolver = NULL;

	TRAPD(err, {

		iDrawableCache = new(ELeave) CWindowDrawableCache(aWsSession);

		DoPlayL(*graphicResolver, aWindowGc);

		});

	delete iDrawableCache;

	iDrawableCache = NULL;

	return err;

	}

/**

Draws drawcommands that are within a specific rect.

@param aWsGraphicResolver Any DrawWsGraphic commands will use this to draw themselves

@param aGraphicsContext The graphics context to draw to.

*/

template<typename ContextType> void CCommandBuffer::DoPlayL(const MWsGraphicResolver& aWsGraphicResolver, ContextType& aGraphicsContext)

	{

	const TInt sections = iDrawSections.Count();

	if(sections == 0)

		User::Leave(KErrEof);

	iBitmapCache->BeginUpdate();

	iFontCache->BeginUpdate();

	for(TInt i = 0; i < sections; i++)

		{

		UpdateClippingRegion(i);

		DrawSectionL(*iDrawSections[i], aWsGraphicResolver, aGraphicsContext);		

		}

	iFontCache->EndUpdate();

	iBitmapCache->EndUpdate();	

	}

/**

Draws a specific drawsection.

@param aDrawSection The drawsection to be drawn.

@param aWsGraphicResolver Any DrawWsGraphic commands will use this to draw themselves

@param aGraphicsContext The graphics context to draw to.

*/

template<typename ContextType> void CCommandBuffer::DrawSectionL(const CDrawSection& aDrawSection, const MWsGraphicResolver& aWsGraphicResolver, ContextType& aGraphicsContext)

	{

	iDrawSectionRect = aDrawSection.DrawRect();

	Reset(aGraphicsContext);

	iBufRead = aDrawSection.Buffer();

	iBufReadStream.Open(*iBufRead, 0);

	TDrawCode drawCode;

	while(ETrue)

		{		

	   	TRAPD(err, ReadL<TDrawCode>(drawCode));

	   	if(err == KErrEof)

	   		return;

	   	else if(err)

	   		User::Leave(err);

		switch(drawCode)

			{

		case ECommandClear:

			Clear(aGraphicsContext);

			break;			

		case ECommandClearRect:

			ClearRectL(aGraphicsContext);

			break;

		case ECommandCopyRect:

			CopyRectL(aGraphicsContext);

			break;

		case ECommandBitBlt1:

			BitBlt1L(aGraphicsContext);

			break;

		case ECommandBitBlt2:

			BitBlt2L(aGraphicsContext);

			break;

		case ECommandBitBltMasked:

			BitBltMaskedL(aGraphicsContext);

			break;

		case ECommandSetFaded:

			User::Leave(KErrNotSupported); //this op code is deprecated, should never be generated

			break;

		case ECommandSetFadingParameters:

			User::Leave(KErrNotSupported); //this op code is deprecated, should never be generated

			break;

		case ECommandAlphaBlendBitmaps:

			AlphaBlendBitmapsL(aGraphicsContext);

			break;		

		case ECommandSetOrigin:

			SetOriginL(aGraphicsContext);

			break;

		case ECommandSetDrawMode:

			SetDrawModeL(aGraphicsContext);

			break;

		case ECommandSetClippingRect:

			SetClippingRectL(aGraphicsContext);

			break;

		case ECommandCancelClippingRect:

			CancelClippingRect(aGraphicsContext);

			break;

		case ECommandReset:

			Reset(aGraphicsContext);

			break;			

		case ECommandUseFont:

			UseFontL(aGraphicsContext);

			break;

		case ECommandDiscardFont:

			DiscardFont(aGraphicsContext);

			break;

		case ECommandSetUnderlineStyle:

			SetUnderlineStyleL(aGraphicsContext);

			break;

		case ECommandSetStrikethroughStyle:

			SetStrikethroughStyleL(aGraphicsContext);

			break;

		case ECommandSetWordJustification:

			SetWordJustificationL(aGraphicsContext);

			break;

		case ECommandSetCharJustification:

			SetCharJustificationL(aGraphicsContext);

			break;

		case ECommandSetPenColor:

			SetPenColorL(aGraphicsContext);

			break;

		case ECommandSetPenStyle:

			SetPenStyleL(aGraphicsContext);

			break;

		case ECommandSetPenSize:

			SetPenSizeL(aGraphicsContext);

			break;									

		case ECommandSetBrushColor:

			SetBrushColorL(aGraphicsContext);

			break;						

		case ECommandSetBrushStyle:

			SetBrushStyleL(aGraphicsContext);

			break;

		case ECommandSetBrushOrigin:

			SetBrushOriginL(aGraphicsContext);

			break;

		case ECommandUseBrushPattern:

			UseBrushPatternL(aGraphicsContext);

			break;

		case ECommandDiscardBrushPattern:

			DiscardBrushPattern(aGraphicsContext);

			break;

		case ECommandMoveTo:

			MoveToL(aGraphicsContext);

			break;

		case ECommandMoveBy:

			MoveByL(aGraphicsContext);

			break;

		case ECommandPlot:

			PlotL(aGraphicsContext);

			break;

		case ECommandDrawArc:

			DrawArcL(aGraphicsContext);

			break;

		case ECommandDrawLine:

			DrawLineL(aGraphicsContext);

			break;

		case ECommandDrawLineTo:

			DrawLineToL(aGraphicsContext);

			break;

		case ECommandDrawLineBy:

			DrawLineByL(aGraphicsContext);

			break;

		case ECommandDrawPolyLine:

			DrawPolyLineL(aGraphicsContext);

			break;

		case ECommandDrawPie:

			DrawPieL(aGraphicsContext);

			break;

		case ECommandDrawEllipse:

			DrawEllipseL(aGraphicsContext);

			break;	

		case ECommandDrawRect:

			DrawRectL(aGraphicsContext);

			break;

		case ECommandDrawPolygon:

			DrawPolygonL(aGraphicsContext);

			break;	

		case ECommandDrawRoundRect:

			DrawRoundRectL(aGraphicsContext);

			break;

		case ECommandDrawBitmap1:

			DrawBitmap1L(aGraphicsContext);

			break;					

		case ECommandDrawBitmap2:

			DrawBitmap2L(aGraphicsContext);

			break;	

		case ECommandDrawBitmap3:

			DrawBitmap3L(aGraphicsContext);

			break;	

		case ECommandDrawBitmapMasked:

			DrawBitmapMaskedL(aGraphicsContext);

			break;

		case ECommandDrawText1:

			DrawText1L(aGraphicsContext);

			break;

		case ECommandDrawText2:

			DrawText2L(aGraphicsContext);

			break;

		case ECommandDrawText3:

			DrawText3L(aGraphicsContext);

			break;

		case ECommandDrawText4:

			DrawText4L(aGraphicsContext);

			break;

		case ECommandDrawText5:

			DrawText5L(aGraphicsContext);

			break;

		case ECommandMapColors:

			User::Leave(KErrNotSupported); //this op code is deprecated, should never be generated

			break;					

		case ECommandSetClippingRegion:

			SetClippingRegionL(aGraphicsContext);

			break;

		case ECommandCancelClippingRegion:

			CancelClippingRegion(aGraphicsContext);

			break;

		case ECommandDrawTextVertical1:

			DrawTextVertical1L(aGraphicsContext);

			break;

		case ECommandDrawTextVertical2:

			DrawTextVertical2L(aGraphicsContext);

			break;			

		case ECommandDrawTextVertical3:

			DrawTextVertical3L(aGraphicsContext);

			break;	

		case ECommandDrawTextVertical4:

			DrawTextVertical4L(aGraphicsContext);

			break;	

		case ECommandDrawWsGraphic1:

			DrawWsGraphic1L(aWsGraphicResolver);

			break;						

		case ECommandDrawWsGraphic2:

			DrawWsGraphic2L(aWsGraphicResolver);

			break;						

		case ECommandSetShadowColor:

			SetShadowColorL(aGraphicsContext);

			break;

		case ECommandDrawResourceToPos:

			DrawResourceToPosL(aGraphicsContext);

			break;

		case ECommandDrawResourceToRect:

			DrawResourceToRectL(aGraphicsContext);

			break;

		case ECommandDrawResourceFromRectToRect:

			DrawResourceFromRectToRectL(aGraphicsContext);

			break;

		case ECommandDrawResourceWithData:

			DrawResourceWithDataL(aGraphicsContext);

			break;

		default:

			User::LeaveIfError(KErrNotFound);

			break;

			}

		}

	}

template<typename ContextType> void CCommandBuffer::Clear(ContextType& aGraphicsContext) const

	{

	aGraphicsContext.Clear();

	}

template<typename ContextType> void CCommandBuffer::ClearRectL(ContextType& aGraphicsContext)

	{

	TRect rect;	

	ReadL<TRect>(rect);

	aGraphicsContext.Clear(rect);

	}

template<typename ContextType> void CCommandBuffer::CopyRectL(ContextType& aGraphicsContext)

	{

	TPoint point;

	TRect rect;	

	ReadL<TPoint>(point);

	ReadL<TRect>(rect);

	aGraphicsContext.CopyRect(point, rect);

	}

template<typename ContextType> void CCommandBuffer::BitBlt1L(ContextType& aGraphicsContext)

	{

	TPoint point;

	TInt handle;

	ReadL<TPoint>(point);

	ReadL<TInt>(handle);

	if(!iBitmapCache->UseL(handle))

		DoBitBlt1L(aGraphicsContext, point, handle);

	}

void CCommandBuffer::DoBitBlt1L(CWindowGc& aWindowGc, TPoint aPoint, TInt aHandle)

	{	

	aWindowGc.BitBlt(aPoint, iBitmapCache->Resolve(aHandle));

	}

void CCommandBuffer::DoBitBlt1L(MWsGraphicsContext& aGraphicsContext, TPoint aPoint, TInt aHandle)

	{	

	aGraphicsContext.BitBlt(aPoint, *iBitmapCache->Resolve(aHandle));

	}

template<typename ContextType> void CCommandBuffer::BitBlt2L(ContextType& aGraphicsContext)

	{

	TPoint point;

	TRect sourceRect;

	TInt handle;

	ReadL<TPoint>(point);

	ReadL<TInt>(handle);

	ReadL<TRect>(sourceRect);

	if(!iBitmapCache->UseL(handle))

		DoBitBlt2L(aGraphicsContext, point, handle, sourceRect);

	}

void CCommandBuffer::DoBitBlt2L(CWindowGc& aWindowGc, TPoint aPoint, TInt aHandle, TRect aSourceRect)

	{

	aWindowGc.BitBlt(aPoint, iBitmapCache->Resolve(aHandle), aSourceRect);

	}

void CCommandBuffer::DoBitBlt2L(MWsGraphicsContext& aGraphicsContext, TPoint aPoint, TInt aHandle, TRect aSourceRect)

	{

	aGraphicsContext.BitBlt(aPoint, *iBitmapCache->Resolve(aHandle), aSourceRect);

	}

template<typename ContextType> void CCommandBuffer::BitBltMaskedL(ContextType& aGraphicsContext)

	{

	TPoint point;

	TInt bitmapHandle;

	TRect sourceRect;	

	TInt maskHandle;

	TBool invertedMask;

	ReadL<TPoint>(point);

	ReadL<TInt>(bitmapHandle);

	ReadL<TRect>(sourceRect);

	ReadL<TInt>(maskHandle);

	ReadL<TBool>(invertedMask);

	if(!iBitmapCache->UseL(bitmapHandle) && !iBitmapCache->UseL(maskHandle))

		DoBitBltMaskedL(aGraphicsContext, point, bitmapHandle, sourceRect, maskHandle, invertedMask);

	}

void CCommandBuffer::DoBitBltMaskedL(CWindowGc& aWindowGc, TPoint aPoint, TInt aBitmapHandle, TRect aSourceRect, TInt aMaskHandle, TBool aInvertMask)

	{

	aWindowGc.BitBltMasked(aPoint, iBitmapCache->Resolve(aBitmapHandle), aSourceRect, iBitmapCache->Resolve(aMaskHandle), aInvertMask);	

	}

void CCommandBuffer::DoBitBltMaskedL(MWsGraphicsContext& aGraphicsContext, TPoint aPoint, TInt aBitmapHandle, TRect aSourceRect, TInt aMaskHandle, TBool aInvertMask)

	{

	aGraphicsContext.BitBltMasked(aPoint, *iBitmapCache->Resolve(aBitmapHandle), aSourceRect, *iBitmapCache->Resolve(aMaskHandle), aInvertMask);		

	}

template<typename ContextType> void CCommandBuffer::AlphaBlendBitmapsL(ContextType& aGraphicsContext)

	{

	TPoint destPoint;

	TInt srcHandle;

	TRect sourceRect;

	TInt alphaHandle;

	TPoint alphaPoint;

	ReadL<TPoint>(destPoint);

	ReadL<TInt>(srcHandle);

	ReadL<TRect>(sourceRect);

	ReadL<TInt>(alphaHandle);

	ReadL<TPoint>(alphaPoint);

	if(!iBitmapCache->UseL(srcHandle) && !iBitmapCache->UseL(alphaHandle))

		DoAlphaBlendBitmapsL(aGraphicsContext, destPoint, srcHandle, sourceRect, alphaHandle, alphaPoint);

	}

void CCommandBuffer::DoAlphaBlendBitmapsL(CWindowGc& aWindowGc, TPoint aDestPoint, TInt aSrcHandle, TRect aSourceRect, TInt aAlphaHandle, TPoint aAlphaPoint)

	{

	aWindowGc.AlphaBlendBitmaps(aDestPoint, iBitmapCache->Resolve(aSrcHandle), aSourceRect, iBitmapCache->Resolve(aAlphaHandle), aAlphaPoint);

	}

void CCommandBuffer::DoAlphaBlendBitmapsL(MWsGraphicsContext& aGraphicsContext, TPoint aDestPoint, TInt aSrcHandle, TRect aSourceRect, TInt aAlphaHandle, TPoint aAlphaPoint)

	{

	aGraphicsContext.BitBltMasked(aDestPoint, *iBitmapCache->Resolve(aSrcHandle), aSourceRect, *iBitmapCache->Resolve(aAlphaHandle), aAlphaPoint);	

	}

template<typename ContextType> void CCommandBuffer::SetOriginL(ContextType& aGraphicsContext)

	{

	ReadL<TPoint>(iOrigin);

	aGraphicsContext.SetOrigin(iMasterOrigin + iOrigin);

	}

template<typename ContextType> void CCommandBuffer::SetDrawModeL(ContextType& aGraphicsContext)

	{

	CGraphicsContext::TDrawMode drawMode;

	ReadL<CGraphicsContext::TDrawMode>(drawMode);

	DoSetDrawModeL(aGraphicsContext, drawMode);

	}

void CCommandBuffer::DoSetDrawModeL(CWindowGc& aWindowGc, CGraphicsContext::TDrawMode aDrawMode)

	{

	aWindowGc.SetDrawMode(aDrawMode);

	}

void CCommandBuffer::DoSetDrawModeL(MWsGraphicsContext& aGraphicsContext, CGraphicsContext::TDrawMode aDrawMode)

	{

	aGraphicsContext.SetDrawMode(BitGdiToMWsGraphicsContextMappings::LossyConvert(aDrawMode));

	}

template<typename ContextType> void CCommandBuffer::SetClippingRectL(ContextType& aGraphicsContext)

	{

	ReadL<TRect>(iClippingRect);

	iClippingRect.Intersection(iMasterClippingRect);

	iClippingRect.Intersection(iDrawSectionRect);

	//Replacement for SetClippingRect functionality which MWsGraphicsContext does not support

	iIntersectedRegion.Clear();

	if(iActiveMasterClippingRegion->Count() > 0)

		iIntersectedRegion.Copy(*iActiveMasterClippingRegion);

	iIntersectedRegion.ClipRect(iClippingRect);

	aGraphicsContext.SetClippingRegion(iIntersectedRegion);

	}

template<typename ContextType> void CCommandBuffer::CancelClippingRect(ContextType& aGraphicsContext)

	{

	iClippingRect = iMasterClippingRect;

	iClippingRect.Intersection(iDrawSectionRect);

	//Replacement for SetClippingRect functionality which MWsGraphicsContext does not support

	iIntersectedRegion.Clear();

	if(iActiveMasterClippingRegion && iActiveMasterClippingRegion->Count() > 0)

		iIntersectedRegion.Copy(*iActiveMasterClippingRegion);

	iIntersectedRegion.ClipRect(iClippingRect);

	aGraphicsContext.SetClippingRegion(iIntersectedRegion);

	}

void CCommandBuffer::Reset(CWindowGc& aWindowGc)

	{

	aWindowGc.Reset();

	aWindowGc.SetOrigin(iMasterOrigin);

	if(iActiveMasterClippingRegion)

		aWindowGc.SetClippingRegion(*iActiveMasterClippingRegion);

	CancelClippingRect(aWindowGc);

	iOrigin = TPoint(0,0);

	iClippingRegion.Clear();

	iParsedClippingRegionIsSet = EFalse;

	}

void CCommandBuffer::Reset(MWsGraphicsContext& aGraphicsContext)

	{

	aGraphicsContext.Reset();

	TRgb brushColor = KRgbWhite;

	brushColor.SetAlpha(0); //make transparent

	aGraphicsContext.SetBrushColor(brushColor);

	aGraphicsContext.SetOrigin(iMasterOrigin);

	if(iActiveMasterClippingRegion)

		aGraphicsContext.SetClippingRegion(*iActiveMasterClippingRegion);

	CancelClippingRect(aGraphicsContext);

	iOrigin = TPoint(0,0);

	iClippingRegion.Clear();

	iParsedClippingRegionIsSet = EFalse;

	}

template<typename ContextType> void CCommandBuffer::UseFontL(ContextType& aGraphicsContext)

	{

	TInt fontHandle;

	ReadL<TInt>(fontHandle);