diff -r 000000000000 -r 5d03bc08d59c windowing/windowserver/nonnga/remotegc/RemoteGc.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/nonnga/remotegc/RemoteGc.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,653 @@
+// 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 "RemoteGc.h"
+#include "RemoteGcUtils.h"
+#include "CommandBuffer.h"
+#include <graphics/gdi/gdiconsts.h>
+
+/**
+Creates a new remotegc.
+
+@param aDevice The windowserver screendevice to use.
+@param aCommandBufferObserver Pointer to a commandbufferobserver.
+@return A pointer to a new instance of CRemoteGc.
+*/
+EXPORT_C CRemoteGc* CRemoteGc::NewL(CWsScreenDevice* aDevice)
+	{
+	CRemoteGc* remoteGc = new (ELeave) CRemoteGc(aDevice);
+	CleanupStack::PushL(remoteGc);
+	remoteGc->ConstructL();
+	CleanupStack::Pop(remoteGc);
+	return remoteGc;
+	}
+
+CRemoteGc::CRemoteGc(CWsScreenDevice* aDevice) : CWindowGc(aDevice), iCommandBufferObserver(NULL)
+	{	
+	}
+	
+EXPORT_C CRemoteGc::~CRemoteGc()
+	{
+	delete iCommandBuffer;	
+	}
+	
+void CRemoteGc::ConstructL()
+	{
+	User::LeaveIfError(CWindowGc::Construct());
+	iCommandBuffer = CCommandBuffer::NewL();
+	}
+	
+EXPORT_C void CRemoteGc::SetCommandBufferObserver(MCommandBufferObserver* aCommandBufferObserver)
+	{
+	iCommandBufferObserver = aCommandBufferObserver;
+	}
+
+/**
+Resets the commandbuffer.
+*/
+EXPORT_C void CRemoteGc::ResetCommandBuffer()
+	{
+	iCommandBuffer->Reset();
+	}
+
+/**
+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.
+*/	
+EXPORT_C void CRemoteGc::ExternalizeL(RWsGraphicMsgBuf& aMsgBuf, TBool aEntireBuffer)
+	{
+	return iCommandBuffer->ExternalizeL(aMsgBuf, aEntireBuffer);
+	}
+
+/**
+Prepares the remotegc to be drawn to.
+
+@param aRect The rect to be drawn.
+*/
+EXPORT_C void CRemoteGc::BeginDraw(const TRect& aRect)
+	{
+	iDrawRect = aRect;
+	iBoundingRect = TRect();
+	iHasBitmapCommand = EFalse;
+	iCommandBuffer->Prepare(aRect);
+	}
+ 
+/**
+Finishes the current redraw.
+This method should be called when drawing to the remotegc is complete.
+*/
+EXPORT_C void CRemoteGc::EndDraw()
+	{
+	iBoundingRect.Intersection(iDrawRect);
+	const TInt err = iCommandBuffer->Finish(iDrawRect, iBoundingRect, iHasBitmapCommand);
+
+	if(iCommandBufferObserver && !err)
+		iCommandBufferObserver->CommandBufferUpdated(iDrawRect, iBoundingRect); 
+ 	}
+
+void CRemoteGc::Activate(RDrawableWindow &aDevice)
+	{
+	BeginDraw(aDevice.GetDrawRect());
+	CWindowGc::Activate(aDevice);
+	}
+	
+void CRemoteGc::Deactivate()
+	{	
+	CWindowGc::Deactivate();
+	EndDraw();
+	}
+	
+void CRemoteGc::Clear()
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandClear);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+	
+void CRemoteGc::Clear(const TRect& aRect)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandClearRect);
+	iCommandBuffer->Write<TRect>(aRect);
+	iBoundingRect.BoundingRect(aRect);
+	}
+	
+void CRemoteGc::CopyRect(const TPoint &anOffset, const TRect &aRect)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandCopyRect);
+	iCommandBuffer->Write<TPoint>(anOffset);
+	iCommandBuffer->Write<TRect>(aRect);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+
+void CRemoteGc::BitBlt(const TPoint &aPoint, const CFbsBitmap *aBitmap)
+	{
+	__ASSERT_DEBUG(aBitmap, User::Invariant());
+	if(aBitmap)
+		{
+		iCommandBuffer->Write<TDrawCode>(ECommandBitBlt1);
+		iCommandBuffer->Write<TPoint>(aPoint);
+		iCommandBuffer->Write<TInt>(aBitmap->Handle());
+		iBoundingRect.BoundingRect(TRect(aPoint, aBitmap->SizeInPixels()));
+		iHasBitmapCommand = ETrue;
+		}
+	}
+	
+void CRemoteGc::BitBlt(const TPoint &aDestination, const CFbsBitmap *aBitmap, const TRect &aSource)
+	{
+	__ASSERT_DEBUG(aBitmap, User::Invariant());
+	if(aBitmap)
+		{	
+		iCommandBuffer->Write<TDrawCode>(ECommandBitBlt2);
+		iCommandBuffer->Write<TPoint>(aDestination);
+		iCommandBuffer->Write<TInt>(aBitmap->Handle());
+		iCommandBuffer->Write<TRect>(aSource);
+		iBoundingRect.BoundingRect(TRect(aDestination, aSource.Size()));
+		iHasBitmapCommand = ETrue;
+		}
+	}
+	
+void CRemoteGc::BitBltMasked(const TPoint& aPoint, const CFbsBitmap* aBitmap, const TRect& aSourceRect, const CFbsBitmap* aMaskBitmap, TBool aInvertMask)
+	{
+	__ASSERT_DEBUG(aBitmap && aMaskBitmap, User::Invariant());
+	if(aBitmap && aMaskBitmap)
+		{
+		iCommandBuffer->Write<TDrawCode>(ECommandBitBltMasked);
+		iCommandBuffer->Write<TPoint>(aPoint);
+		iCommandBuffer->Write<TInt>(aBitmap->Handle());
+		iCommandBuffer->Write<TRect>(aSourceRect);
+		iCommandBuffer->Write<TInt>(aMaskBitmap->Handle());
+		iCommandBuffer->Write<TBool>(aInvertMask);
+		iBoundingRect.BoundingRect(TRect(aPoint, aSourceRect.Size()));
+		iHasBitmapCommand = ETrue;
+		}
+	}
+
+void CRemoteGc::BitBlt(const TPoint &aPoint, const CWsBitmap *aBitmap)
+	{
+	BitBlt(aPoint, reinterpret_cast<const CFbsBitmap*>(aBitmap));		
+	}
+	
+void CRemoteGc::BitBlt(const TPoint &aDestination, const CWsBitmap *aBitmap, const TRect &aSource)
+	{
+	BitBlt(aDestination, reinterpret_cast<const CFbsBitmap*>(aBitmap), aSource);
+	}
+	
+void CRemoteGc::BitBltMasked(const TPoint& aPoint, const CWsBitmap *aBitmap, const TRect& aSourceRect, const CWsBitmap *aMaskBitmap, TBool aInvertMask)
+	{		
+	BitBltMasked(aPoint, reinterpret_cast<const CFbsBitmap*>(aBitmap), aSourceRect, reinterpret_cast<const CFbsBitmap*>(aMaskBitmap), aInvertMask);
+	}
+
+void CRemoteGc::SetFaded(TBool aFaded)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetFaded);
+	iCommandBuffer->Write<TBool>(aFaded);
+	}
+	
+void CRemoteGc::SetFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetFadingParameters);
+	iCommandBuffer->Write<TUint8>(aBlackMap);
+	iCommandBuffer->Write<TUint8>(aWhiteMap);
+	}
+	
+TInt CRemoteGc::AlphaBlendBitmaps(const TPoint& aDestPt, const CFbsBitmap* aSrcBmp, const TRect& aSrcRect, const CFbsBitmap* aAlphaBmp, const TPoint& aAlphaPt)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandAlphaBlendBitmaps);
+	iCommandBuffer->Write<TPoint>(aDestPt);
+	iCommandBuffer->Write<TInt>(aSrcBmp->Handle());
+	iCommandBuffer->Write<TRect>(aSrcRect);
+	iCommandBuffer->Write<TInt>(aAlphaBmp->Handle());
+	iCommandBuffer->Write<TPoint>(aAlphaPt);
+	iBoundingRect.BoundingRect(iDrawRect);
+	iHasBitmapCommand = ETrue;
+	return KErrNone;
+	}
+	
+TInt CRemoteGc::AlphaBlendBitmaps(const TPoint& aDestPt, const CWsBitmap* aSrcBmp, const TRect& aSrcRect, const CWsBitmap* aAlphaBmp, const TPoint& aAlphaPt)
+	{
+	return AlphaBlendBitmaps(aDestPt, reinterpret_cast<const CFbsBitmap*>(aSrcBmp), aSrcRect, reinterpret_cast<const CFbsBitmap*>(aAlphaBmp), aAlphaPt);
+	}
+
+void CRemoteGc::SetOrigin(const TPoint &aPoint)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetOrigin);
+	iCommandBuffer->Write<TPoint>(aPoint);
+	}
+	
+void CRemoteGc::SetDrawMode(TDrawMode aDrawingMode)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetDrawMode);
+	iCommandBuffer->Write<TDrawMode>(aDrawingMode);		
+	}
+	
+void CRemoteGc::SetClippingRect(const TRect& aRect)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetClippingRect);
+	iCommandBuffer->Write<TRect>(aRect);		
+	}
+	
+void CRemoteGc::CancelClippingRect()
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandCancelClippingRect);		
+	}
+	
+void CRemoteGc::Reset()
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandReset);			
+	}
+	
+void CRemoteGc::UseFont(const CFont *aFont)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandUseFont);
+	iCommandBuffer->Write<TInt>(((CFbsFont*)aFont)->Handle());
+	}
+	
+void CRemoteGc::DiscardFont()
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDiscardFont);
+	}
+	
+void CRemoteGc::SetUnderlineStyle(TFontUnderline aUnderlineStyle)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetUnderlineStyle);
+	iCommandBuffer->Write<TFontUnderline>(aUnderlineStyle);
+	}
+	
+void CRemoteGc::SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetStrikethroughStyle);
+	iCommandBuffer->Write<TFontStrikethrough>(aStrikethroughStyle);
+	}
+	
+void CRemoteGc::SetWordJustification(TInt aExcessWidth, TInt aNumGaps)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetWordJustification);
+	iCommandBuffer->Write<TInt>(aExcessWidth);
+	iCommandBuffer->Write<TInt>(aNumGaps);
+	}
+	
+void CRemoteGc::SetCharJustification(TInt aExcessWidth, TInt aNumChars)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetCharJustification);
+	iCommandBuffer->Write<TInt>(aExcessWidth);
+	iCommandBuffer->Write<TInt>(aNumChars);	
+	}
+
+void CRemoteGc::SetPenColor(const TRgb &aColor)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetPenColor);
+	iCommandBuffer->Write<TRgb>(aColor);		
+	}
+	
+void CRemoteGc::SetPenStyle(TPenStyle aPenStyle)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetPenStyle);
+	iCommandBuffer->Write<TPenStyle>(aPenStyle);			
+	}
+	
+void CRemoteGc::SetPenSize(const TSize& aSize)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetPenSize);
+	iCommandBuffer->Write<TSize>(aSize);			
+	}
+
+void CRemoteGc::SetBrushColor(const TRgb &aColor)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetBrushColor);
+	iCommandBuffer->Write<TRgb>(aColor);
+	}
+
+void CRemoteGc::SetBrushStyle(TBrushStyle aBrushStyle)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetBrushStyle);
+	iCommandBuffer->Write<TBrushStyle>(aBrushStyle);		
+	}
+	
+void CRemoteGc::SetBrushOrigin(const TPoint &aOrigin)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetBrushOrigin);
+	iCommandBuffer->Write<TPoint>(aOrigin);			
+	}
+	
+void CRemoteGc::UseBrushPattern(const CFbsBitmap *aDevice)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandUseBrushPattern);
+	iCommandBuffer->Write<TInt>(aDevice->Handle());		
+	}
+	
+void CRemoteGc::DiscardBrushPattern()
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDiscardBrushPattern);	
+	}
+
+void CRemoteGc::MoveTo(const TPoint &aPoint)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandMoveTo);
+	iCommandBuffer->Write<TPoint>(aPoint);
+	}
+	
+void CRemoteGc::MoveBy(const TPoint &aPoint)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandMoveBy);
+	iCommandBuffer->Write<TPoint>(aPoint);
+	}
+	
+void CRemoteGc::Plot(const TPoint &aPoint)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandPlot);
+	iCommandBuffer->Write<TPoint>(aPoint);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+	
+void CRemoteGc::DrawArc(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawArc);
+	iCommandBuffer->Write<TRect>(aRect);
+	iCommandBuffer->Write<TPoint>(aStart);
+	iCommandBuffer->Write<TPoint>(aEnd);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+	
+void CRemoteGc::DrawLine(const TPoint &aPoint1,const TPoint &aPoint2)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawLine);
+	iCommandBuffer->Write<TPoint>(aPoint1);
+	iCommandBuffer->Write<TPoint>(aPoint2);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+	
+void CRemoteGc::DrawLineTo(const TPoint &aPoint)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawLineTo);
+	iCommandBuffer->Write<TPoint>(aPoint);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+	
+void CRemoteGc::DrawLineBy(const TPoint &aPoint)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawLineBy);
+	iCommandBuffer->Write<TPoint>(aPoint);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+
+void CRemoteGc::DrawPolyLine(const CArrayFix<TPoint> *aPointList)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawPolyLine);
+	iCommandBuffer->Write<TInt>(aPointList->Count()); // Write number of points
+	
+	const TInt count = aPointList->Count();
+	for(TInt i = 0; i < count; i++)	
+		{
+		iCommandBuffer->Write<TPoint>(aPointList->At(i));
+		}
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+
+void CRemoteGc::DrawPolyLine(const TPoint* aPointList, TInt aNumPoints)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawPolyLine);
+	iCommandBuffer->Write<TInt>(aNumPoints); // Write number of points
+	
+	for(TInt i = 0; i < aNumPoints; i++)	
+		{
+		iCommandBuffer->Write<TPoint>(aPointList[i]);
+		}
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+
+void CRemoteGc::DrawPie(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawPie);
+	iCommandBuffer->Write<TRect>(aRect);
+	iCommandBuffer->Write<TPoint>(aStart);
+	iCommandBuffer->Write<TPoint>(aEnd);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+	
+void CRemoteGc::DrawEllipse(const TRect &aRect)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawEllipse);
+	iCommandBuffer->Write<TRect>(aRect);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+	
+void CRemoteGc::DrawRect(const TRect &aRect)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawRect);
+	iCommandBuffer->Write<TRect>(aRect);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+	
+void CRemoteGc::DrawRoundRect(const TRect &aRect,const TSize &aEllipse)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawRoundRect);
+	iCommandBuffer->Write<TRect>(aRect);
+	iCommandBuffer->Write<TSize>(aEllipse);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+
+TInt CRemoteGc::DrawPolygon(const CArrayFix<TPoint> *aPointList, TFillRule aFillRule)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawPolygon);
+	iCommandBuffer->Write<TInt>(aPointList->Count()); // Write number of points
+	
+	for(TInt i = 0; i < aPointList->Count(); i++)	
+		{
+		iCommandBuffer->Write<TPoint>(aPointList->At(i));
+		}
+		
+	iCommandBuffer->Write<TFillRule>(aFillRule);
+	iBoundingRect.BoundingRect(iDrawRect);
+	return KErrNone;
+	}
+	
+TInt CRemoteGc::DrawPolygon(const TPoint* aPointList, TInt aNumPoints, TFillRule aFillRule)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawPolygon);
+	iCommandBuffer->Write<TInt>(aNumPoints); // Write number of points
+	
+	for(TInt i = 0; i < aNumPoints; i++)	
+		{
+		iCommandBuffer->Write<TPoint>(aPointList[i]);
+		}
+		
+	iCommandBuffer->Write<TFillRule>(aFillRule);
+	iBoundingRect.BoundingRect(iDrawRect);
+	return KErrNone;
+	}
+
+void CRemoteGc::DrawBitmap(const TPoint &aTopLeft, const CFbsBitmap *aDevice)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawBitmap1);
+	iCommandBuffer->Write<TPoint>(aTopLeft);
+	iCommandBuffer->Write<TInt>(aDevice->Handle());
+	iBoundingRect.BoundingRect(TRect(aTopLeft, aDevice->SizeInPixels()));
+	iHasBitmapCommand = ETrue;
+	}
+	
+void CRemoteGc::DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawBitmap2);
+	iCommandBuffer->Write<TRect>(aDestRect);
+	iCommandBuffer->Write<TInt>(aDevice->Handle());
+	iBoundingRect.BoundingRect(aDestRect);
+	iHasBitmapCommand = ETrue;
+	}
+	
+void CRemoteGc::DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice, const TRect &aSourceRect)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawBitmap3);
+	iCommandBuffer->Write<TRect>(aDestRect);
+	iCommandBuffer->Write<TInt>(aDevice->Handle());
+	iCommandBuffer->Write<TRect>(aSourceRect);
+	iBoundingRect.BoundingRect(aDestRect);
+	iHasBitmapCommand = ETrue;
+	}
+	
+void CRemoteGc::DrawBitmapMasked(const TRect& aDestRect, const CFbsBitmap* aBitmap, const TRect& aSourceRect, const CFbsBitmap* aMaskBitmap, TBool aInvertMask)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawBitmapMasked);
+	iCommandBuffer->Write<TRect>(aDestRect);
+	iCommandBuffer->Write<TInt>(aBitmap->Handle());
+	iCommandBuffer->Write<TRect>(aSourceRect);
+	iCommandBuffer->Write<TInt>(aMaskBitmap->Handle());
+	iCommandBuffer->Write<TBool>(aInvertMask);
+	iBoundingRect.BoundingRect(aDestRect);
+	iHasBitmapCommand = ETrue;
+	}
+	
+void CRemoteGc::DrawBitmapMasked(const TRect& aDestRect, const CWsBitmap* aBitmap, const TRect& aSourceRect, const CWsBitmap* aMaskBitmap, TBool aInvertMask)
+	{
+	DrawBitmapMasked(aDestRect, reinterpret_cast<const CFbsBitmap*>(aBitmap), aSourceRect, reinterpret_cast<const CFbsBitmap*>(aMaskBitmap), aInvertMask);
+	}
+
+void CRemoteGc::DrawText(const TDesC &aBuf,const TPoint &aPos)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawText1);
+	iCommandBuffer->WriteText(aBuf);
+	iCommandBuffer->Write<TPoint>(aPos);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+
+void CRemoteGc::DrawText(const TDesC &aBuf, const TRect &aBox, TInt aBaselineOffset, TTextAlign aHoriz, TInt aLeftMrg)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawText2);
+	iCommandBuffer->WriteText(aBuf);
+	iCommandBuffer->Write<TRect>(aBox);
+	iCommandBuffer->Write<TInt>(aBaselineOffset);
+	iCommandBuffer->Write<TTextAlign>(aHoriz);
+	iCommandBuffer->Write<TInt>(aLeftMrg);
+	iBoundingRect.BoundingRect(aBox);
+	}
+	
+void CRemoteGc::DrawText(const TDesC& aText, const TPoint& aPosition, const TDrawTextParam& aParam)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawText3);
+	iCommandBuffer->WriteText(aText);
+	iCommandBuffer->Write<TPoint>(aPosition);
+	iCommandBuffer->Write<TDrawTextParam>(aParam);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+
+void CRemoteGc::MapColors(const TRect& aRect, const TRgb* aColors, TInt aNumPairs, TBool aMapForwards)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandMapColors);
+	iCommandBuffer->Write<TRect>(aRect);	
+	iCommandBuffer->Write<TInt>(aNumPairs);
+	
+	for(TInt i = 0; i < aNumPairs; i++)	
+		{
+		iCommandBuffer->Write<TRgb>(aColors[i]);
+		iCommandBuffer->Write<TRgb>(aColors[i+1]);
+		}
+		
+	iCommandBuffer->Write<TBool>(aMapForwards);
+	}
+
+TInt CRemoteGc::SetClippingRegion(const TRegion &aRegion)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandSetClippingRegion);
+	
+	const TInt count = aRegion.Count();
+	iCommandBuffer->Write<TInt>(count);
+	
+	for(TInt i = 0; i < count; i++)	
+		{
+		iCommandBuffer->Write<TRect>(aRegion.RectangleList()[i]);
+		}
+		
+	return KErrNone;
+	}
+	
+void CRemoteGc::CancelClippingRegion()
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandCancelClippingRegion);
+	}
+	
+void CRemoteGc::DrawTextVertical(const TDesC& aText, const TPoint& aPos, TBool aUp)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawTextVertical1);
+	iCommandBuffer->WriteText(aText);
+	iCommandBuffer->Write<TPoint>(aPos);	
+	iCommandBuffer->Write<TBool>(aUp);
+	iBoundingRect.BoundingRect(iDrawRect);
+	}
+	
+void CRemoteGc::DrawTextVertical(const TDesC& aText, const TRect& aBox, TInt aBaselineOffset, TBool aUp, TTextAlign aVert, TInt aMargin)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawTextVertical2);
+	iCommandBuffer->WriteText(aText);
+	iCommandBuffer->Write<TRect>(aBox);
+	iCommandBuffer->Write<TInt>(aBaselineOffset);
+	iCommandBuffer->Write<TBool>(aUp);
+	iCommandBuffer->Write<TTextAlign>(aVert);
+	iCommandBuffer->Write<TInt>(aMargin);
+	iBoundingRect.BoundingRect(aBox);
+	}
+	
+void CRemoteGc::DrawWsGraphic(const TWsGraphicId& aId,const TRect& aDestRect)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawWsGraphic1);
+	iCommandBuffer->Write<TInt>(aId.IsUid()? aId.Uid().iUid: aId.Id());
+	iCommandBuffer->Write<TBool>(aId.IsUid());
+	iCommandBuffer->Write<TRect>(aDestRect);
+	iBoundingRect.BoundingRect(aDestRect);
+	}
+	
+void CRemoteGc::DrawWsGraphic(const TWsGraphicId& aId,const TRect& aDestRect,const TDesC8& aData)
+	{
+	iCommandBuffer->Write<TDrawCode>(ECommandDrawWsGraphic2);
+	iCommandBuffer->Write<TInt>(aId.IsUid()? aId.Uid().iUid: aId.Id());
+	iCommandBuffer->Write<TBool>(aId.IsUid());
+	iCommandBuffer->Write<TRect>(aDestRect);
+	iCommandBuffer->WriteText(aData);
+	iBoundingRect.BoundingRect(aDestRect);
+	}
+
+void CRemoteGc::SetDitherOrigin(const TPoint& /*aPoint*/)
+	{
+	// do nothing, does not apply to CBitmapContext which CCommandBuffer is using
+	}
+
+void CRemoteGc::SetOpaque(TBool /*aDrawOpaque*/)
+	{
+	// overrides to prevent calling CWindowGc::SetOpaque, it's specific to how wserv blends windows content
+	}
+
+TInt CRemoteGc::APIExtension(TUid aUid, TAny*& aOutput, TAny* aInput)
+	{
+	if (aUid == KSetShadowColor)
+		{
+		return APIExSetShadowColor(aInput);
+		}
+	/* Future cases may be placed here later.*/
+	else
+		{
+		return CBitmapContext::APIExtension(aUid, aOutput, aInput);
+		}
+	}
+
+TInt CRemoteGc::APIExSetShadowColor(TAny* aShadowColor)
+	{
+	const TRgb shadowColor = *(reinterpret_cast<TRgb*> (aShadowColor));
+	iCommandBuffer->Write<TDrawCode>(ECommandSetShadowColor);
+	iCommandBuffer->Write<TRgb>(shadowColor);
+	return KErrNone;
+	}