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

#include <s32mem.h> 

#include "gc.h"

#include "backedupwindow.h"

#include "windowgroup.h"

#include "ScrDev.H"

#include "wstop.h"

#include "panics.h"

#include "Graphics/WSGRAPHICDRAWER.H"

#include "wsfont.h"

class TPlacedAttributes;

CFbsBitmap *CWsGc::iScratchBitmap=NULL;

CFbsBitmap *CWsGc::iScratchMaskBitmap=NULL;

GLREF_C TInt ExternalizeRegionL(RWriteStream& aWriteStream, const RWsRegion& aRegion);

/*CWsGc*/

CWsGc* CWsGc::NewL(CWsClient *aOwner)	

	{

	CWsGc* self = new(ELeave) CWsGc(aOwner);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CWsGc::InitStaticsL()

	{

	iScratchBitmap=new(ELeave) CFbsBitmap();

	iScratchMaskBitmap=new(ELeave) CFbsBitmap();

	}

void CWsGc::DeleteStatics()

	{

	delete iScratchBitmap;

	delete iScratchMaskBitmap;

	}

CWsGc::CWsGc(CWsClient *owner) : CWsObject(owner,WS_HANDLE_GC)

	{

	__DECLARE_NAME(_S("CWsGc"));

	}

void CWsGc::ConstructL()

	{

	NewObjL();

	iBackedUpWinGc=CFbsBitGc::NewL();

	iInternalStatus.ResetInternalStatus(iWin);

	}

void CWsGc::Activate(CWsClientWindow *win)

	{

	if (iWin!=NULL)

		{

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

			{

			WS_PANIC_ALWAYS(EWsPanicDrawCommandsInvalidState);

			}

		else

			{

			OwnerPanic(EWservPanicGcActive);

			}

		}

	iWin = win;

	if (iWin->Redraw()->OutputDevice()) // Activated on a backed up window

		iBackedUpWinGc->ActivateNoJustAutoUpdate(iWin->Redraw()->OutputDevice());

	iWin->GcActivated(this);

	iInternalStatus.iBrushColor = iWin->BackColor();

	if (iWin->Redraw()->OutputDevice())

		iBackedUpWinGc->SetBrushColor(iInternalStatus.iBrushColor);

	iOrigin.SetXY(0,0);

	ResetClippingRect();

	if(iWsOwner)

		{

		CWsWindowGroup *winGp = iWin->WinGroup();

		if(!winGp->Device())

			OwnerPanic(EWservPanicGroupWinScreenDeviceDeleted);		

		SetReply(winGp->Device()->ClientDevicePointer());			

		}	

	}

void CWsGc::Activate(const TInt &aHandle)

	{

	CWsClientWindow *win;

	iWsOwner->HandleToClientWindow(aHandle,&win);

	if (!win->BaseParent())

		OwnerPanic(EWservPanicParentDeleted);

	Activate(win);

	}

void CWsGc::Reactivate()

	{

	WS_ASSERT_DEBUG(iWin != NULL, EWsPanicDrawCommandsInvalidState);

	if (iWin->Redraw()->OutputDevice()) // Activated on a backed up window

		iBackedUpWinGc->ActivateNoJustAutoUpdate(iWin->Redraw()->OutputDevice());

	}

CWsGc::~CWsGc()

	{

	if (iWin!=NULL)

		Deactivate();

	delete iBackedUpWinGc;

	delete iPolyPoints;

	}

void CWsGc::Deactivate()

	{

	if (iWin)	// Protect against deactivating an already deactivated GC, this is allowed to aid clean up code.

		{

		CWsFontCache::Instance()->ReleaseFont(iFont);

		iBackedUpWinGc->Reset();

		iInternalStatus.ResetInternalStatus(iWin);

		iWin->GcDeactivated(this);

		CancelClippingRegion();

		iWin->Redraw()->GcDeactivate(this);

		iWin=NULL;

		}

	}

void CWsGc::SetClippingRect(const TRect &aRect)

	{

	iClippingRect=aRect;

	iClippingRect.Move(iOrigin);

	iClippingRectSet=ETrue;

	}

void CWsGc::ResetClippingRect()

	{

	iClippingRectSet=EFalse;

	}

void CWsGc::SetClippingRegionL(TInt aRegionCount)

	{

	RWsRegion *newRegion=GetRegionFromClientL(iWsOwner, aRegionCount);

	CancelClippingRegion();

	iUserDefinedClippingRegion=newRegion;

	if (iUserDefinedClippingRegion)

		{

		iUserDefinedClippingRegion->Offset(iOrigin);

		}

	}

void CWsGc::CancelClippingRegion()

	{

	if (iUserDefinedClippingRegion)

		{

		iUserDefinedClippingRegion->Destroy();

		iUserDefinedClippingRegion=NULL;

		}

	}

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

	{

	TInt maxDataLen;

	if (CWsClient::iCurrentCommand.iOpcode>0)

		{

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

		}

	else	// Playing back from redraw store??

		{

		maxDataLen=CWsClient::iCurrentCommand.iCmdLength;

		}

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

	if (dataSize>maxDataLen)

		GcOwnerPanic(EWservPanicBadPolyData);

	}

void CWsGc::DoDrawPolygon(const TWsGcCmdDrawPolygon *aDrawPolygon)

	{

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

	iBackedUpWinGc->DrawPolygon((TPoint *)(aDrawPolygon+1),aDrawPolygon->numPoints,aDrawPolygon->fillRule);

	}

void CWsGc::StartSegmentedDrawPolygonL(const TWsGcCmdStartSegmentedDrawPolygon* aDrawPolygon)

	{

	WS_ASSERT_DEBUG(iWin->Redraw()->OutputDevice(), EWsPanicWindowType);

	if (iPolyPoints || !Rng(0, aDrawPolygon->totalNumPoints, KMaxTInt/2 - 1))	// Restarting without finishing old polygon or invalid size

		GcOwnerPanic(EWservPanicBadPolyData);

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

	iPolyPointListSize=aDrawPolygon->totalNumPoints;

	}

void CWsGc::SegmentedDrawPolygonData(const TWsGcCmdSegmentedDrawPolygonData* aDrawPolygon)

	{

	WS_ASSERT_DEBUG(iWin->Redraw()->OutputDevice(), EWsPanicWindowType);

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

		GcOwnerPanic(EWservPanicBadPolyData);

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

	}

void CWsGc::EndSegmentedPolygon()

	{

	delete iPolyPoints;

	iPolyPoints=NULL;

	iPolyPointListSize = 0;

	}

void CWsGc::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;

		}

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

		iBackedUpWinGc->DrawPolyLineNoEndPoint(points,numPoints);

	else

		iBackedUpWinGc->DrawPolyLine(points,numPoints);

	}

