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

// GC and Graphics functions

// 

//

#include "playbackgc.h"

#include <e32std.h>

#include <s32mem.h> 

#include "backedupwindow.h"

#include "panics.h"

#include "ScrDev.H"

#include "windowgroup.h"

#include "wsfont.h"

#include "wstop.h"

#include "Graphics/WSGRAPHICDRAWER.H"

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

#   include "offscreenbitmap.h"

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

#else

#	define DEBUGOSB

#endif

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

	{

	iSelf->iScratchBitmap=new(ELeave) CFbsBitmap();

	iSelf->iScratchMaskBitmap=new(ELeave) CFbsBitmap();

	iGcBuf = CBufSeg::NewL(512);

	}

CPlaybackGc::~CPlaybackGc()

	{

	delete iPolyPoints;

	delete iGcBuf;

	iCurrentClippingRegion = NULL;

	delete iScratchBitmap;

	delete iScratchMaskBitmap;

	}

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

	{

	iWin = aWin;

	iGc = aGc;

	iTargetRegion = aRegion;

	iDrawRegion = iTargetRegion;

	iMasterOrigin = iWin->Origin();

	iOrigin.SetXY(0,0);

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

	iGc->DrawPolygon((TPoint *)(aDrawPolygon+1),aDrawPolygon->numPoints,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)

	delete iPolyPoints;

	iPolyPoints=NULL;	

	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;

		}

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

		iGc->DrawPolyLineNoEndPoint(points,numPoints);

	else

		iGc->DrawPolyLine(points,numPoints);

	}

void CPlaybackGc::GcOwnerPanic(TClientPanic aPanic)

	{

	iGc->SetClippingRegion(NULL);

	iCurrentClippingRegion = NULL;

	EndSegmentedPolygon();

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

	}

// implementing MWsGc

MWsClient& CPlaybackGc::Client()

	{

	return *(iWin->WsOwner());

	}

MWsScreen& CPlaybackGc::Screen()

	{

	return *(iWin->Screen());

	}

TPoint CPlaybackGc::GcOrigin() const

	{

	return (iMasterOrigin + iOrigin);

	}

const TRegion& CPlaybackGc::ClippingRegion()

	{

	WS_ASSERT_ALWAYS(iCurrentClippingRegion,EWsPanicDrawCommandsInvalidState);

	return* iCurrentClippingRegion;

	}

CFbsBitGc& CPlaybackGc::BitGc()

	{

	return *iGc;

	}

TInt CPlaybackGc::PushBitGcSettings()

	{

	// the buf format is len+data where data is written by the GC's ExternalizeL()

	CBufBase& buf = *iGcBuf;

	const TInt start = buf.Size();

	RBufWriteStream out(buf,start);

	TRAPD(err,out.WriteInt32L(0));

	if(!err)

		{

		TRAP(err,iGc->ExternalizeL(out));

		}

	if(err) //rollback addition

		{

		buf.Delete(start,buf.Size()-start);

		}

	else //fixup len

		{

		TRAP_IGNORE(out.CommitL();) // can't see this failing

		TPckgBuf<TInt32> pckg(buf.Size()-sizeof(TInt32)-start);

		buf.Write(start,pckg);

		}

	return err;

	}

