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

// GC and Graphics functions

// 

//

#include "playbackgc.h"

#include <e32std.h>

#include <s32mem.h> 

#include "panics.h"

#include "ScrDev.H"

#include "windowgroup.h"

#include "wsfont.h"

#include "wstop.h"

#include "Graphics/WSGRAPHICDRAWER.H"

#include "Graphics/surfaceconfiguration.h"

#include "windowelementset.h"

#include <graphics/wsgraphicscontext.h>

#include <graphics/wsuibuffer.h>

#include "bitgditomwsgraphicscontextmappings.h"

#include "graphicscontextstate.h"

#include "drawresource.h"

#include "devicemap.h"

CPlaybackGc * CPlaybackGc::iSelf=NULL;

GLREF_C RWsRegion* InternalizeRegionL(RReadStream& aReadStream);

/*CPlaybackGc*/

void CPlaybackGc::InitStaticsL()

	{

	iSelf=new(ELeave) CPlaybackGc();

	iSelf->ConstructL();

	}

void CPlaybackGc::DeleteStatics()

	{

	delete iSelf;

	iSelf = 0;

	}

CPlaybackGc::CPlaybackGc()

	{

	}

void CPlaybackGc::ConstructL()

	{

	iGcBuf = CBufSeg::NewL(512);

	}

CPlaybackGc::~CPlaybackGc()

	{

	delete iPolyPoints;

	delete iGcBuf;

	iCurrentClippingRegion = NULL;

	iIntersectedRegion.Close();

	}

void CPlaybackGc::Activate(CWsClientWindow * aWin, MWsGraphicsContext * aGc, const TRegion * aRegion)

	{

	iWin = aWin;

	iGc = aGc;

	iTargetRegion = aRegion;

	iDrawRegion = iTargetRegion;

	iMasterOrigin = iWin->Origin();

	iOrigin.SetXY(0,0);

	iSendOrigin = ETrue;

	iGc->SetBrushColor(iWin->BackColor());

	ResetClippingRect();

	}

void CPlaybackGc::Deactivate()

	{

	iWin = 0;

	iGc = 0;

	iTargetRegion = 0;

	iDrawRegion = 0;

	CancelUserClippingRegion();

	}

void CPlaybackGc::CancelUserClippingRegion()

	{

	if (iUserDefinedClippingRegion)

		{

		iUserDefinedClippingRegion->Destroy();

		iUserDefinedClippingRegion = 0;

		iDrawRegion = iTargetRegion;

		}

	}

void CPlaybackGc::SetClippingRect(const TRect &aRect)

	{

	iClippingRect=aRect;

	iClippingRect.Move(iOrigin);

	iClippingRectSet=ETrue;

	}

void CPlaybackGc::ResetClippingRect()

	{

	iClippingRectSet=EFalse;

	}

void CPlaybackGc::CheckPolyData(const TAny* aDataPtr, TInt aHeaderSize, TInt aNumPoints)

	{

	TInt maxDataLen;

	if (CWsClient::iCurrentCommand.iOpcode>0)

		{

		maxDataLen=CWsClient::EndOfCommandBuffer()-static_cast<const TUint8*>(aDataPtr);

		}

	else

		{

		maxDataLen=CWsClient::iCurrentCommand.iCmdLength;

		}

	const TInt dataSize=aHeaderSize+aNumPoints*sizeof(TPoint);

	if (dataSize>maxDataLen)

		GcOwnerPanic(EWservPanicBadPolyData);

	}

void CPlaybackGc::DoDrawPolygon(const TWsGcCmdDrawPolygon *aDrawPolygon)

	{

	CheckPolyData(aDrawPolygon, sizeof(TWsGcCmdDrawPolygon), aDrawPolygon->numPoints);

	TArrayWrapper<TPoint> points((TPoint*)(aDrawPolygon + 1), aDrawPolygon->numPoints);

	iGc->DrawPolygon(points, BitGdiToMWsGraphicsContextMappings::Convert(aDrawPolygon->fillRule));

	}

void CPlaybackGc::StartSegmentedDrawPolygonL(const TWsGcCmdStartSegmentedDrawPolygon *aDrawPolygon)

	{

// In case a Playback have been done before all the segment is in the RedrawStore

// (This allocation is deleted only thanks to the EWsGcOpDrawSegmentedPolygon opcode

//  which arrive after all the segments)

	if (iPolyPoints)

		{

		delete iPolyPoints;

		iPolyPoints=NULL;	

		}

	if(!Rng(0, aDrawPolygon->totalNumPoints, KMaxTInt/2 - 1))

		GcOwnerPanic(EWservPanicBadPolyData);	

	iPolyPoints=(TPoint *)User::AllocL(aDrawPolygon->totalNumPoints*sizeof(TPoint));

	iPolyPointListSize=aDrawPolygon->totalNumPoints;

	}