void CWsGc::GcOwnerPanic(TClientPanic aPanic)

	{

	iBackedUpWinGc->SetClippingRegion(NULL);

	EndSegmentedPolygon();

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

	}

TPtrC CWsGc::BufferTPtr(TText* aStart,TInt aLen)

	{

	TPtrC gcPtr;

	if (!CWsClient::BufferTPtrGc(aStart,aLen,gcPtr))

		GcOwnerPanic(EWservPanicBufferPtr);

	return(gcPtr);

	}

void CWsGc::DoDrawCommand(TWsGcOpcodes aOpcode, const TWsGcCmdUnion &pData)

	{

	WS_ASSERT_DEBUG(iWin,EWsPanicWindowNull);

	WS_ASSERT_DEBUG(iWin->Redraw()->OutputDevice(), EWsPanicWindowType); // Must be activated on a backed up window

	if (iUserDefinedClippingRegion)

		{

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

			return;

		if (iUserDefinedClippingRegion->IsContainedBy(TRect(TPoint(0,0), iBackedUpWinGc->Device()->SizeInPixels())))

			{

			iBackedUpWinGc->SetClippingRegion(iUserDefinedClippingRegion);

			}

		}

	CGraphicsContext::TTextParameters contextParam;

	switch(aOpcode)

		{

		case EWsGcOpDrawWsGraphic:

		case EWsGcOpDrawWsGraphicPtr:

			{

			// CWsGc doesn't support CRPs.  CPlaybackGc does.  This means backedup windows

			// don't get to play with them yet.

			break;

			}

		case EWsGcOpMapColorsLocal:

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

			break;

		case EWsGcOpDrawPolyLineLocalBufLen:

			iBackedUpWinGc->DrawPolyLine(pData.DrawPolyLineLocalBufLen->points,pData.DrawPolyLineLocalBufLen->length);

			break;

		case EWsGcOpDrawPolyLineLocal:

			iBackedUpWinGc->DrawPolyLine(pData.PointList);

			break;

		case EWsGcOpDrawPolygonLocalBufLen:

			iBackedUpWinGc->DrawPolygon(pData.DrawPolygonLocalBufLen->points,pData.DrawPolygonLocalBufLen->length,pData.DrawPolygonLocalBufLen->fillRule);

			break;

		case EWsGcOpDrawPolygonLocal:

			iBackedUpWinGc->DrawPolygon(pData.DrawPolygonLocal->pointList,pData.DrawPolygonLocal->fillRule);

			break;

		case EWsGcOpDrawBitmapLocal:

			iBackedUpWinGc->DrawBitmap(pData.BitmapLocal->pos, pData.BitmapLocal->bitmap);

			break;

		case EWsGcOpDrawBitmap2Local:

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

			break;

		case EWsGcOpDrawBitmap3Local:

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

			break;

		case EWsGcOpDrawBitmapMaskedLocal:

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

			break;

		case EWsGcOpAlphaBlendBitmapsLocal:

			iBackedUpWinGc->AlphaBlendBitmaps(pData.AlphaBlendBitmapsLocal->point,pData.AlphaBlendBitmapsLocal->iBitmap,

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

									pData.AlphaBlendBitmapsLocal->alphaPoint);

			break;

		case EWsGcOpDrawText:

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

			break;

		case EWsGcOpDrawBoxTextOptimised1:

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

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

			break;

		case EWsGcOpDrawBoxTextOptimised2:

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

							pData.BoxTextO2->baselineOffset,pData.BoxTextO2->horiz,pData.BoxTextO2->leftMrg);

			break;

		case EWsGcOpDrawTextPtr:

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

			break;

		case EWsGcOpDrawTextPtr1:

		   	iBackedUpWinGc->DrawText(*pData.DrawTextPtr->text);

			break;

		case EWsGcOpDrawBoxText:

			iBackedUpWinGc->DrawText(BufferTPtr((TText *)(pData.BoxText+1),pData.BoxText->length),pData.BoxText->box,pData.BoxText->baselineOffset,pData.BoxText->width,pData.BoxText->horiz,pData.BoxText->leftMrg);

			break;

		case EWsGcOpDrawBoxTextPtr:

			iBackedUpWinGc->DrawText(*pData.DrawBoxTextPtr->text,pData.DrawBoxTextPtr->box,pData.DrawBoxTextPtr->baselineOffset,pData.DrawBoxTextPtr->width,pData.DrawBoxTextPtr->horiz,pData.DrawBoxTextPtr->leftMrg);

			break;

		case EWsGcOpDrawBoxTextPtr1:

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

			break;

		case EWsGcOpDrawTextVertical:

			iBackedUpWinGc->DrawTextVertical(BufferTPtr((TText *)(pData.DrawTextVertical+1),pData.DrawTextVertical->length),pData.DrawTextVertical->pos

							,pData.DrawTextVertical->up);

			break;

		case EWsGcOpDrawTextVerticalPtr:

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

			break;

		case EWsGcOpDrawTextVerticalPtr1:

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

			break;

		case EWsGcOpDrawBoxTextVertical:

			iBackedUpWinGc->DrawTextVertical(BufferTPtr((TText *)(pData.DrawBoxTextVertical+1),pData.DrawBoxTextVertical->length),

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

							pData.DrawBoxTextVertical->up,(CGraphicsContext::TTextAlign)pData.DrawBoxTextVertical->vert,pData.DrawBoxTextVertical->margin);

			break;

		case EWsGcOpDrawBoxTextVerticalPtr:

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

							,pData.DrawBoxTextVerticalPtr->width,pData.DrawBoxTextVerticalPtr->up,pData.DrawBoxTextVerticalPtr->vert,pData.DrawBoxTextVerticalPtr->margin);

			break;

		case EWsGcOpDrawBoxTextVerticalPtr1:

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

			break;

		case EWsGcOpDrawTextLocal:

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

			break;

		case EWsGcOpDrawBoxTextLocal:

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

							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)

				{

				iBackedUpWinGc->DrawText(BufferTPtr((TText *)(pData.DrawTextInContext+1),pData.DrawTextInContext->length),&contextParam,pData.DrawTextInContext->pos);

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawBoxTextInContextOptimised1:

			contextParam.iStart = pData.BoxTextInContextO1->start;

			contextParam.iEnd = pData.BoxTextInContextO1->end;

			if(contextParam.iStart < contextParam.iEnd)

				{

				iBackedUpWinGc->DrawText(BufferTPtr((TText *)(pData.BoxTextInContextO1+1),pData.BoxTextInContextO1->length),&contextParam,pData.BoxTextInContextO1->box,

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

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawBoxTextInContextOptimised2:

			contextParam.iStart = pData.BoxTextInContextO2->start;

			contextParam.iEnd = pData.BoxTextInContextO2->end;

			if(contextParam.iStart < contextParam.iEnd)

				{

				iBackedUpWinGc->DrawText(BufferTPtr((TText *)(pData.BoxTextInContextO2+1),pData.BoxTextInContextO2->length),&contextParam,pData.BoxTextInContextO2->box,

						pData.BoxTextInContextO2->baselineOffset,pData.BoxTextInContextO2->horiz,pData.BoxTextInContextO2->leftMrg);

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawTextInContextPtr:

			contextParam.iStart = pData.DrawTextInContextPtr->start;

			contextParam.iEnd = pData.DrawTextInContextPtr->end;

			if(contextParam.iStart < contextParam.iEnd)

				{

				iBackedUpWinGc->DrawText(*pData.DrawTextInContextPtr->text,&contextParam,pData.DrawTextInContextPtr->pos);

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawTextInContextPtr1:

			contextParam.iStart = pData.DrawTextInContextPtr->start;

			contextParam.iEnd = pData.DrawTextInContextPtr->end;

			if(contextParam.iStart < contextParam.iEnd)

				{

				iBackedUpWinGc->DrawText(*pData.DrawTextInContextPtr->text,&contextParam);

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawBoxTextInContext:

			contextParam.iStart = pData.BoxTextInContext->start;

			contextParam.iEnd = pData.BoxTextInContext->end;

			if(contextParam.iStart < contextParam.iEnd)

				{

				iBackedUpWinGc->DrawText(BufferTPtr((TText *)(pData.BoxTextInContext+1),pData.BoxTextInContext->length),&contextParam,

						pData.BoxTextInContext->box,pData.BoxTextInContext->baselineOffset,pData.BoxTextInContext->width,pData.BoxTextInContext->horiz,pData.BoxTextInContext->leftMrg);

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawBoxTextInContextPtr:

			contextParam.iStart = pData.DrawBoxTextInContextPtr->start;

			contextParam.iEnd = pData.DrawBoxTextInContextPtr->end;

			if(contextParam.iStart < contextParam.iEnd)

				{

				iBackedUpWinGc->DrawText(*pData.DrawBoxTextInContextPtr->text,&contextParam,pData.DrawBoxTextInContextPtr->box,pData.DrawBoxTextInContextPtr->baselineOffset,pData.DrawBoxTextInContextPtr->width,pData.DrawBoxTextInContextPtr->horiz,pData.DrawBoxTextInContextPtr->leftMrg);

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawBoxTextInContextPtr1:

			contextParam.iStart = pData.DrawBoxTextInContextPtr->start;

			contextParam.iEnd = pData.DrawBoxTextInContextPtr->end;

			if(contextParam.iStart < contextParam.iEnd)

				{

				iBackedUpWinGc->DrawText(*pData.DrawBoxTextInContextPtr->text,&contextParam,pData.DrawBoxTextInContextPtr->box);

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawTextInContextVertical:

			contextParam.iStart = pData.DrawTextInContextVertical->start;

			contextParam.iEnd = pData.DrawTextInContextVertical->end;

			if(contextParam.iStart < contextParam.iEnd)

				{

				iBackedUpWinGc->DrawTextVertical(BufferTPtr((TText *)(pData.DrawTextInContextVertical+1),pData.DrawTextInContextVertical->length),&contextParam,pData.DrawTextInContextVertical->pos

						,pData.DrawTextInContextVertical->up);

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawTextInContextVerticalPtr:

			contextParam.iStart = pData.DrawTextInContextVerticalPtr->start;

			contextParam.iEnd = pData.DrawTextInContextVerticalPtr->end;

			if(contextParam.iStart < contextParam.iEnd)

				{

				iBackedUpWinGc->DrawTextVertical(*pData.DrawTextInContextVerticalPtr->text,&contextParam,pData.DrawTextInContextVerticalPtr->pos,pData.DrawTextInContextVerticalPtr->up);

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawTextInContextVerticalPtr1:

			contextParam.iStart = pData.DrawTextInContextVerticalPtr->start;

			contextParam.iEnd = pData.DrawTextInContextVerticalPtr->end;

			if(contextParam.iStart < contextParam.iEnd)

				{

				iBackedUpWinGc->DrawTextVertical(*pData.DrawTextInContextVerticalPtr->text,&contextParam,pData.DrawTextInContextVerticalPtr->up);

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawBoxTextInContextVertical:

			contextParam.iStart = pData.DrawBoxTextInContextVertical->start;

			contextParam.iEnd = pData.DrawBoxTextInContextVertical->end;

			if(contextParam.iStart < contextParam.iEnd)

				{

				iBackedUpWinGc->DrawTextVertical(BufferTPtr((TText *)(pData.DrawBoxTextInContextVertical+1),pData.DrawBoxTextInContextVertical->length),&contextParam,

						pData.DrawBoxTextInContextVertical->box,pData.DrawBoxTextInContextVertical->baselineOffset,

						pData.DrawBoxTextInContextVertical->up,(CGraphicsContext::TTextAlign)pData.DrawBoxTextInContextVertical->vert,pData.DrawBoxTextInContextVertical->margin);

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawBoxTextInContextVerticalPtr:

			contextParam.iStart = pData.DrawBoxTextInContextVerticalPtr->start;

			contextParam.iEnd = pData.DrawBoxTextInContextVerticalPtr->end;

			if(contextParam.iStart < contextParam.iEnd)

				{

				iBackedUpWinGc->DrawTextVertical(*pData.DrawBoxTextVerticalPtr->text,&contextParam,pData.DrawBoxTextVerticalPtr->box,pData.DrawBoxTextVerticalPtr->baselineOffset

						,pData.DrawBoxTextVerticalPtr->width,pData.DrawBoxTextVerticalPtr->up,pData.DrawBoxTextVerticalPtr->vert,pData.DrawBoxTextVerticalPtr->margin);

				}

			else

				{

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

				}

			break;

		case EWsGcOpDrawBoxTextInContextVerticalPtr1:

			contextParam.iStart = pData.DrawBoxTextInContextVerticalPtr->start;