void CPlaybackGc::PopBitGcSettings()

	{

	CBufBase& buf = *iGcBuf;

	TInt ofs = 0;

	FOREVER

		{

		TInt chunk = 0;

		RBufReadStream in(buf,ofs);

		TRAPD(err,chunk = in.ReadInt32L());

		if(err)

			{

			WS_ASSERT_DEBUG(err != 0, EWsPanicWsGraphic);

			return;

			}

		if(ofs+sizeof(TInt32)+chunk >= buf.Size()) // the last chunk?

			{

			TRAP_IGNORE(iGc->InternalizeL(in));

			buf.Delete(ofs,buf.Size()-ofs);

			return;

			}

		ofs += chunk + sizeof(TInt32);

		}

	}

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

	// clip rect to window extent

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

	if (!rect.IsEmpty())

		{

		// and schedule it

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

		}

	}

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)

	{

	TWsGcCmdUnion pData;

	pData.any=aCmdData.Ptr();

	if (aRegion)

		{

		WS_ASSERT_DEBUG(iWin,EWsPanicWindowNull);

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

			return;

		iGc->SetClippingRegion(aRegion);

		WS_ASSERT_DEBUG(!iCurrentClippingRegion, EWsPanicDrawCommandsInvalidState);

		iCurrentClippingRegion = aRegion;

		}

	switch(aOpcode)

		{

		case EWsGcOpDrawWsGraphic:

		case EWsGcOpDrawWsGraphicPtr:

			{

			TRect screenRect(pData.WsGraphic->iRect);

			screenRect.Move(GcOrigin());

			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 = owner->WindowServer().ResolveGraphic(id);

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

					}

				}

			break;

			}

		case EWsGcOpMapColorsLocal:

			iGc->MapColors(pData.MapColorsLocal->rect, pData.MapColorsLocal->colors,pData.MapColorsLocal->numPairs,pData.MapColorsLocal->mapForwards);

			break;

		case EWsGcOpDrawPolyLineLocalBufLen:

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

			break;

		case EWsGcOpDrawPolyLineLocal:

			iGc->DrawPolyLine(pData.PointList);

			break;

		case EWsGcOpDrawPolygonLocalBufLen:

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

			break;

		case EWsGcOpDrawPolygonLocal:

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

			break;

		case EWsGcOpDrawBitmapLocal:

			iGc->DrawBitmap(pData.BitmapLocal->pos, 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->AlphaBlendBitmaps(pData.AlphaBlendBitmapsLocal->point,pData.AlphaBlendBitmapsLocal->iBitmap,

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

									pData.AlphaBlendBitmapsLocal->alphaPoint);

			break;

		case EWsGcOpDrawText:

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

			break;

		case EWsGcOpDrawBoxTextOptimised1:

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

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

			break;

		case EWsGcOpDrawBoxTextOptimised2:

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

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

			break;

		case EWsGcOpDrawTextPtr:

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

			break;

		case EWsGcOpDrawTextPtr1:

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

			break;

		case EWsGcOpDrawBoxText:

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

			break;

		case EWsGcOpDrawBoxTextPtr:

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

			break;

		case EWsGcOpDrawBoxTextPtr1:

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

			break;

		case EWsGcOpDrawTextVertical:

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

							,pData.DrawTextVertical->up);

			break;

		case EWsGcOpDrawTextVerticalPtr:

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

			break;

		case EWsGcOpDrawTextVerticalPtr1:

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

			break;

		case EWsGcOpDrawBoxTextVertical:

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

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

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

			break;

		case EWsGcOpDrawBoxTextVerticalPtr:

			iGc->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:

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

			break;

		case EWsGcOpDrawTextLocal:

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

			break;

		case EWsGcOpDrawBoxTextLocal:

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

							pData.BoxTextLocal->horiz,pData.BoxTextLocal->leftMrg);

			break;

		case EWsGcOpDrawLine:

			iGc->DrawLine(pData.DrawLine->pnt1,pData.DrawLine->pnt2);

			break;

		case EWsGcOpDrawTo:

			iGc->DrawLine(iLinePos,*pData.Point);

			break;

		case EWsGcOpDrawBy:

			iGc->DrawLine(iLinePos,iLinePos+(*pData.Point));

			break;

		case EWsGcOpPlot:

			iGc->Plot(*pData.Point);

			break;

		case EWsGcOpMoveTo:

		case EWsGcOpMoveBy:

			break;

		case EWsGcOpGdiBlt2Local:

			iGc->BitBlt(pData.GdiBlt2Local->pos,pData.GdiBlt2Local->bitmap);

			break;

		case EWsGcOpGdiBlt3Local:

			iGc->BitBlt(pData.GdiBlt3Local->pos,pData.GdiBlt3Local->bitmap, pData.GdiBlt3Local->rect);

			break;

		case EWsGcOpGdiBltMaskedLocal:

			iGc->BitBltMasked(pData.GdiBltMaskedLocal->pos,pData.GdiBltMaskedLocal->bitmap,

								pData.GdiBltMaskedLocal->rect,pData.GdiBltMaskedLocal->maskBitmap,

								pData.GdiBltMaskedLocal->invertMask);

			break;

		case EWsGcOpGdiWsBlt2:

		case EWsGcOpGdiWsBlt3:

		case EWsGcOpGdiWsBltMasked:

		case EWsGcOpGdiWsAlphaBlendBitmaps:

		case EWsGcOpWsDrawBitmapMasked:

			{

			// Andy - we continually duplicate bitmaps in here, and yet we already have them

			// somewhere as pointers so can't we both simplify and optimize this?

			CFbsBitmap* scratchBitmap=iScratchBitmap;

			CFbsBitmap* scratchMaskBimap=iScratchMaskBitmap;

			TInt maskHandle=0;

			TInt handle=WsBitmapHandle(aOpcode,pData, maskHandle);

			CWsClient* owner=iWin->WsOwner();

			if (owner!=NULL)

				{

				TInt wsBmpErr = KErrNone;

				DWsBitmap *bitmap=(DWsBitmap *)owner->HandleToObj(handle, WS_HANDLE_BITMAP);

				if (!bitmap)

					wsBmpErr = KErrNotFound;

				else

					scratchBitmap=bitmap->FbsBitmap();

				if (wsBmpErr == KErrNone)

					if (aOpcode==EWsGcOpGdiWsBltMasked || aOpcode==EWsGcOpGdiWsAlphaBlendBitmaps || aOpcode==EWsGcOpWsDrawBitmapMasked)

						{

						DWsBitmap *bitmap2=(DWsBitmap *)owner->HandleToObj(maskHandle, WS_HANDLE_BITMAP);

						if (!bitmap2)

							wsBmpErr = KErrNotFound;

						else

							scratchMaskBimap=bitmap2->FbsBitmap();

						}

				if (wsBmpErr == KErrNone)

					{

					switch(aOpcode)

						{

						case EWsGcOpGdiWsBlt2:

							iGc->BitBlt(pData.GdiBlt2->pos,scratchBitmap);