void CPlaybackGc::SegmentedDrawPolygonData(const TWsGcCmdSegmentedDrawPolygonData *aDrawPolygon)

	{

	if (aDrawPolygon->index<0 || (aDrawPolygon->index + aDrawPolygon->numPoints) > iPolyPointListSize)

		GcOwnerPanic(EWservPanicBadPolyData);

	Mem::Copy(iPolyPoints+aDrawPolygon->index,aDrawPolygon+1,aDrawPolygon->numPoints*sizeof(TPoint));

	}

void CPlaybackGc::EndSegmentedPolygon()

	{

	delete iPolyPoints;

	iPolyPoints=NULL;

	}

void CPlaybackGc::DoDrawPolyLine(const TWsGcCmdDrawPolyLine *aDrawPolyLine, TBool aContinued)

	{

	TInt numPoints=aDrawPolyLine->numPoints;

	CheckPolyData(aDrawPolyLine, sizeof(TWsGcCmdDrawPolyLine), numPoints);

	const TPoint *points=(TPoint *)(aDrawPolyLine+1);

	if (aContinued)

		{

		numPoints++;

		points=&aDrawPolyLine->last;

		}

	TArrayWrapper<TPoint> pointsArr(points, numPoints);

	if (aDrawPolyLine->more)	// more to come so don't draw the end point

		iGc->DrawPolyLineNoEndPoint(pointsArr);

	else

		iGc->DrawPolyLine(pointsArr);

	}

void CPlaybackGc::GcOwnerPanic(TClientPanic aPanic)

	{

	iGc->ResetClippingRegion();

	iCurrentClippingRegion = NULL;

	EndSegmentedPolygon();

	iWin->WsOwner()->PPanic(aPanic);

	}

// implementing MWsGc

MWsClient& CPlaybackGc::Client()

	{

	return *(iWin->WsOwner());

	}

MWsScreen& CPlaybackGc::Screen()

	{

	return *(iWin->Screen());

	}

const TTime& CPlaybackGc::Now() const

	{

	return iWin->Screen()->Now();

	}

void CPlaybackGc::ScheduleAnimation(const TRect& aRect,const TTimeIntervalMicroSeconds& aFromNow)

	{

	ScheduleAnimation(aRect,aFromNow,0,0);

	}

void CPlaybackGc::ScheduleAnimation(const TRect& aRect,const TTimeIntervalMicroSeconds& aFromNow,const TTimeIntervalMicroSeconds& aFreq,const TTimeIntervalMicroSeconds& aStop)

	{

	// convert window rect to screen rect

	TRect rect(aRect);

	rect.Move(iGc->Origin());

	// clip rect to window extent

	rect.Intersection(iWin->Abs());

	if (!rect.IsEmpty())

		{

		// and schedule it

		iWin->Screen()->ScheduleAnimation(ECrpAnim, rect, aFromNow, aFreq, aStop, iWin);

		}

	}

void CPlaybackGc::SetGcOrigin(const TPoint& aOrigin) 

	{

	iOrigin = aOrigin - iMasterOrigin;

	} 

void CPlaybackGc::RemoteReadDataAndDrawL(const CWsGraphicDrawer* aGraphic, CWsClient* aOwner, const TWsGcCmdUnion &aData)

	{

	TPtrC8 data;

	HBufC8* dataBuf = NULL;

	const TInt len = aData.WsGraphic->iDataLen;

	if ((len >= KMaxTInt / 4) || (len < 0))

		{

		aOwner->PPanic(EWservPanicBuffer);	

		}	

	dataBuf = HBufC8::NewLC(len);

	TPtr8 des = dataBuf->Des();

	aOwner->RemoteRead(des, 0);

	if(des.Size() != len)

		{

		aOwner->PPanic(EWservPanicBuffer);

		}

	data.Set(des);																

	aGraphic->Draw(*this, aData.WsGraphic->iRect, data);

	CleanupStack::PopAndDestroy(dataBuf);		

	}

TPtrC CPlaybackGc::BufferTPtr(TText* aStart,TInt aLen, const TDesC8& aCmdData)

	{

	if ((reinterpret_cast<TUint8*>(aStart) < aCmdData.Ptr()

									|| reinterpret_cast<TUint8*>(aStart+aLen) > (aCmdData.Ptr() + aCmdData.Size()) ))

		{

		GcOwnerPanic(EWservPanicBufferPtr);

		}

	TPtrC gcPtr;

	gcPtr.Set(aStart,aLen);

	return(gcPtr);

	} 

void CPlaybackGc::DoDrawCommand(TWsGcOpcodes aOpcode, const TDesC8& aCmdData, const TRegion *aRegion)

	{

    if (aRegion->Count()==0)

        return;

    TWsGcCmdUnion pData;

	// coverity[returned_pointer]

	pData.any=aCmdData.Ptr();

	SendClippingRegionIfRequired(aRegion);

	WS_ASSERT_DEBUG(!iCurrentClippingRegion, EWsPanicDrawCommandsInvalidState);

	iCurrentClippingRegion = aRegion;

	CGraphicsContext::TTextParameters contextParam;

	TBool bGcDrawingOccurred = ETrue;	//most commands in here draw using the gc

	switch(aOpcode)

		{

		case EWsGcOpDrawWsGraphic:

		case EWsGcOpDrawWsGraphicPtr:

			{

			bGcDrawingOccurred = EFalse;	//best guess if the drawer did no happen 

			TRect screenRect(pData.WsGraphic->iRect);

			screenRect.Move(iGc->Origin());

			if(iCurrentClippingRegion->Intersects(screenRect))

				{

				const TInt dataLen = pData.WsGraphic->iDataLen;

				TGraphicDrawerId id;

				id.iId = pData.WsGraphic->iId;

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

				CWsClient* owner = iWin->WsOwner();

				const CWsGraphicDrawer* graphic = CWsTop::WindowServer()->ResolveGraphic(id);

				TInt lastDrawCount=GcDrawingCount();

				if(graphic && graphic->IsSharedWith(owner->SecureId()))

					{

					if(aOpcode == EWsGcOpDrawWsGraphicPtr)

						{

						TRAPD(err, RemoteReadDataAndDrawL(graphic, owner, pData))

						if(err)

							WS_PANIC_DEBUG(EWsPanicWsGraphic);

						}

					else

						graphic->Draw(*this,pData.WsGraphic->iRect,CWsClient::BufferTPtr8((TUint8*)(pData.WsGraphic+1),dataLen));

					WS_ASSERT_DEBUG(!iGcBuf->Size(),EWsPanicWsGraphic);

					iGcBuf->Reset();

					}

				if (lastDrawCount!=GcDrawingCount())

					{

					// Changes to the GcDrawingCount are used to tag placed and background surfaces as dirty.

					// If drawing occurs inside a CRP and perhaps PlaceSurface occurs inside the CRP 

					// then we tag to count again to cause the placed surface to get marked as dirty later.

					bGcDrawingOccurred = ETrue;	//some GC drawing did occurr at some point

					}

				}

			break;

			}

		case EWsGcOpMapColorsLocal:

			GcOwnerPanic(EWservPanicOpcode); //deprecated, the client should never generate this op

			break;

		case EWsGcOpDrawPolyLineLocalBufLen:

			{

			TArrayWrapper<TPoint> points(pData.DrawPolyLineLocalBufLen->points, pData.DrawPolyLineLocalBufLen->length);

			iGc->DrawPolyLine(points);

			break;

			}

		case EWsGcOpDrawPolyLineLocal:

			iGc->DrawPolyLine(pData.PointList->Array());

			break;

		case EWsGcOpDrawPolygonLocalBufLen:

			{

			TArrayWrapper<TPoint> points(pData.DrawPolygonLocalBufLen->points, pData.DrawPolygonLocalBufLen->length);

			iGc->DrawPolygon(points, BitGdiToMWsGraphicsContextMappings::Convert(pData.DrawPolygonLocalBufLen->fillRule));

			break;

			}

		case EWsGcOpDrawPolygonLocal:

			iGc->DrawPolygon(pData.DrawPolygonLocal->pointList->Array(),BitGdiToMWsGraphicsContextMappings::Convert(pData.DrawPolygonLocal->fillRule));

			break;

		case EWsGcOpDrawBitmapLocal:

			{

			// DrawBitmap(TPoint&, ) uses the size of the bitmap in twips, but 

			// MWsGraphicsContext::DrawBitmap() takes a TRect in pixels, so we need to convert

			TRect destRect(iWin->Screen()->DeviceMap().TwipsToPixels(pData.BitmapLocal->bitmap->SizeInTwips()));

			destRect.Move(pData.BitmapLocal->pos); //pos is defined in pixels, that's why we're not converting it

			iGc->DrawBitmap(destRect, *pData.BitmapLocal->bitmap);

			break;

			}

		case EWsGcOpDrawBitmap2Local:

			iGc->DrawBitmap(pData.Bitmap2Local->rect, *pData.Bitmap2Local->bitmap);

			break;

		case EWsGcOpDrawBitmap3Local:

			iGc->DrawBitmap(pData.Bitmap3Local->rect, *pData.Bitmap3Local->bitmap, pData.Bitmap3Local->srcRect);

			break;

		case EWsGcOpDrawBitmapMaskedLocal:

			iGc->DrawBitmapMasked(pData.iBitmapMaskedLocal->iRect, *pData.iBitmapMaskedLocal->iBitmap, pData.iBitmapMaskedLocal->iSrcRect, *pData.iBitmapMaskedLocal->iMaskBitmap,pData.iBitmapMaskedLocal->iInvertMask);

			break;

		case EWsGcOpAlphaBlendBitmapsLocal:

			iGc->BitBltMasked(pData.AlphaBlendBitmapsLocal->point, *pData.AlphaBlendBitmapsLocal->iBitmap,

						                  pData.AlphaBlendBitmapsLocal->source, *pData.AlphaBlendBitmapsLocal->iAlpha,

						                  pData.AlphaBlendBitmapsLocal->alphaPoint);

			break;

		case EWsGcOpDrawText:

			if (iGc->HasFont())

				iGc->DrawText(BufferTPtr((TText *)(pData.DrawText+1),pData.DrawText->length,aCmdData), NULL, pData.DrawText->pos);

			break;

		case EWsGcOpDrawBoxTextOptimised1:

			if (iGc->HasFont())

				iGc->DrawText(BufferTPtr((TText *)(pData.BoxTextO1+1),pData.BoxTextO1->length,aCmdData), NULL, pData.BoxTextO1->box,

							  pData.BoxTextO1->baselineOffset,MWsGraphicsContext::ELeft,0);

			break;

		case EWsGcOpDrawBoxTextOptimised2:

			if (iGc->HasFont())

				iGc->DrawText(BufferTPtr((TText *)(pData.BoxTextO2+1),pData.BoxTextO2->length,aCmdData), NULL, pData.BoxTextO2->box,

							  pData.BoxTextO2->baselineOffset,BitGdiToMWsGraphicsContextMappings::Convert(pData.BoxTextO2->horiz),pData.BoxTextO2->leftMrg);

			break;

		case EWsGcOpDrawTextPtr:

			if (iGc->HasFont())

				iGc->DrawText(*pData.DrawTextPtr->text, NULL, pData.DrawTextPtr->pos);

			break;

		case EWsGcOpDrawTextPtr1:

			if (iGc->HasFont())

				iGc->DrawText(*pData.DrawTextPtr->text, NULL);

			break;

		case EWsGcOpDrawBoxText:

			if (iGc->HasFont())

				iGc->DrawText(BufferTPtr((TText *)(pData.BoxText+1),pData.BoxText->length,aCmdData), NULL, pData.BoxText->box,

							  pData.BoxText->baselineOffset,BitGdiToMWsGraphicsContextMappings::Convert(pData.BoxText->horiz),pData.BoxText->leftMrg);

			break;

		case EWsGcOpDrawBoxTextPtr:

			if (iGc->HasFont())

				iGc->DrawText(*pData.DrawBoxTextPtr->text, NULL, pData.DrawBoxTextPtr->box,pData.DrawBoxTextPtr->baselineOffset,BitGdiToMWsGraphicsContextMappings::Convert(pData.DrawBoxTextPtr->horiz),pData.DrawBoxTextPtr->leftMrg);

			break;

		case EWsGcOpDrawBoxTextPtr1:

			if (iGc->HasFont())

				iGc->DrawText(*pData.DrawBoxTextPtr->text, NULL, pData.DrawBoxTextPtr->box);

			break;

		case EWsGcOpDrawTextVertical:

			if (iGc->HasFont())

				iGc->DrawTextVertical(BufferTPtr((TText *)(pData.DrawTextVertical+1),pData.DrawTextVertical->length,aCmdData),NULL,pData.DrawTextVertical->pos

							          ,pData.DrawTextVertical->up);

			break;

		case EWsGcOpDrawTextVerticalPtr:

			if (iGc->HasFont())

				iGc->DrawTextVertical(*pData.DrawTextVerticalPtr->text,NULL,pData.DrawTextVerticalPtr->pos,pData.DrawTextVerticalPtr->up);

			break;

		case EWsGcOpDrawTextVerticalPtr1:

			if (iGc->HasFont())

				iGc->DrawTextVertical(*pData.DrawTextVerticalPtr->text,NULL,pData.DrawTextVerticalPtr->up);

			break;

		case EWsGcOpDrawBoxTextVertical:

			if (iGc->HasFont())

				iGc->DrawTextVertical(BufferTPtr((TText *)(pData.DrawBoxTextVertical+1),pData.DrawBoxTextVertical->length,aCmdData), NULL,

									  pData.DrawBoxTextVertical->box,	pData.DrawBoxTextVertical->baselineOffset,

									  pData.DrawBoxTextVertical->up,BitGdiToMWsGraphicsContextMappings::Convert(pData.DrawBoxTextVertical->vert),pData.DrawBoxTextVertical->margin);

			break;

		case EWsGcOpDrawBoxTextVerticalPtr:

			if (iGc->HasFont())

				iGc->DrawTextVertical(*pData.DrawBoxTextVerticalPtr->text,NULL,pData.DrawBoxTextVerticalPtr->box,pData.DrawBoxTextVerticalPtr->baselineOffset

									  ,pData.DrawBoxTextVerticalPtr->width,pData.DrawBoxTextVerticalPtr->up,BitGdiToMWsGraphicsContextMappings::Convert(pData.DrawBoxTextVerticalPtr->vert),pData.DrawBoxTextVerticalPtr->margin);

			break;

		case EWsGcOpDrawBoxTextVerticalPtr1:

			if (iGc->HasFont())

				iGc->DrawTextVertical(*pData.DrawBoxTextVerticalPtr->text,NULL,pData.DrawBoxTextVerticalPtr->box,pData.DrawBoxTextVerticalPtr->up);

			break;

		case EWsGcOpDrawTextLocal:

			if (iGc->HasFont())

				iGc->DrawText(*pData.DrawTextLocal->desc, NULL, pData.DrawTextLocal->pos);

			break;

		case EWsGcOpDrawBoxTextLocal:

			if (iGc->HasFont())

				iGc->DrawText(*pData.BoxTextLocal->desc, NULL, pData.BoxTextLocal->box,pData.BoxTextLocal->baselineOffset,

							  BitGdiToMWsGraphicsContextMappings::Convert(pData.BoxTextLocal->horiz),pData.BoxTextLocal->leftMrg);

			break;

		/************* DrawText in Context function calls*********************************************/

		case EWsGcOpDrawTextInContext:

			contextParam.iStart = pData.DrawTextInContext->start;

			contextParam.iEnd = pData.DrawTextInContext->end;

			if((contextParam.iStart < contextParam.iEnd) && (iGc->HasFont()))

				{

				iGc->DrawText(BufferTPtr((TText *)(pData.DrawTextInContext+1),pData.DrawTextInContext->length,aCmdData),BitGdiToMWsGraphicsContextMappings::Convert(&contextParam),pData.DrawTextInContext->pos);

				}

			break;

		case EWsGcOpDrawBoxTextInContextOptimised1:

			contextParam.iStart = pData.BoxTextInContextO1->start;

			contextParam.iEnd = pData.BoxTextInContextO1->end;

			if((contextParam.iStart < contextParam.iEnd) && (iGc->HasFont()))

				{

				iGc->DrawText(BufferTPtr((TText *)(pData.BoxTextInContextO1+1),pData.BoxTextInContextO1->length,aCmdData),BitGdiToMWsGraphicsContextMappings::Convert(&contextParam),pData.BoxTextInContextO1->box,

							  pData.BoxTextInContextO1->baselineOffset,MWsGraphicsContext::ELeft,0);

				}

			break;

		case EWsGcOpDrawBoxTextInContextOptimised2:

			contextParam.iStart = pData.BoxTextInContextO2->start;

			contextParam.iEnd = pData.BoxTextInContextO2->end;

			if((contextParam.iStart < contextParam.iEnd) && (iGc->HasFont()))

				{

				iGc->DrawText(BufferTPtr((TText *)(pData.BoxTextInContextO2+1),pData.BoxTextInContextO2->length,aCmdData),BitGdiToMWsGraphicsContextMappings::Convert(&contextParam),pData.BoxTextInContextO2->box,

							  pData.BoxTextInContextO2->baselineOffset,BitGdiToMWsGraphicsContextMappings::Convert(pData.BoxTextInContextO2->horiz),pData.BoxTextInContextO2->leftMrg);

				}

			break;

		case EWsGcOpDrawTextInContextPtr:

			contextParam.iStart = pData.DrawTextInContextPtr->start;

			contextParam.iEnd = pData.DrawTextInContextPtr->end;

			if((contextParam.iStart < contextParam.iEnd) && (iGc->HasFont()))

				{

				iGc->DrawText(*pData.DrawTextInContextPtr->text,BitGdiToMWsGraphicsContextMappings::Convert(&contextParam),pData.DrawTextInContextPtr->pos);

				}

			break;

		case EWsGcOpDrawTextInContextPtr1:

			contextParam.iStart = pData.DrawTextInContextPtr->start;

			contextParam.iEnd = pData.DrawTextInContextPtr->end;

			if((contextParam.iStart < contextParam.iEnd) && (iGc->HasFont()))

				{

				iGc->DrawText(*pData.DrawTextInContextPtr->text,BitGdiToMWsGraphicsContextMappings::Convert(&contextParam));

				}

			break;

		case EWsGcOpDrawBoxTextInContext:

			contextParam.iStart = pData.BoxTextInContext->start;

			contextParam.iEnd = pData.BoxTextInContext->end;

			if((contextParam.iStart < contextParam.iEnd) && (iGc->HasFont()))

				{

				iGc->DrawText(BufferTPtr((TText *)(pData.BoxTextInContext+1),pData.BoxTextInContext->length,aCmdData),

							  BitGdiToMWsGraphicsContextMappings::Convert(&contextParam),pData.BoxTextInContext->box,pData.BoxTextInContext->baselineOffset,

							  BitGdiToMWsGraphicsContextMappings::Convert(pData.BoxTextInContext->horiz),pData.BoxTextInContext->leftMrg);

				}

			break;

		case EWsGcOpDrawBoxTextInContextPtr:

			contextParam.iStart = pData.DrawBoxTextInContextPtr->start;

			contextParam.iEnd = pData.DrawBoxTextInContextPtr->end;

			if((contextParam.iStart < contextParam.iEnd) && (iGc->HasFont()))

				{

				iGc->DrawText(*pData.DrawBoxTextInContextPtr->text,BitGdiToMWsGraphicsContextMappings::Convert(&contextParam),pData.DrawBoxTextInContextPtr->box,pData.DrawBoxTextInContextPtr->baselineOffset,

							  BitGdiToMWsGraphicsContextMappings::Convert(pData.DrawBoxTextInContextPtr->horiz),pData.DrawBoxTextInContextPtr->leftMrg);

				}

			break;

		case EWsGcOpDrawBoxTextInContextPtr1:

			contextParam.iStart = pData.DrawBoxTextInContextPtr->start;

			contextParam.iEnd = pData.DrawBoxTextInContextPtr->end;

			if((contextParam.iStart < contextParam.iEnd) && (iGc->HasFont()))

				{

				iGc->DrawText(*pData.DrawBoxTextInContextPtr->text,BitGdiToMWsGraphicsContextMappings::Convert(&contextParam),pData.DrawBoxTextInContextPtr->box);

				}

			break;

		case EWsGcOpDrawTextInContextVertical:

			contextParam.iStart = pData.DrawTextInContextVertical->start;

			contextParam.iEnd = pData.DrawTextInContextVertical->end;

			if((contextParam.iStart < contextParam.iEnd) && (iGc->HasFont()))

				{

				iGc->DrawTextVertical(BufferTPtr((TText *)(pData.DrawTextInContextVertical+1),pData.DrawTextInContextVertical->length,aCmdData),

									  BitGdiToMWsGraphicsContextMappings::Convert(&contextParam),pData.DrawTextInContextVertical->pos,pData.DrawTextInContextVertical->up);

				}

			break;

		case EWsGcOpDrawTextInContextVerticalPtr:

			contextParam.iStart = pData.DrawTextInContextVerticalPtr->start;