// Copyright (c) 2007-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:
// Unless stated otherwise, all co-ordinates are recorded and calculated using 
// Symbian graphics format: origin at top left of image, 'y' increasing towards bottom
// of image. Note that OpenVG places the origin at an image's bottom left corner, with
// 'y' increasing towards the top of the image. 
// 
//

#include "vgengine.h"
#include "directgdiadapter.h"
#include "directgdidriverimpl.h"
#include "directgdiimagetargetimpl.h"
#include "directgdiimagesourceimpl.h"
#include "confighelper.h"
#include <graphics/directgdiimagetarget.h>
#include <graphics/directgdidrawablesource.h>
#include <fbs.h>
#include <e32cmn.h>
#include <e32math.h>
#include <s32strm.h>
#include <pixelformats.h>
#include <bitdraworigin.h>
#include <bitdrawinterfaceid.h>

#include "blendingalgorithms.inl"

/**
Pre-calculation for normalising a 0-255 colour channel to 0..1.
*/
const VGfloat KColorConversion = 1.0f/255.0f;


inline TInt Scale(TInt aValue,TInt aNum,TInt aDen)
	{
	if (aNum==aDen)
		return aValue;
	TInt64 result(aValue);
	result=(result*aNum+(aDen/2))/aDen;
	return I64INT(result);
	}

/**
Maps TDisplayMode onto a supported VGImageFormat. Only compatible formats are returned,
anything else results in VG_IMAGE_FORMAT_INVALID being returned.

@param 	aDisplayMode Mode to convert from.

@return The VGImageFormat which matches the specified TDisplayMode pixel format exactly.
		If no exact match exists, then VG_IMAGE_FORMAT_INVALID is returned.
 */
static VGImageFormat MapToVgDisplayMode(TDisplayMode aDisplayMode)
	{
	switch(aDisplayMode)
		{
	case ENone:
		return VG_IMAGE_FORMAT_INVALID;
	case EGray2:
		return VG_BW_1;
	case EGray4: 
	case EGray16:
		return VG_IMAGE_FORMAT_INVALID;
	case EGray256:
		return VG_sL_8;
	case EColor16:
	case EColor256:
	case EColor4K:
		return VG_IMAGE_FORMAT_INVALID;
	case EColor64K:
		return VG_sRGB_565;
	case EColor16M:
	case ERgb:
		return VG_IMAGE_FORMAT_INVALID;
	case EColor16MU:
		return VG_sXRGB_8888;
	case EColor16MA:
		return VG_sARGB_8888;
	case EColor16MAP:
		return VG_sARGB_8888_PRE;
	case EColorLast:
		return VG_IMAGE_FORMAT_INVALID;
		}
	
	return VG_IMAGE_FORMAT_INVALID;
	}

/**
Destructor
 */
CVgEngine::~CVgEngine()
	{
	iRegionManager.Close();
	
	if (iBrushPatternUser != VG_INVALID_HANDLE)	
		vgDestroyImage(iBrushPatternUser);		
		
	if (iBrushPatternStandard != VG_INVALID_HANDLE)
		vgDestroyImage(iBrushPatternStandard);		
	
	if (iBrushPatternStandardRegion != VG_INVALID_HANDLE)
		vgDestroyImage(iBrushPatternStandardRegion);		
	
	if (iBrushPatternNonZeroOrigin != VG_INVALID_HANDLE)
		vgDestroyImage(iBrushPatternNonZeroOrigin);	
	
	User::Free(iPathCommands);	
	User::Free(iPathCoords);
	
	Deactivate();
	}

/**
Constructor
 */
CVgEngine::CVgEngine(CDirectGdiDriverImpl& aDriver)
	:iDriver(aDriver),
	iPen(VG_INVALID_HANDLE),
	iBrush(VG_INVALID_HANDLE),
	iClearBrush(VG_INVALID_HANDLE),
	iVgPath(VG_INVALID_HANDLE),
	iTextBrush(VG_INVALID_HANDLE),
	iBrushPatternUser(VG_INVALID_HANDLE),
	iBrushPatternStandard(VG_INVALID_HANDLE),
	iBrushPatternStandardRegion(VG_INVALID_HANDLE),
	iBrushPatternNonZeroOrigin(VG_INVALID_HANDLE)
	{		
	// Set the default paint mode for drawing and filling shapes to
	// just draw the pen and not the brush as default (to match BitGdi)
	iPaintMode = VG_STROKE_PATH;
	
	//cache interface to use every time glyph gets drawn
	GetInterface(TUid::Uid(KDirectGdiGetGlyphStorageUid), (TAny*&) iFontGlyphImageStorage);
	}

/**
Applies the engine's state to OpenVG, re-applying all the VgEngine settings. It is called by 
Activate() as well as when the engine is being made current. 
*/
void CVgEngine::SetVgState()
	{
	ResetVgMatrix();
	vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
	vgSeti(VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_NONANTIALIASED);
	vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_ROUND);
	vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
	vgSetPaint(iPen, VG_STROKE_PATH);
	vgSetPaint(iBrush, VG_FILL_PATH);
	SetDrawMode(iDrawMode); 
	SetPenColor(iPenColor);
	SetPenStyle(iPenStyle);
	SetPenSize(iPenSize);
	SetBrushColor(iBrushColor);
	SetBrushStyle(iBrushStyle);
	SetBrushOrigin(iBrushOrigin);
	vgSetParameteri(iClearBrush, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
	vgSetParameteri(iTextBrush, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
	}

/**
Binds a rendering target to this OpenVG rendering engine.
Activates the target, which increments the reference count of target as it can be shared across many 
DirectGDI contexts.

The rendering target, for this implementation, specifies an Embedded OpenVG rendering surface.

@see MDirectGdiEngine::Activate()
@see Deactivate()

@panic DGDIAdapter 34, if the passed target has a NULL handle.
@panic DGDIAdapter 39, if target associated with the handle is NULL.
 */
TInt CVgEngine::Activate(RDirectGdiImageTarget& aTarget)
	{
	TInt result = KErrNone;
	GRAPHICS_ASSERT_ALWAYS(aTarget.Handle(), EDirectGdiPanicActivateWithNullHandle);
	CDirectGdiImageTargetImpl* target = iDriver.GetImageTargetFromHandle(aTarget.Handle());
	GRAPHICS_ASSERT_ALWAYS(target, EDirectGdiPanicNullTargetActivate);
	if (target == iRenderingTarget)
		{
		return KErrNone;
		}
	
	Deactivate();	
	
	iDriver.Activate(target);
	iRenderingTarget = target;
	iDriver.SetCurrentEngine(this);
	iDriver.SetCurrentTarget(target);
	iSize = iRenderingTarget->Size();
	iTargetRegion.Clear();
	iTargetRegion.AddRect(iSize);

	iRegionManager.Initialize(vgGeti(VG_MAX_SCISSOR_RECTS), iSize);
	
	// Set the origin to top-left for path and image rendering. iIdentityMatrix is set so that we have a
	// record of the "identity" transform. After modifying the transform for offsets, rotations, etc, etc
	// just set to iIdentityMatrix to get back to "normal".
	//
	vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
	vgLoadIdentity();
	vgScale(1, -1);
	vgTranslate(0,  -iSize.iHeight);
	vgGetMatrix(iIdentityMatrix);
	// Set the origin to top-left for image matrix.
	vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
	vgLoadMatrix(iIdentityMatrix);
	
	// Create the path.
	if (!PreparePath(iVgPath, 1) || (iVgPath == VG_INVALID_HANDLE))
		result = KErrNoMemory;

	// Create the pen object and set it as the object for stroking (OpenVG equivalent of a pen).
	if (result == KErrNone)
		{
		iPen = vgCreatePaint();
		if (iPen != VG_INVALID_HANDLE)
			vgSetPaint(iPen, VG_STROKE_PATH);
		else
			result = KErrNoMemory;
		}

	if (result == KErrNone)
		{		
		// Create the brush object
		// This only need to be done the first time the context is activated
		iBrush = vgCreatePaint();
		if (iBrush != VG_INVALID_HANDLE)
			vgSetPaint(iBrush, VG_FILL_PATH);
		else
			result = KErrNoMemory;
		}
	
	if (result == KErrNone)
		{
		// Create the brush object for Clear operations.
		// This only need to be done the first time the context is activated
		iClearBrush = vgCreatePaint();
		if (iClearBrush == VG_INVALID_HANDLE)
			{
			result = KErrNoMemory;
			}
		}
	
	if (result == KErrNone)
		{
		iTextBrush = vgCreatePaint();
		if (iTextBrush == VG_INVALID_HANDLE)
			{
			result = KErrNoMemory;
			}
		}
	
	if (result == KErrNone)
		{
		result = iDriver.PreAllocateFontGlyphImages();
		}

	if (result == KErrNone)
		{
		SetVgState();
		}

	return result;
	}

/**
@see MDirectGdiEngine::Deactivate()
@see Activate()
 */
void CVgEngine::Deactivate()
	{
	if (iPen != VG_INVALID_HANDLE)
		{
		vgDestroyPaint(iPen);
		}
	if (iBrush != VG_INVALID_HANDLE)
		{
		vgDestroyPaint(iBrush);		
		}
	if (iClearBrush != VG_INVALID_HANDLE)
		{
		vgDestroyPaint(iClearBrush);		
		}
	if (iTextBrush != VG_INVALID_HANDLE)
		{
		vgDestroyPaint(iTextBrush);		
		}
	if (iVgPath != VG_INVALID_HANDLE)
		{
		vgDestroyPath(iVgPath);
		}
	iPen = VG_INVALID_HANDLE;
	iBrush = VG_INVALID_HANDLE;
	iClearBrush = VG_INVALID_HANDLE;
	iVgPath = VG_INVALID_HANDLE;
	iTextBrush = VG_INVALID_HANDLE;
	
	if (iRenderingTarget)
		{
		// Deactivating the render target could potentially unbind the current EGL context
		// which would make the above vgDestroy() calls do nothing, therefore call Deactivate() last.
		iDriver.Deactivate(iRenderingTarget);
		}
	}

/**
Checks whether the engine and target are current. If current, then nothing is done, else all the OpenVG settings 
and EGL context are reapplied. This function is called in every drawing function to ensure that the engine and 
target are current.

If this function returns EFalse, it means any subsequent setting of OpenVG state may be invalid 
and should be avoided as it is setting a null EGL context.

@pre	None.
@post	Applies the current state to OpenVG and is made the active EGL context, if the engine or target is 
        not current.
@return ETrue if as a result of calling this function, the underlying OpenVG context is now current. This
        effectively means whether we have a target or not. EFalse is returned otherwise.
*/
TBool CVgEngine::MakeEngineCurrent()
	{
	TBool vgCurrent = iRenderingTarget!=NULL;
	if(!iDriver.IsCurrentEngine(this) || !iDriver.IsCurrentTarget(iRenderingTarget))
		{
		iDriver.SetCurrentEngine(this);
		iDriver.SetCurrentTarget(iRenderingTarget);
		// Must reactivate the target (i.e. make it current to EGL) before resetting the OpenVG parameters.
		if (iRenderingTarget)
			{
			iDriver.Reactivate(iRenderingTarget);
			SetVgState();
			}
		else
			vgCurrent = EFalse;
		}
	
	return vgCurrent;
	}

/**
@see MDirectGdiEngine::SetOrigin()
 */
void CVgEngine::SetOrigin(const TPoint& aOrigin)
	{
	iOrigin = aOrigin + iDrawOrigin;
	
	if (!MakeEngineCurrent())
		return;

	ResetVgMatrix();
	}

/** 
@see MDrawDeviceOrigin::Set()
*/
TInt CVgEngine::Set(const TPoint& aDrawOrigin)
	{
	TPoint moveOrigin=aDrawOrigin;
 	moveOrigin-=iDrawOrigin;
 	iOrigin+=moveOrigin;
 	
 	//offset clipping region
 	TInt result = KErrNone;
 	RRegion clippingRegion;
 	clippingRegion.Copy(iRegionManager.ClippingRegion());
 	if(!clippingRegion.CheckError())
 		{
 		clippingRegion.Offset(moveOrigin);
 		result = iRegionManager.SetClippingRegion(clippingRegion);
 		}
 	else
 		{
 		result = KErrNoMemory;
 		}
 	
 	if(result != KErrNone)
 		{
 		iDriver.SetError(result);
 		}
 	
 	clippingRegion.Close();
 	
 	iDrawOrigin = aDrawOrigin;
 	return result;
 	}
 
/** 
@see MDrawDeviceOrigin::Get()
*/
void CVgEngine::Get(TPoint& aDrawOrigin)
 	{
 	aDrawOrigin=iDrawOrigin;
   	}

/**
@see MDirectGdiEngine::SetClippingRegion(const TRegion&)
*/
void CVgEngine::SetClippingRegion(const TRegion& aRegion)
	{
	TInt result = KErrNone;
	TRect boundingRect=iTargetRegion.BoundingRect();
	boundingRect.iTl-=iDrawOrigin;
	boundingRect.iBr-=iDrawOrigin;
	if (!aRegion.IsContainedBy(boundingRect))
		{
		result = KErrArgument;
		}
	else
		{
		RRegion clippingRegion;
		clippingRegion.Copy(aRegion);
		if(!clippingRegion.CheckError())
			{
			clippingRegion.Offset(iDrawOrigin);
			result = iRegionManager.SetClippingRegion (clippingRegion);
			}
		else
			{
			result = KErrNoMemory;
			}
		clippingRegion.Close();
		}
	
	if (result != KErrNone)
		{
		iDriver.SetError(result);
		}
	}

/**
@see MDirectGdiEngine::ResetClippingRegion()
*/
void CVgEngine::ResetClippingRegion()
	{
	iRegionManager.Reset();
	
	if (!MakeEngineCurrent())
		return;
		
	vgSeti(VG_SCISSORING, VG_FALSE);
	}

/**
@see MDirectGdiEngine::SetDrawMode()

The generic layer has already checked whether the draw mode is already aMode.
Draw mode is referred to as "blend" mode in OpenVG.
Note that only EDrawModePEN and EDrawModeWriteAlpha style blending are supported by OpenVG.
The default OpenVG blend mode is VG_BLEND_SRC_OVER.
 */
void CVgEngine::SetDrawMode(DirectGdi::TDrawMode aMode)
	{
	iDrawMode = aMode;
	
	if (!MakeEngineCurrent())
		return;

	// Invalid modes are filtered out in the generic layer.
	if (aMode == DirectGdi::EDrawModePEN)
		{
		// Blend the destination with the source using the source alpha for blending if 
		// alpha is available.		
		vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER);
		}
	else // DirectGdi::EDrawModeWriteAlpha
		{
		// Destination colors and alpha are overwritten with source colors and alpha.						
		vgSeti(VG_BLEND_MODE, VG_BLEND_SRC);											
		}
	}

/**
@see MDirectGdiEngine::SetPenColor()
*/
void CVgEngine::SetPenColor(const TRgb& aColor)
	{
	iPenColor = aColor;
	
	if (!MakeEngineCurrent())
		return;

	// Make sure our pen is the current selected pen for stroking before we set the color	
	vgSetPaint(iPen, VG_STROKE_PATH);	
	
	// Set the color
	vgSetParameteri(iPen, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
	SetVgPaintColor(iPen, iPenColor);	
	SetVgPaintColor(iTextBrush, iPenColor);
	}

/**
Set the current pen style for drawing lines. This corresponds to setting the "stroke dash" pattern in OpenVG.

@see MDirectGdiEngine::SetPenStyle()
 */
void CVgEngine::SetPenStyle(DirectGdi::TPenStyle aStyle)
	{
	iPenStyle = aStyle;
	
	if (!MakeEngineCurrent())
		return;
	
	iPaintMode = iPaintMode | VG_STROKE_PATH;		
	
	switch (aStyle)
		{
		case DirectGdi::ENullPen:
			{
			iPaintMode = iPaintMode & (~VG_STROKE_PATH); // Unset stroke bit
			vgSetfv(VG_STROKE_DASH_PATTERN, 0, NULL);
			vgSetf(VG_STROKE_DASH_PHASE, 0.f);
			break;
			}
			
		case DirectGdi::ESolidPen:
			{
			vgSetfv(VG_STROKE_DASH_PATTERN, 0, NULL);	
			vgSetf(VG_STROKE_DASH_PHASE, 0.f);
			break;
			}
			
		case DirectGdi::EDottedPen:
			{
			VGfloat offset = (iPenSize.iWidth > 1) ? 2.f : 0.f;			
			VGfloat dashPattern[2] = {(1*iPenSize.iWidth)-offset, (3*iPenSize.iWidth)+offset};
			vgSetfv(VG_STROKE_DASH_PATTERN, 2, dashPattern);
			vgSetf(VG_STROKE_DASH_PHASE, 1.f);
			break;
			}
			
		case DirectGdi::EDashedPen:
			{
			VGfloat offset = (iPenSize.iWidth > 1) ? 2.f : 0.f;			
			VGfloat dashPattern[2] = {(3*iPenSize.iWidth)-offset, (3*iPenSize.iWidth)+offset};
			vgSetfv(VG_STROKE_DASH_PATTERN, 2, dashPattern);
			vgSetf(VG_STROKE_DASH_PHASE, (iPenSize.iWidth != 1) ? 1.f : 0.f);
			break;
			}
			
		case DirectGdi::EDotDashPen:
			{
			VGfloat offset = (iPenSize.iWidth > 1) ? 2.f : 0.f;			
			VGfloat dashPattern[4] = {(1*iPenSize.iWidth)-offset, (3*iPenSize.iWidth)+offset, (3*iPenSize.iWidth)-offset, (3*iPenSize.iWidth)+offset};
			vgSetfv(VG_STROKE_DASH_PATTERN, 4, dashPattern);
			vgSetf(VG_STROKE_DASH_PHASE, 1.f);
			break;
			}
			
		case DirectGdi::EDotDotDashPen:
			{
			VGfloat offset = (iPenSize.iWidth > 1) ? 2.f : 0.f;			
			VGfloat dashPattern[6] = {(1*iPenSize.iWidth)-offset, (3*iPenSize.iWidth)+offset, (1*iPenSize.iWidth)-offset, (3*iPenSize.iWidth)+offset, (3*iPenSize.iWidth)-offset, (3*iPenSize.iWidth)+offset};
			vgSetfv(VG_STROKE_DASH_PATTERN, 6, dashPattern);
			vgSetf(VG_STROKE_DASH_PHASE, (iPenSize.iWidth != 1) ? 1.f : 0.f);
			break;			
			}
			
		default:
			{
			// Copy BitGdi behaviour here and draw a solid line for any unknown pen style
			vgSetfv(VG_STROKE_DASH_PATTERN, 0, NULL);
			vgSetf(VG_STROKE_DASH_PHASE, 0.f);
			break;		
			}
		}
	}


/**
@see MDirectGdiEngine::SetPenSize()
 */
void CVgEngine::SetPenSize(const TSize& aSize)
	{
	iPenSize = aSize;
	
	if (!MakeEngineCurrent())
		return;

	// VG_STROKE_LINE_WIDTH expects a float	
	// Note that we set the pen size using just the width in the assumption that the pen width
	// and height are normally the same. For the special cases where the pen width and height
	// are different, the pen size is set to (1,1) then scaled to give the effect of a pen with 
	// different width and height. This is done for all functions in this file that draws shapes,  
	// see Plot(), DrawLine(), DrawArc(), DrawRect() etc.
	vgSetf(VG_STROKE_LINE_WIDTH, aSize.iWidth);	
		
	// Re-set the pen style as the pen size has changed, SetPenStyle() uses the pen size to set 
	// the dotted line styles.
	SetPenStyle(iPenStyle);
	}

/**
@see MDirectGdiEngine::SetTextShadowColor()
*/
void CVgEngine::SetTextShadowColor(const TRgb& aColor)
	{
	iTextShadowColor = aColor; //just cache this color
	}


/**
@see MDirectGdiEngine::SetBrushColor()
*/
void CVgEngine::SetBrushColor(const TRgb& aColor)
	{
	iBrushColor = aColor;
	
	if (!MakeEngineCurrent())
		return;
	
	// Convert the color components as that they are between 0.0f and 1.0f
	VGfloat color[4];	
	color[0] = aColor.Red() * KColorConversion;
	color[1] = aColor.Green() * KColorConversion;
	color[2] = aColor.Blue() * KColorConversion;
	color[3] = aColor.Alpha() * KColorConversion;

	// Make sure our brush is the current selected brush for filling before we set the color
	if (iBrushStyle != DirectGdi::ENullBrush)
		vgSetPaint(iBrush, VG_FILL_PATH);	
	
	vgSetParameteri(iBrush, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
	vgSetParameterfv(iBrush, VG_PAINT_COLOR, 4, color);
	
	// Set the clear color and the tile fill color as well as these should both
	// be the same as the brush color
	vgSetParameterfv(iClearBrush, VG_PAINT_COLOR, 4, color);
	vgSetfv(VG_CLEAR_COLOR, 4, color);
	vgSetfv(VG_TILE_FILL_COLOR, 4, color);
	
	// If using a patterned brush, need to reconstruct it as the colours may be out of sync.
	if ((iBrushStyle != DirectGdi::ENullBrush) && (iBrushStyle != DirectGdi::ESolidBrush))
		{
		SetBrushStyle(iBrushStyle);
		}	
	}


/**
The DirectGDI brush styles do not map directly to OpenVG, so brushes for styles > DirectGdi::EPatternedBrush
are created as bitmaps before being set.

@see MDirectGdiEngine::SetBrushColor()
@see CreateStandardBrush()
*/
void CVgEngine::SetBrushStyle(DirectGdi::TBrushStyle aStyle) 
	{	
	iBrushStyle = aStyle;
	
	if (!MakeEngineCurrent())
		return;
	
	TInt standardBrushErr = KErrNone;
	const TInt standardBrushSize = 3;
	const TInt standardBrushArea = standardBrushSize*standardBrushSize;
	const TInt diamondCrossHatchBrushSize = 4;
	const TInt diamondCrossHatchBrushArea = diamondCrossHatchBrushSize*diamondCrossHatchBrushSize;
	
	// Select the brush for drawing any style that is not ENullBrush
	iPaintMode = iPaintMode | VG_FILL_PATH;
	if (aStyle != DirectGdi::ENullBrush)
		vgSetPaint(iBrush, VG_FILL_PATH);

	// Paint using a pattern for all styles that are not ENullBrush or ESolidBrush
	if ((aStyle != DirectGdi::ENullBrush) && (aStyle != DirectGdi::ESolidBrush))
		{		
		vgSetParameteri(iBrush, VG_PAINT_TYPE, VG_PAINT_TYPE_PATTERN);
		vgSetParameteri(iBrush, VG_PAINT_PATTERN_TILING_MODE, VG_TILE_REPEAT);
		}	

	switch (aStyle)
		{
		case DirectGdi::ENullBrush:					
			iPaintMode = iPaintMode & (~VG_FILL_PATH);
			
			// Clear the current brush so that no brush color is drawn
			vgSetPaint(VG_INVALID_HANDLE, VG_FILL_PATH);
			break;			

		case DirectGdi::ESolidBrush:			
			// Paint using a solid color
			vgSetParameteri(iBrush, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
			break;			

		case DirectGdi::EPatternedBrush:						
			// Make sure the user has set a patterned brush for use
			GRAPHICS_ASSERT_ALWAYS(iBrushPatternUser != VG_INVALID_HANDLE, EDirectGdiPanicPatternedBrushNotSet);						
			
			if (NonZeroBrushPatternOrigin())
				{
				// The brush origin is non-zero, update the non-zero origin brush 
				// with the user brush and use that instead of the user brush
				CopyCurrentBrushPatternForNonZeroOrigin();										
				}
			else
				{
				// Set the brush to fill with the user selected bitmap pattern
				vgPaintPattern(iBrush, iBrushPatternUser);
				}
			break;			

		case DirectGdi::EVerticalHatchBrush:
			{
			// The brush fills with vertical hatching  lines going from top to bottom
			TSize size(standardBrushSize, standardBrushSize);
			VGbyte brushPattern[standardBrushArea] = {0,0,1, 0,0,1, 0,0,1};
			standardBrushErr = CreateStandardBrush(size, brushPattern);
			break;
			}
		
		case DirectGdi::EForwardDiagonalHatchBrush:
			{
			// The brush fills with diagonal hatching lines going from bottom left to top right
			TSize size(standardBrushSize, standardBrushSize);
			VGbyte brushPattern[standardBrushArea] = {1,0,0, 0,0,1, 0,1,0};
			standardBrushErr = CreateStandardBrush(size, brushPattern);
			break;
			}
		
		case DirectGdi::EHorizontalHatchBrush:
			{
			// The brush fills with horizontal hatching lines going from left to right
			TSize size(standardBrushSize, standardBrushSize);
			VGbyte brushPattern[standardBrushArea] = {0,0,0, 0,0,0, 1,1,1};
			standardBrushErr = CreateStandardBrush(size, brushPattern);
			break;
			}
		
		case DirectGdi::ERearwardDiagonalHatchBrush:
			{
			// The brush fills with rearward diagonal hatching lines going from top left to bottom right
			TSize size(standardBrushSize, standardBrushSize);
			VGbyte brushPattern[standardBrushArea] = {1,0,0, 0,1,0, 0,0,1};
			standardBrushErr = CreateStandardBrush(size, brushPattern);
			break;
			}
		
		case DirectGdi::ESquareCrossHatchBrush:
			{
			// The brush fills with horizontal and vertical hatching lines going from left to right 
			// plus lines going from top to bottom  giving the effect of a grid of small squares
			TSize size(standardBrushSize, standardBrushSize);
			VGbyte brushPattern[standardBrushArea] = {0,0,1, 0,0,1, 1,1,1};
			standardBrushErr = CreateStandardBrush(size, brushPattern);
			break;
			}
		
		case DirectGdi::EDiamondCrossHatchBrush:
			{
			// The brush fills with forward diagonal and rearward diagonal hatching lines going from  
			// bottom left to top right plus lines going from top left to bottom right giving the effect  
			// of a grid of small diamonds
			// The brush fills with diagonal hatching lines going from bottom left to top right
			TSize size(diamondCrossHatchBrushSize, diamondCrossHatchBrushSize);
			VGbyte brushPattern[diamondCrossHatchBrushArea] = {0,0,1,0, 0,1,0,1, 1,0,0,0, 0,1,0,1};
			standardBrushErr = CreateStandardBrush(size, brushPattern);
			break;	
			}		
		}
	
	// Select the standard brush for all styles > EPatternedBrush
	if (aStyle > DirectGdi::EPatternedBrush)
		{
		if (standardBrushErr == KErrNone)
			{
			if (NonZeroBrushPatternOrigin())
				{
				// The brush origin is non-zero, update the non-zero origin brush 
				// with the standard brush and use that instead of the standard brush
				CopyCurrentBrushPatternForNonZeroOrigin();
				}
			else
				{
				// Use the standard brush region
				vgPaintPattern(iBrush, iBrushPatternStandardRegion);
				}
			}
		else
			{
			iDriver.SetError(standardBrushErr);
			}
		}
	else
		{
		vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_NORMAL);
		}
	}

/**
@see MDirectGdiEngine::SetBrushOrigin()
 */
void CVgEngine::SetBrushOrigin(const TPoint& aOrigin) 
	{
	iBrushOrigin = aOrigin;
	if (NonZeroBrushPatternOrigin())
		{
		// Copy the current brush pattern into iBrushPatternNonZeroOrigin, but shift it to
		// take into account the current non-zero brush origin.
		CopyCurrentBrushPatternForNonZeroOrigin();		
		}
	}


/**
@see MDirectGdiEngine::SetBrushPattern()
 */
TInt CVgEngine::SetBrushPattern(const CFbsBitmap& aPattern) 
	{
	if (aPattern.ExtendedBitmapType() != KNullUid)
		{
		return KErrNotSupported; // Not supported for extended bitmaps
		}
	
	// Destroy any previously set brush pattern
	MakeEngineCurrent();
	ResetBrushPattern();	
	iBrushPatternUser = CreateSourceVGImage(aPattern);
	if (iBrushPatternUser == VG_INVALID_HANDLE)
		{
		return KErrNoMemory;
		}

	iBrushPatternUserSize = aPattern.SizeInPixels();
	iBrushPatternUserBitmapHandle = aPattern.Handle();
	return KErrNone;
	}


/**
@see MDirectGdiEngine::ResetBrushPattern()
 */
void CVgEngine::ResetBrushPattern() 
	{
	MakeEngineCurrent();
	if (iBrushPatternUser != VG_INVALID_HANDLE)
		{
		vgDestroyImage(iBrushPatternUser);
		iBrushPatternUser = VG_INVALID_HANDLE;
		iBrushPatternUserBitmapHandle = KNullHandle;
		iBrushPatternUserSize = TSize(0,0);
		}	
	}

/**
@see MDirectGdiEngine::SetFont()
*/
void CVgEngine::SetFont(TUint32 aFontId) 
	{
	iFontId = aFontId;
	}


/**
@see MDirectGdiEngine::ResetFont()
 */
void CVgEngine::ResetFont() 
	{
	iFontId = 0;
	}

/**
Reset all the VgEngine-specific settings. Generic settings such as paint colour and pen colour
are set by calls from the CDirectGdiContext.
	
@see MDirectGdiEngine::Reset()

@post All VgEngine-specific settings have been reset to their default values.
 */
void CVgEngine::Reset() 
	{
	if (!MakeEngineCurrent())
		return;

	ResetVgMatrix();
	}



/**
@see MDirectGdiEngine::Clear(const TRect&)

@panic DGDIAdapter 62, if the brush for clearing is not valid (debug-only).
*/
void CVgEngine::Clear(const TRect& aRect) 
	{
	MakeEngineCurrent();

	if (255 == iBrushColor.Alpha())
		{
		const TPoint rectOrigin = ConvertToVgCoords(aRect);
		for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
			vgClear(rectOrigin.iX, rectOrigin.iY, aRect.Width(), aRect.Height());
		}
	else
		{
		// If blending is enabled, we cannot use vgClear as it ignores the current blendmode and performs a WriteAlpha.
		// Therefore a clear is done by a filled rectangle.
		
		// The Clear brush should always be a solid brush.
		GRAPHICS_ASSERT_DEBUG(vgGetParameteri(iClearBrush, VG_PAINT_TYPE) == VG_PAINT_TYPE_COLOR, EDirectGdiPanicClearBrushInvalid);
				
		if (PreparePath(iVgPath, 5))
			{
			// Before any vgu command, call SetError() as this stores the current OpenVG error state (if any) 
			// on the driver. Some implementations of vgu clears error state so we'd lose error codes otherwise.
			iDriver.SetError(KErrNone);
			
			VGUErrorCode err = vguRect(iVgPath, aRect.iTl.iX, aRect.iTl.iY, aRect.Width(), aRect.Height());
			if (err == VGU_NO_ERROR)
				{
				// Temporarily set the brush to the clear brush and fill the path.
				vgSetPaint(iClearBrush, VG_FILL_PATH);
				for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
					vgDrawPath(iVgPath, VG_FILL_PATH);
				vgSetPaint(iBrush, VG_FILL_PATH);	
				}
			else
				{
				SetVguError(err);
				}
			}
		}
	}

/**
@see MDirectGdiEngine::Clear()
 */
void CVgEngine::Clear() 
	{
	Clear(TRect(iSize));
	}

/**
@see MDirectGdiEngine::MoveTo()
 */
void CVgEngine::MoveTo(const TPoint& aPoint) 
	{
	iLinePos = aPoint;
	}

/**
@see MDirectGdiEngine::MoveBy()
 */
void CVgEngine::MoveBy(const TPoint& aVector) 
	{
	iLinePos += aVector;
	}

/**
@see MDirectGdiEngine::Plot()
 */
void CVgEngine::Plot(const TPoint& aPoint) 
	{
	MakeEngineCurrent();
	GRAPHICS_ASSERT_DEBUG(vgGeti(VG_STROKE_CAP_STYLE) == VG_CAP_ROUND,  EDirectGdiPanicPenEndCapStyleNotRound);

	
	// If the pen width and height are equal just plot as normal. 
	if (iPenSize.iWidth == iPenSize.iHeight)
		{
		if (PreparePath(iVgPath, 2))
			{
			// A point is plotted by drawing a line with start and end points the same.
			AppendPathCommand(VG_MOVE_TO_ABS, aPoint.iX + 0.5f, aPoint.iY + 0.5f);
			AppendPathCommand(VG_HLINE_TO_REL, 0.f);
			FinishPath(iVgPath);
			
			for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
				vgDrawPath(iVgPath, iPaintMode&VG_STROKE_PATH);
			}
		}
	else if ((iPenSize.iWidth != 0) && (iPenSize.iHeight != 0))
		{
		// Setting a pen with different width and height is not available on OpenVG, so we need to scale 
		// the coordinates we are drawing and apply a scaling matrix that scales by the width and height 
		// of the pen to get the effect of a pen width different width and height.
		if (PreparePath(iVgPath, 2))
			{
			TSize penSize = iPenSize;
			SetPenSize(TSize(1, 1));
			vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
			vgScale(penSize.iWidth, penSize.iHeight);
			
			// A point is plotted by drawing a line with start and end points the same.
			AppendPathCommand(VG_MOVE_TO_ABS, (aPoint.iX + 0.5f)/(float)penSize.iWidth, (aPoint.iY + 0.5f)/(float)penSize.iHeight);
			AppendPathCommand(VG_HLINE_TO_REL, 0.f);
			FinishPath(iVgPath);
			
			vgDrawPath(iVgPath, iPaintMode&VG_STROKE_PATH);
			
			ResetVgMatrix(VG_MATRIX_PATH_USER_TO_SURFACE);
			SetPenSize(penSize);
			}								
		}	
	}

/**
@see MDirectGdiEngine::DrawLine()
 */
void CVgEngine::DrawLine(const TPoint& aStart, const TPoint& aEnd)
	{
	MakeEngineCurrent();
	GRAPHICS_ASSERT_DEBUG(vgGeti(VG_STROKE_CAP_STYLE) == VG_CAP_ROUND, EDirectGdiPanicPenEndCapStyleNotRound);
	
    if (iPaintMode == 0)
		{
		return;
		}    
	
	if (PreparePath(iVgPath, 2))
		{
		// If the pen width and height are the same then draw as normal
		if (iPenSize.iWidth == iPenSize.iHeight)
			{
			// 0.5 is appended to all OpenVG drawing co-ordinates as when specifying them, the spec says
			// co-ordinates are relative to pixel boundaries, not pixel centres, so 0,0 is the top left of the
			// top pixel. We need to add 0.5 to specify the centre of pixels.
			
			AppendPathCommand(VG_MOVE_TO_ABS, aStart.iX + 0.5f, aStart.iY + 0.5f);		
			if (aStart.iX == aEnd.iX)
				{
				AppendPathCommand(VG_VLINE_TO_ABS, aEnd.iY + 0.5f);			
				}
			else if (aStart.iY == aEnd.iY)
				{
				AppendPathCommand(VG_HLINE_TO_ABS, aEnd.iX + 0.5f);			
				}
			else
				{
				AppendPathCommand(VG_LINE_TO_ABS, aEnd.iX + 0.5f, aEnd.iY + 0.5f);
				}		
			FinishPath(iVgPath);
			for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
				vgDrawPath(iVgPath, iPaintMode);			
			}
		else if ((iPenSize.iWidth != 0) && (iPenSize.iHeight != 0))
			{
			// Setting a pen with different width and height is not available on OpenVG, so we need to scale 
			// the coordinates we are drawing and apply a scaling matrix that scales by the width and height 
			// of the pen to get the effect of a pen width different width and height.
			TSize penSize = iPenSize;
			SetPenSize(TSize(1, 1));
			vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
			vgScale(penSize.iWidth, penSize.iHeight);
					
			VGfloat scaleX = 1.0f/(float)penSize.iWidth;
			VGfloat scaleY = 1.0f/(float)penSize.iHeight;
			AppendPathCommand(VG_MOVE_TO_ABS, (aStart.iX + 0.5f)*scaleX, (aStart.iY + 0.5f)*scaleY);		
			if (aStart.iX == aEnd.iX)
				{
				AppendPathCommand(VG_VLINE_TO_ABS, (aEnd.iY + 0.5f)*scaleY);			
				}
			else if (aStart.iY == aEnd.iY)
				{
				AppendPathCommand(VG_HLINE_TO_ABS, (aEnd.iX + 0.5f)*scaleX);			
				}
			else
				{
				AppendPathCommand(VG_LINE_TO_ABS, (aEnd.iX + 0.5f)*scaleX, (aEnd.iY + 0.5f)*scaleY);
				}		
			FinishPath(iVgPath);				
			vgDrawPath(iVgPath, iPaintMode);
			
			ResetVgMatrix(VG_MATRIX_PATH_USER_TO_SURFACE);
			SetPenSize(penSize);
			}			
		}	

	iLinePos = aEnd;
	}

/**
@see MDirectGdiEngine::DrawLineTo()
 */
void CVgEngine::DrawLineTo(const TPoint& aPoint)
	{
	DrawLine(iLinePos, aPoint);
	}

/**
@see MDirectGdiEngine::DrawLineBy()
 */
void CVgEngine::DrawLineBy(const TPoint& aVector)
	{
	DrawLine(iLinePos, iLinePos + aVector);
	}

/**
@see MDirectGdiEngine::DrawRect()
 */
void CVgEngine::DrawRect(const TRect& aRect)
	{
	MakeEngineCurrent();
	
	// Only draw if we are not painting with a NULL pen and a NULL brush
	if (iPaintMode == 0)
		return;
	
	// If the pen size is larger then 1, make sure we are using the ESolidPen
	// pen style (to match BitGdi behaviour)
	DirectGdi::TPenStyle savedPenStyle = iPenStyle;
	if (((iPenSize.iWidth > 1) || (iPenSize.iHeight > 1)) && (iPenStyle > DirectGdi::ESolidPen))
		SetPenStyle(DirectGdi::ESolidPen);
	
	// Create a copy of the rect. If the pen style is not null, we have to shrink the 
	// width and height of the rect by one pixel at the bottom left corner for conformance.	
	TRect copyRect(aRect.iTl.iX, aRect.iTl.iY, aRect.iBr.iX, aRect.iBr.iY-1);
	if (iPenStyle != DirectGdi::ENullPen)
		{
		--copyRect.iBr.iX;
		}
	else
		{
		--copyRect.iTl.iY;
		}

	const TBool symmetricalPenSize = iPenSize.iWidth == iPenSize.iHeight;
	
	// If the pen is so thick it covers the entire area of the rect, don't do the fill, as per BitGdi.
	const TBool penThickerThanRect = (iPenSize.iWidth >= copyRect.Width()) || (iPenSize.iHeight >= copyRect.Height());
	
	// If the pen width and height are the same then draw as normal. If they are different but we should be filling
	// this shape we need to draw the filled area only as normal (not the outline). The outline of the shape is drawn 
	// in the block of code below to allow the effect of a different width and height pen to be applied.
	if (!penThickerThanRect || (iPenStyle == DirectGdi::ENullPen))
		{
		if (symmetricalPenSize || (iPaintMode & VG_FILL_PATH))
			{
			if (PreparePath(iVgPath, 5))
				{
				vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_MITER);
				AppendPathCommand(VG_MOVE_TO_ABS, copyRect.iTl.iX + 0.5f, copyRect.iTl.iY + 0.5f);
				AppendPathCommand(VG_HLINE_TO_ABS, copyRect.iBr.iX + 0.5f);
				AppendPathCommand(VG_VLINE_TO_ABS, copyRect.iBr.iY + 0.5f);
				AppendPathCommand(VG_HLINE_TO_ABS, copyRect.iTl.iX + 0.5f);
				AppendPathCommand(VG_CLOSE_PATH);
				FinishPath(iVgPath);
			
				for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
					vgDrawPath(iVgPath, symmetricalPenSize ? iPaintMode : VG_FILL_PATH);
				vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
				}
			}
		}
	if((penThickerThanRect && (iPenStyle != DirectGdi::ENullPen)) ||  //we shouldn't draw if pen style is null
		(!symmetricalPenSize &&	(iPaintMode & VG_STROKE_PATH) && (iPenSize.iWidth != 0) && (iPenSize.iHeight != 0)))
		{
		// Setting a pen with different width and height is not available on OpenVG, so we need to scale 
		// the coordinates we are drawing and apply a scaling matrix that scales by the width and height 
		// of the pen to get the effect of a pen width different width and height.
		TSize penSize = iPenSize;
		SetPenSize(TSize(1, 1));
		vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
		vgScale(penSize.iWidth, penSize.iHeight);
			
		if (PreparePath(iVgPath, 5))
			{
			vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_MITER);
			VGfloat scaleX = 1.0f/(float)penSize.iWidth;
			VGfloat scaleY = 1.0f/(float)penSize.iHeight;
			AppendPathCommand(VG_MOVE_TO_ABS, (copyRect.iTl.iX + 0.5f)*scaleX, (copyRect.iTl.iY + 0.5f)*scaleY);
			AppendPathCommand(VG_HLINE_TO_ABS, (copyRect.iBr.iX + 0.5f)*scaleX);
			AppendPathCommand(VG_VLINE_TO_ABS, (copyRect.iBr.iY + 0.5f)*scaleY);
			AppendPathCommand(VG_HLINE_TO_ABS, (copyRect.iTl.iX + 0.5f)*scaleX);
			AppendPathCommand(VG_CLOSE_PATH);
			FinishPath(iVgPath);
			for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
				vgDrawPath(iVgPath, VG_STROKE_PATH);
			vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
			}
		
		ResetVgMatrix(VG_MATRIX_PATH_USER_TO_SURFACE);
		SetPenSize(penSize);
		}

	// Reset the pen style if we changed it above
	if (savedPenStyle != iPenStyle)
		SetPenStyle(savedPenStyle);
	}

/**
@see MDirectGdiEngine::DrawRoundRect()
 */
void CVgEngine::DrawRoundRect(const TRect& aRect, const TSize& aCornerSize) 
	{
	MakeEngineCurrent();
	
	// Only draw if we are not painting with a NULL pen and a NULL brush
	if (iPaintMode == 0)		
		return;
	
	// Create a copy of the rect. If the pen style is not null, we have to shrink the 
	// width and height of the rect by one pixel at the bottom left corner for conformance.	
	TRect copyRect(aRect.iTl.iX, aRect.iTl.iY, aRect.iBr.iX, aRect.iBr.iY-1);
	if (iPenStyle != DirectGdi::ENullPen)
		{
		--copyRect.iBr.iX;
		}
	//If the penstyle is null and brush style is not null, then reduce the width and height by
	//two pixels for conformation.
	else if(iBrushStyle != DirectGdi::ENullBrush)
		{
		----copyRect.iBr.iX;		
		--copyRect.iBr.iY;
		}
	else if(iPenStyle == DirectGdi::ENullPen)
		{
		--copyRect.iTl.iY;
		}
	
	// check that the corner size is less than the rectangle size
	if ((aRect.Width() > aCornerSize.iWidth) || (aRect.Height() > aCornerSize.iHeight))
		{									
		// Before any vgu command, call SetError() as this stores the current vg error state (if any) in the 
		// driver. Some implementations of vgu clears error state so we'd lose error codes otherwise.
		iDriver.SetError(KErrNone);
		
		// If the pen width and height are the same then draw as normal. If they are different but we should be filling
		// this shape we need to draw the filled area only as normal (not the outline). The outline of the shape is drawn 
		// in the block of code below to allow the effect of a different width and height pen to be applied.
		if ((iPenSize.iWidth == iPenSize.iHeight) || (iPaintMode & VG_FILL_PATH))
			{
			if (PreparePath(iVgPath, 10))
				{
				VGUErrorCode err = vguRoundRect(iVgPath,
											copyRect.iTl.iX + 0.5f, 
											copyRect.iTl.iY + 0.5f,
											copyRect.Width(), 
											copyRect.Height(),
											aCornerSize.iWidth * 2, 
											aCornerSize.iHeight * 2);	
				
				if (err == VGU_NO_ERROR)
					{
					for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
						vgDrawPath(iVgPath, (iPenSize.iWidth == iPenSize.iHeight) ? iPaintMode : VG_FILL_PATH);	
					}
				else
					{
					SetVguError(err);
					}
				}
			}
		
		if ((iPenSize.iWidth != iPenSize.iHeight)
		&& (iPaintMode & VG_STROKE_PATH)		
		&& (iPenSize.iWidth != 0) && (iPenSize.iHeight != 0))
			{
			// Setting a pen with different width and height is not available on OpenVG, so we need to scale 
			// the coordinates we are drawing and apply a scaling matrix that scales by the width and height 
			// of the pen to get the effect of a pen width different width and height.
			TSize penSize = iPenSize;
			SetPenSize(TSize(1, 1));
			vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
			vgScale(penSize.iWidth, penSize.iHeight);
			
			if (PreparePath(iVgPath, 10))
				{
				VGfloat scaleX = 1.0f/(float)penSize.iWidth;
				VGfloat scaleY = 1.0f/(float)penSize.iHeight;
				VGUErrorCode err = vguRoundRect(iVgPath,
							                (copyRect.iTl.iX + 0.5f) * scaleX, 
							                (copyRect.iTl.iY + 0.5f) * scaleY,
							                copyRect.Width() * scaleX, 
							                copyRect.Height() * scaleY,
							                (aCornerSize.iWidth * 2) * scaleX, 
							                (aCornerSize.iHeight * 2) * scaleY);	
				if (err == VGU_NO_ERROR)
					{
					vgDrawPath(iVgPath, VG_STROKE_PATH);		
					}
				else
					{
					SetVguError(err);
					}
				}
			
			ResetVgMatrix(VG_MATRIX_PATH_USER_TO_SURFACE);
			SetPenSize(penSize);
			}
		}
	else
		{
		// Draw an ellipse as the corner size is greater than or equal to the rectangle size
		DrawEllipse(copyRect);
		}
	}

/**
@see MDirectGdiEngine::DrawPolyLine()

@panic DGDIAdapter 27, if the passed point list has zero points (debug-only).
 */
void CVgEngine::DrawPolyLine(const TArray<TPoint>& aPointList)
	{
	DrawPolyLineNoEndPoint(aPointList);
	
	// Do a plot at the end point to improve the appearance. For larger pen-sizes, a plot
	// improves the correlation with BitGDI polylines, giving a subtly more rounded finish.
	if (DirectGdi::ESolidPen == iPenStyle)
		{
		Plot(iLinePos);
		}
	}

/**
@see MDirectGdiEngine::DrawPolyLineNoEndPoint()

@panic DGDIAdapter 27, if the passed point list has zero points (debug-only).
 */
void CVgEngine::DrawPolyLineNoEndPoint(const TArray<TPoint>& aPointList)
	{
	MakeEngineCurrent();

	GRAPHICS_ASSERT_DEBUG(aPointList.Count() > 0, EDirectGdiPanicInvalidPointArray);
	
	DoDrawPoly(aPointList, EFalse);
	}

/**
@see MDirectGdiEngine::DrawPolygon()

@panic DGDIAdapter 26, if the passed fill-rule is invalid (debug-only).
 */
void CVgEngine::DrawPolygon(const TArray<TPoint>& aPoints, DirectGdi::TFillRule aRule)
	{
	MakeEngineCurrent();
	
	GRAPHICS_ASSERT_DEBUG(aPoints.Count() > 0, EDirectGdiPanicInvalidPointArray);
	
	switch(aRule)
	    {
		case DirectGdi::EAlternate:
			vgSeti(VG_FILL_RULE, VG_EVEN_ODD); 
			break;
		case DirectGdi::EWinding: 
			vgSeti(VG_FILL_RULE, VG_NON_ZERO); 
			break;
		default: 
			GRAPHICS_PANIC_DEBUG(EDirectGdiPanicInvalidFillRule);
			return;
	    };
	
	DoDrawPoly(aPoints, ETrue);
	}

/**
Helper function to assist with drawing polygons with DrawPolygon()/DrawPolyLine(). It takes care of 
drawing the array of points given to it. It sets the internal drawing poisition to the last TPoint
in the array.

@see	DrawPolyLine()
@see 	DrawPolygon()

@param	aPoints	Array of points specifying the vertices of the polygon. There must be at least one 
		vertex.
@param  aClosed	If ETrue, the start and end points are joined, and the polygon filled using current 
        brush settings, otherwise just a polyline is drawn.
*/
void CVgEngine::DoDrawPoly(const TArray<TPoint>& aPoints, TBool aClosed)
	{
	GRAPHICS_ASSERT_DEBUG(aPoints.Count() > 0, EDirectGdiPanicInvalidPointArray);	
	const TInt numPoints = aPoints.Count();	
	
	// Set drawing position to last point in the array (regardless of whether the poly is open/closed)
	iLinePos = aPoints[numPoints - 1];
	
	// Set the paint mode depending on whether we are drawing a line (not closed) or a poly (closed)
	VGbitfield paintMode = iPaintMode;
	if (!aClosed)
		{
		paintMode &= ~VG_FILL_PATH;
		}
	
	if (!paintMode)
		{
		return;
		}

	// If the pen width and height are the same then draw as normal. If they are different but we should be filling
	// this shape we need to draw the filled area only as normal (not the outline). The outline of the shape is drawn 
	// in the block of code below to allow the effect of a different width and height pen to be applied.
	if ((iPenSize.iWidth == iPenSize.iHeight) || (paintMode & VG_FILL_PATH))
		{
		if (PreparePath(iVgPath, aClosed ? numPoints + 1 : numPoints))
			{
			AppendPathCommand(VG_MOVE_TO_ABS, aPoints[0].iX + 0.5f, aPoints[0].iY + 0.5f);
			for (TInt point = 0; point < numPoints; ++point)
				{
				AppendPathCommand(VG_LINE_TO_ABS, aPoints[point].iX + 0.5f, aPoints[point].iY + 0.5f);	
				}
			if (aClosed)
				{
				AppendPathCommand(VG_CLOSE_PATH);
				}
			FinishPath(iVgPath);
			for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
				vgDrawPath(iVgPath, (iPenSize.iWidth == iPenSize.iHeight) ? paintMode : VG_FILL_PATH);
			}
		}
	
	if ((iPenSize.iWidth != iPenSize.iHeight)
		&& (paintMode & VG_STROKE_PATH)		
		&& (iPenSize.iWidth != 0) && (iPenSize.iHeight != 0))
		{
		// Setting a pen with different width and height is not available on OpenVG, so we need to scale 
		// the coordinates we are drawing and apply a scaling matrix that scales by the width and height 
		// of the pen to get the effect of a pen width different width and height.
		TSize penSize = iPenSize;
		SetPenSize(TSize(1, 1));
		vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
		vgScale(penSize.iWidth, penSize.iHeight);
		
		if (PreparePath(iVgPath, aClosed ? numPoints + 1 : numPoints))
			{
			AppendPathCommand(VG_MOVE_TO_ABS, (aPoints[0].iX + 0.5f)/(float)penSize.iWidth, (aPoints[0].iY + 0.5f)/(float)penSize.iHeight);
			for (TInt point = 0; point < numPoints; ++point)
				{
				AppendPathCommand(VG_LINE_TO_ABS, (aPoints[point].iX + 0.5f)/(float)penSize.iWidth, (aPoints[point].iY + 0.5f)/(float)penSize.iHeight);	
				}				
			if (aClosed)
				{
				AppendPathCommand(VG_CLOSE_PATH);
				}			
			FinishPath(iVgPath);		
			vgDrawPath(iVgPath, VG_STROKE_PATH);
			}
		
		ResetVgMatrix(VG_MATRIX_PATH_USER_TO_SURFACE);
		SetPenSize(penSize);
		}
			
	}

/**
@see MDirectGdiEngine::DrawArc()
@see DrawPie()
@see DrawArc(const TRect&, const TPoint&, const TPoint&, VGUArcType)
 */
void CVgEngine::DrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd) 
	{	
	DoDrawArc(aRect, aStart, aEnd, VGU_ARC_OPEN);
	}

/**
@see MDirectGdiEngine::DrawPie()
@see DrawArc(const TRect&, const TPoint&, const TPoint&)
@see DrawArc(const TRect&, const TPoint&, const TPoint&, VGUArcType)
 */
void CVgEngine::DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd) 
	{	
	DoDrawArc(aRect, aStart, aEnd, VGU_ARC_PIE);
	}

/**
@see MDirectGdiEngine::DrawEllipse()
 */
void CVgEngine::DrawEllipse(const TRect& aRect) 
	{
	// Null brush and pen, draw nothing.
	if (iPaintMode == 0)
		return;
	
	MakeEngineCurrent();	
	VGfloat x = (aRect.iTl.iX + aRect.iBr.iX) * 0.5;
	VGfloat y = (aRect.iTl.iY + aRect.iBr.iY) * 0.5;
	
	// Before any vgu command, call SetError() as this stores the current vg error state (if any) in the 
	// driver. Some implementations of vgu clears error state so we'd lose error codes otherwise.
	iDriver.SetError(KErrNone);
	
	TInt width = aRect.Width();
	TInt height = aRect.Height();
	
	//If the penstyle is null and brush style is not null, then reduce the width and height by
	//two pixels for conformation.
	if(iPenStyle == DirectGdi::ENullPen && iBrushStyle != DirectGdi::ENullBrush)
		{
		width = aRect.Width() > 2 ? aRect.Width() - 2 : 1;
		height = aRect.Height() > 2 ? aRect.Height() - 2 : 1;
		}
	
	// If the pen width and height are the same then draw as normal. If they are different but we should be filling
	// this shape we need to draw the filled area only as normal (not the outline). The outline of the shape is drawn 
	// in the block of code below to allow the effect of a different width and height pen to be applied.
	if ((iPenSize.iWidth == iPenSize.iHeight) || (iPaintMode & VG_FILL_PATH))
		{
		if (PreparePath(iVgPath, 4))
			{
			VGUErrorCode err = vguEllipse(iVgPath, x, y, width, height);
			if (err == VGU_NO_ERROR)
				{
				for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
					vgDrawPath(iVgPath, (iPenSize.iWidth == iPenSize.iHeight) ? iPaintMode : VG_FILL_PATH);
				}
			else
				{
				SetVguError(err);
				}
			}
		}
	
	if ((iPenSize.iWidth != iPenSize.iHeight)
		&& (iPaintMode & VG_STROKE_PATH)		
		&& (iPenSize.iWidth != 0) && (iPenSize.iHeight != 0))
		{
		// Setting a pen with different width and height is not available on OpenVG, so we need to scale 
		// the coordinates we are drawing and apply a scaling matrix that scales by the width and height 
		// of the pen to get the effect of a pen width different width and height.
		TSize penSize = iPenSize;
		SetPenSize(TSize(1, 1));
		vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
		vgScale(penSize.iWidth, penSize.iHeight);
		
		VGfloat scaleX = 1.0f/(float)penSize.iWidth;
		VGfloat scaleY = 1.0f/(float)penSize.iHeight;
		
		if (PreparePath(iVgPath, 4))
			{
			VGUErrorCode err = vguEllipse(iVgPath, x*scaleX, y*scaleY, (float)width*scaleX, (float)height*scaleY);			
			if (err == VGU_NO_ERROR)
				{
				vgDrawPath(iVgPath, VG_STROKE_PATH);
				}
			else
				{
				SetVguError(err);
				}
			}
		
		ResetVgMatrix(VG_MATRIX_PATH_USER_TO_SURFACE);
		SetPenSize(penSize);			
		}	
	}

/**
Given a TDisplayMode, returns the closest TDisplayMode that is pixel-for-pixel-compatible
with an OpenVG format, such that the given TDisplayMode may be converted into the result
without loss of colour information.

@param 	aDisplayMode Pixel format to find a match for.

@return Closest TDisplayMode for which there is a OpenVG-compatible match.
 */
static TDisplayMode ClosestVgCompatibleDisplayMode(TDisplayMode aDisplayMode)
	{
	switch (aDisplayMode)
		{
		case EGray2:
		case EGray4:
		case EGray16:
			return EGray256;

		case EColor16:
		case EColor256:
		case EColor4K:
			return EColor64K;
		
		case EColor16M:
			return EColor16MU;
			
		default:
			return aDisplayMode;
		}
	}

/**
Converts a CFbsBitmap into a VGImage.
If the CFbsBitmap is not a volatile bitmap, the VGImage created will be stored in the thread-wide 
VGImage cache. If the CFbsBitmap has been touched (i.e. its data has been changed since it was last 
used), a new VGImage will be created and will replace that currently stored in the cache. An untouched 
bitmap will store the created VGImage in the cache upon first use, and on subsequent use (if it is 
still untouched), will just retrieve the VGImage stored in the cache.

@param aBitmap The CFbsBitmap to create a VGImage from.
@param aImage Returns the VGImage created from the CFbsBitmap.
@param aIsMask True if the CFbsBitmap is to be used as a mask.
@param aOrigin Position of the first pixel in the mask bitmap.

@return ETrue if the VGimage has been stored in the cache, EFalse if not.
*/
TBool CVgEngine::ConvertBitmapToVgImage(const CFbsBitmap& aBitmap, VGImage& aImage, TBool aIsMask, const TPoint& aOrigin)
	{
	TBool createImage =  EFalse;
	TBool storeImageInCache = EFalse;
	TBool imageCached = EFalse;
	// Set the options createImage, storeImageInCache and imageCached depending on
	// whether the bitmap is volatile, has been touched since last used,
	// and whether it already exists in the cache
	if (aBitmap.IsVolatile()) 
		{
		// Source bitmap is volatile and so should not be stored in cache.
		// Therefore create image only.
		createImage = ETrue;
		}
	else //bitmap not volatile
		{
		// Source bitmap has not changed since last used.
		// Retrieve from cache the image created from the bitmap and the touchCount of that image.
		aImage = iDriver.GetVgImageFromCache(aBitmap, aOrigin);
		// If the source bitmap already has an associated VGImage stored in the cache,
		// just use that VGImage.  Otherwise, need to create a VGImage and add it to the cache.
		if (aImage == VG_INVALID_HANDLE)
			{
			// VGImage not in cache
			// Create image, and store in cache
			createImage = ETrue;
			storeImageInCache = ETrue;
			}
		else
			{
			// Image already in cache
			imageCached = ETrue;
			}
		}

	// Create a new VGImage if needed
	if (createImage)
		{
		aImage = CreateSourceVGImage(aBitmap, aIsMask, aOrigin);
		// Error set on creation of VGImage if aImage == VG_INVALID_HANDLE.
		}
	// Store the VGImage in the cache if appropriate
	if (storeImageInCache && aImage != VG_INVALID_HANDLE)
		{
		imageCached = iDriver.AddVgImageToCache(aBitmap, aImage, aOrigin);
		}
	return imageCached;
	}


/**
Transforms coordinates for a TRect from Symbian Graphics to OpenVG surface coordinates.
This is required for OpenVG operations which are not subject to user-to-surface 
coordinate system transformations.

OpenVG coordinates locate the BOTTOM LEFT corner of the object relative to an origin
at the BOTTOM LEFT of the rendering area.

Symbian Graphics coordinates locate the TOP LEFT corner of the object relative to an 
origin located at the TOP LEFT of the rendering area.

@param	aCoord		Top-left of the rectangle, in Symbian graphics coordinates.
@param  aWidth		The width of the desired rectangle.
@param  aHeight		The height of the desired rectangle.
@return A TRect in OpenVG coordinates which describes a rectangle at aCoord with aWidth and aHeight.
*/
TRect CVgEngine::SgMetricsToVgTRect(const TPoint& aCoord, const TInt aWidth, const TInt aHeight) const
	{
	return TRect (TPoint (aCoord.iX + iOrigin.iX, iSize.iHeight - (aCoord.iY + aHeight) - iOrigin.iY), TSize (aWidth, aHeight));
	}

/** 
@see MDirectGdiEngine::BitBlt()
@see BitBltMasked(const TPoint&, const CFbsBitmap&, const TRect&, const CFbsBitmap&, TBool)
@see BitBltMasked(const TPoint&, const CFbsBitmap&, const TRect&, const CFbsBitmap&, const TPoint&)
 */
void CVgEngine::BitBlt(const TPoint& aDestPos, const CFbsBitmap& aSourceBitmap, const TRect& aSourceRect)
	{
	if (aSourceBitmap.ExtendedBitmapType() != KNullUid)
		{
		iDriver.SetError(KErrNotSupported); // Not supported for extended bitmaps
		return;
		}
	
	DoVgImageDraw (TRect (aDestPos, aSourceRect.Size()), aSourceBitmap, aSourceRect);
	}

/** 
@see MDirectGdiEngine::DrawBitmap()
@see DrawBitmapMasked()
 */
void CVgEngine::DrawBitmap(const TRect& aDestRect, const CFbsBitmap& aSourceBitmap, const TRect& aSourceRect) 
	{
	if (aSourceBitmap.ExtendedBitmapType() != KNullUid)
		{
		iDriver.SetError(KErrNotSupported); // Not supported for extended bitmaps
		return;
		}
	
	DoVgImageDraw (aDestRect, aSourceBitmap, aSourceRect);
	}


/**
Helper method to perform basic VgDrawImage operations, explictly optimised for the case where
the extents of the source image equal the specified source region.

@pre aSource image is a valid VG image handle.
@pre Destination position and/or scaling has already been set in OpenVG. 

@param aDestRect	 	Destination rectangle to draw to.
@param aSourceBitmap	Source bitmap to draw.
@param aSourceRect 		Source rectangle to render. 
*/
void CVgEngine::DoVgImageDraw (const TRect& aDestRect, const CFbsBitmap& aSourceBitmap, const TRect& aSourceRect)
	{
	MakeEngineCurrent();
	TRect destRect(aDestRect);
	TRect srcRect(aSourceRect);
	if (!IntersectsClippingRegion (TRect(iOrigin, destRect.Size()))) 
		return;
	
	VGImage sourceImage = VG_INVALID_HANDLE;
	TBool imageCached = ConvertBitmapToVgImage(aSourceBitmap, sourceImage);
	// Error set on creation of VGImage.
	if (sourceImage == VG_INVALID_HANDLE) return;

	vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
	vgTranslate(destRect.iTl.iX, destRect.iTl.iY);
	
	if (aDestRect.Size() != aSourceRect.Size())
		vgScale((VGfloat)destRect.Width()/aSourceRect.Width(), (VGfloat)destRect.Height()/aSourceRect.Height());
	
	if(aSourceBitmap.SizeInPixels() == aSourceRect.Size())
		{
		for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
			vgDrawImage(sourceImage);
		}
	else
		{
		VGImage sourceImageRegion = 
			vgChildImage(
				sourceImage, 
				srcRect.iTl.iX, 
				srcRect.iTl.iY, 
				srcRect.Width(), 
				srcRect.Height());
		
		if (sourceImageRegion != VG_INVALID_HANDLE)
			{
			for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
				vgDrawImage(sourceImageRegion);

			vgDestroyImage(sourceImageRegion);
			}
		}
		
	if (!imageCached) vgDestroyImage (sourceImage);
	ResetVgMatrix(VG_MATRIX_IMAGE_USER_TO_SURFACE);	// Reset the transform matrix.		
	}

/** 
@see MDirectGdiEngine::BitBltMasked()
@see BitBltMasked(const TPoint&, const CFbsBitmap&, const TRect&, const CFbsBitmap&, TBool)
@see BitBlt()
 */
void CVgEngine::BitBltMasked(
		const TPoint& aDestPos,
		const CFbsBitmap& aBitmap,
		const TRect& aSourceRect,
		const CFbsBitmap& aMask,
		const TPoint& aMaskPt)
	{
	if ((aBitmap.ExtendedBitmapType() != KNullUid) || (aMask.ExtendedBitmapType() != KNullUid))
		{
		iDriver.SetError(KErrNotSupported); // Not supported for extended bitmaps
		return;
		}
	
	DoBitBltMasked(aDestPos, aBitmap, aSourceRect, aMask, EFalse, aMaskPt);
	}

/** 
@see MDirectGdiEngine::BitBlt()
@see BitBltMasked(const TPoint&, const CFbsBitmap&, const TRect&, const CFbsBitmap&, const TPoint&)
@see BitBlt()
 */
void CVgEngine::BitBltMasked( 
		const TPoint& aDestPos,
		const CFbsBitmap& aSourceBitmap,
		const TRect& aSourceRect,
		const CFbsBitmap& aMaskBitmap, 
		TBool aInvertMask)
	{
	if ((aSourceBitmap.ExtendedBitmapType() != KNullUid) || (aMaskBitmap.ExtendedBitmapType() != KNullUid))
		{
		iDriver.SetError(KErrNotSupported); // Not supported for extended bitmaps
		return;
		}
	
	DoBitBltMasked(aDestPos, aSourceBitmap, aSourceRect, aMaskBitmap, aInvertMask, TPoint(0, 0));
	}

/**
Helper method for performing BitBltMasked().
Note that aInvertMask is ignored if aMaskPos is not at 0,0.

@see	CDirectGdiContext::BitBlt(const TPoint& aPoint, const CFbsBitmap& aBitmap, const TRect& aSourceRect);
@see	CDirectGdiContext::BitBltMasked(const TPoint&, const CFbsBitmap&,const TRect&, const CFbsBitmap&, const TPoint&);

@param	aDestPos		The destination for the top left corner of the transferred bitmap. 
						It is relative to the top left corner of the destination bitmap, which may be the screen. 
@param	aSourceBitmap	A memory-resident source bitmap.
@param	aSourceRect		A rectangle defining the piece of the bitmap to be drawn, 
						with co-ordinates relative to the top left corner of the bitmap. 
@param	aMaskBitmap		Mask bitmap.
@param	aInvertMask		If EFalse, a source pixel that is masked by a black pixel is not transferred to 
						the destination rectangle. If ETrue, then a source pixel that is masked by a 
						white pixel is not transferred to the destination rectangle. If alpha blending
						is used instead of masking, this flag is ignored and no inversion takes place.
						Note that this parameter is ignored if aMaskPos does not equal TPoint(0,0).
@param	aMaskPos		The point on the mask bitmap to use as the top left corner 
*/
void CVgEngine::DoBitBltMasked (
		const TPoint& aDestPos,
		const CFbsBitmap& aSourceBitmap,
		const TRect& aSourceRect,
		const CFbsBitmap& aMaskBitmap,
		TBool aInvertMask,
		const TPoint& aMaskPos)
	{
	MakeEngineCurrent();
	ResetVgMatrix(VG_MATRIX_IMAGE_USER_TO_SURFACE);
	if (!IntersectsClippingRegion (TRect (aDestPos+iOrigin, aSourceRect.Size()))) 
		return;
	
	VGImage sourceImage = VG_INVALID_HANDLE;
	TBool imageCached = ConvertBitmapToVgImage(aSourceBitmap, sourceImage);
	if (sourceImage == VG_INVALID_HANDLE)
		{
		// Error set on creation of VGImage.
		return;
		}
	
	VGImage maskImage = VG_INVALID_HANDLE;
	TBool maskImageCached = ConvertBitmapToVgImage(aMaskBitmap, maskImage, ETrue, aMaskPos);
	if (maskImage == VG_INVALID_HANDLE)
		{
		// Error set on creation of VGImage.
		if (!imageCached)
			{
			vgDestroyImage(sourceImage);
			}
		return;
		}

	DoVgMaskedImageDraw(
		aDestPos,
		sourceImage,
		aSourceBitmap.SizeInPixels(),
		aSourceRect,
		maskImage,
		aMaskBitmap.SizeInPixels(),
		aSourceRect.Size(),
		aInvertMask);

	if (!maskImageCached)
		{
		vgDestroyImage(maskImage);
		}
	if (!imageCached)
		{
		vgDestroyImage(sourceImage);
		}
	}


/** 
This implementation stretches the mask first, and then performs mask tiling. Another approach is to
tile first and then perform stretching. The latter method requires more memory and stretches
once. Results between these methods are different. When stretching first, all tiles will be completely
uniform. When stretching last, different tiles are affected differently, based on the tile's position
and stretch factor.

@see MDirectGdiEngine::DrawBitmapMasked()
@see DrawBitmap()
 */
void CVgEngine::DrawBitmapMasked(
	const TRect& aDestRect,
	const CFbsBitmap& aSourceBitmap,
	const TRect& aSourceRect,
	const CFbsBitmap& aMaskBitmap,
	TBool aInvertMask)
	{
	if ((aSourceBitmap.ExtendedBitmapType() != KNullUid) || (aMaskBitmap.ExtendedBitmapType() != KNullUid))
		{
		iDriver.SetError(KErrNotSupported); // Not supported for extended bitmaps
		return;
		}
	
	MakeEngineCurrent();
	TRect destRect(aDestRect);
	if (!IntersectsClippingRegion (TRect(iOrigin, destRect.Size())))
		{
		return;
		}

	// Create source image
	VGImage sourceImage = VG_INVALID_HANDLE;
	TBool imageCached = ConvertBitmapToVgImage(aSourceBitmap, sourceImage);
	// Return if VGImage failed to be created (error set on creation of VGImage).
	if (sourceImage == VG_INVALID_HANDLE)
		{
		return;
		}
		
	// Convert aMask to a VGImage.
	VGImage maskImage = VG_INVALID_HANDLE;
	TBool maskImageCached = ConvertBitmapToVgImage(aMaskBitmap, maskImage, ETrue);
	// Error set on creation of VGImage if mask == VG_INVALID_HANDLE

	if (maskImage != VG_INVALID_HANDLE)
		{
		TSize destSize = destRect.Size();
		TSize sourceSize = aSourceRect.Size();
		if ((destSize.iWidth == sourceSize.iWidth) && (destSize.iHeight == sourceSize.iHeight))
			{
			// No scaling of masked bitmap involved
			DoVgMaskedImageDraw(
					destRect.iTl,
					sourceImage,
					aSourceBitmap.SizeInPixels(),
					aSourceRect,
					maskImage,
					aMaskBitmap.SizeInPixels(),
					destSize,
					aInvertMask);
			}
		else
			{
			// Unfortunately, the current implementation of VG does not support
			// mask scaling. So, we render the mask into a VGImage pbuffer surface,
			// and apply user to surface scaling to get a stretch. The stretched
			// mask is then used for rendering.

			// Generate the VGImage to act as a pbuffer surface and receive the stretched mask.
			const TSize maskSizeInPixels = aMaskBitmap.SizeInPixels();
			const VGImageFormat vgFormat = MapToVgDisplayMode(ClosestVgCompatibleDisplayMode(aMaskBitmap.DisplayMode()));
			TInt scaledMaskWidth = Scale(maskSizeInPixels.iWidth,destSize.iWidth,sourceSize.iWidth);
			TInt scaledMaskHeight = Scale(maskSizeInPixels.iHeight,destSize.iHeight,sourceSize.iHeight);
			VGImage stretchedMask = DoVgCreateImage(vgFormat,
											scaledMaskWidth,
											scaledMaskHeight,
											VG_IMAGE_QUALITY_NONANTIALIASED);
	 
			if (stretchedMask != VG_INVALID_HANDLE)
				{
				// Get a configuration handle that is compatible with the mask pixel format.
				EGLConfig utilConfig = 0;
				TInt err = TConfigHelper::GetConfigForFbsBitmap (aMaskBitmap, utilConfig);
				if (err == KErrNone)
					{
					TBool eglSuccess = EFalse;
					EGLDisplay eglDisplay = iDriver.EglDisplay();
					EGLSurface lastSurface = eglGetCurrentSurface(EGL_DRAW);

					// Create a Pbuffer surface from the stretched mask VGImage.
					EGLSurface utilSurface = eglCreatePbufferFromClientBuffer(
						eglDisplay, 
						EGL_OPENVG_IMAGE,
						static_cast<EGLClientBuffer>(stretchedMask), 
						utilConfig,
						NULL);
					
					if (utilSurface != EGL_NO_SURFACE)
						{
						EGLContext lastContext = eglGetCurrentContext();
						// Create config. compatible context.
						EGLContext utilContext = eglCreateContext(eglDisplay, utilConfig, lastContext, NULL);	
					
						if (utilContext != EGL_NO_CONTEXT)
							{
							// Make the utility surface and context current, and stretch the mask.
							if (eglMakeCurrent(eglDisplay, utilSurface, utilSurface, utilContext) == EGL_TRUE)
								{
								// Set up the scaling transform for the current surface.
								vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
								// Scaling factors for x and y.
								VGfloat xScale = ((VGfloat)destSize.iWidth/sourceSize.iWidth);
								VGfloat yScale = ((VGfloat)destSize.iHeight/sourceSize.iHeight);
								vgScale(xScale, yScale);
								
								// Render the stretched mask.
								vgDrawImage(maskImage);
								ResetVgMatrix(VG_MATRIX_IMAGE_USER_TO_SURFACE);
								
								// All done, make current the pre-existing rendering state.
								eglMakeCurrent(eglDisplay, lastSurface, lastSurface, lastContext);
								
								eglSuccess = ETrue;
								}
							eglDestroyContext(eglDisplay, utilContext);
							}
						eglDestroySurface(eglDisplay, utilSurface);
						}	
					
					if (eglSuccess)
						{
						DoVgMaskedImageDraw(destRect.iTl, sourceImage, aSourceBitmap.SizeInPixels(),
											aSourceRect, stretchedMask,	maskSizeInPixels, destSize,	aInvertMask);
						}
					else
						{						
						// coverity[check_return]
						// coverity[unchecked_value]
						LogEglError();
						}
					}				
				else
					{
					iDriver.SetError(err);
					}
				vgDestroyImage (stretchedMask);
				}
			if (!maskImageCached) vgDestroyImage (maskImage);
			}
		}
	if (!imageCached) vgDestroyImage(sourceImage);
	}

/** 
Helper method that implements the core blitting functionality.

@param	aDestPos	The destination for the top left corner of the transferred bitmap. 
					It is relative to the top left corner of the destination bitmap, which may be the screen. 
@param	aSourceImage A valid VGImage to draw.
@param  aSourceImageSize Extents of source bitmap.
@param	aSourceRect	A rectangle defining the piece of the bitmap to be drawn, 
					with co-ordinates relative to the top left corner of the bitmap. 
@param	aScaledMaskImage A valid mask VGImage - pre-scaled, ready for rendering.
@param	aSrcMaskSize The size of the (unscaled) mask image.
@param	aXscale		Scaling factor to apply to x axis (already applied to mask).
@param	aYscale		Scaling factor to apply to y axis (already applied to mask).
@param	aDestSize	The size of the destination (used for calculating any scaling) 
@param	aInvertMask	If EFalse, a source pixel that is masked by a black pixel 
					is not transferred to the destination rectangle. If ETrue, then a source 
					pixel that is masked by a white pixel is not transferred to the destination 
					rectangle. 

@pre	The rendering target has been activated. aBitmap and aMaskBitmap are not NULL and hold Handles. 
		Destination rectangle extents must intersect clipping region.
		aSourceImage is a valid VGImage handle.
@post	Request to draw the masked bitmap content has been accepted. 
		There is no guarantee that the request has been processed when the method returns.
 */
void CVgEngine::DoVgMaskedImageDraw(
		const TPoint& aDestPos,
		VGImage aSourceImage,
		const TRect& aSourceImageSize,
		const TRect& aSourceRect,
		const VGImage aScaledMaskImage,
		const TSize& aSrcMaskSize,
		const TSize& aDestSize,
		TBool aInvertMask) 
	{
	TBool destroySourceImageAtEnd = EFalse;

	if(aSourceImageSize != aSourceRect)
		{
		aSourceImage = 
			vgChildImage(
				aSourceImage, 
				aSourceRect.iTl.iX, 
				aSourceRect.iTl.iY, 
				aSourceRect.Width(), 
				aSourceRect.Height());

		if (aSourceImage == VG_INVALID_HANDLE) return;
		destroySourceImageAtEnd = ETrue;
		}

	TBool maskOK = EFalse;
	TSize sourceSize = aSourceRect.Size();
	TRect destRect(aDestPos, TSize(Scale(aSourceRect.Width(),aDestSize.iWidth,sourceSize.iWidth),
										Scale(aSourceRect.Height(),aDestSize.iHeight,sourceSize.iHeight)));
	// VG does not provide mask tiling...we currently perform multiple
	// vgMask operations to implement tiling. It should be possible to use
	// pattern tiling to render the mask to a surface, convert surface region
	// to VGImage and apply that as a mask (to take advantage of native VG
	// tiling), though cost/benefit is has not yet been determined.
	// NOTE: It may be worth optimising for cases where xScale or yScale equal one.

	TRect destVgRect = SgMetricsToVgTRect(aDestPos, destRect.Width(), destRect.Height());

	if (aScaledMaskImage != VG_INVALID_HANDLE)
		{
		const TSize scaledMaskSize(Scale(aSrcMaskSize.iWidth,aDestSize.iWidth,sourceSize.iWidth),
										Scale(aSrcMaskSize.iHeight,aDestSize.iHeight,sourceSize.iHeight));
		if (scaledMaskSize.iHeight > 0 && scaledMaskSize.iWidth > 0)
			{
			maskOK = ETrue;
			// Determine mask image offset for rendering.
			TInt scaledMaskXOffset = Scale(aSourceRect.iTl.iX%aSrcMaskSize.iWidth,aDestSize.iWidth,sourceSize.iWidth);

			// Sg coordinates are relative to top left, Vg are reletive to bottom left. As we
			// tile from the bottom up we subtract from maskSize.iHeight to get the bottom edge
			// offset.
			TInt scaledMaskYOffset = (aSourceRect.iTl.iY + aSourceRect.Height()) % aSrcMaskSize.iHeight;
			if (scaledMaskYOffset != 0)
				{
				scaledMaskYOffset = Scale(aSrcMaskSize.iHeight-scaledMaskYOffset,aDestSize.iHeight,sourceSize.iHeight);
				}

			// If inverting the mask, we use a difference operation against the existing mask, so 
			// we need to ensure the existing mask is set to the correct state.
			// Fill the existing mask so that it is completly transparent (set to all ones).
			if(aInvertMask)
				{
				vgMask(
					VG_INVALID_HANDLE, 
					VG_FILL_MASK, 
					destVgRect.iTl.iX, 
					destVgRect.iTl.iY, 
					destVgRect.Width(), 
					destVgRect.Height());			
				}
		
			VGMaskOperation vgMaskOp = aInvertMask ? VG_SUBTRACT_MASK : VG_SET_MASK;
			// NOTE: in VG destVgRect.iTl is physically at the bottom and destVgRect.iBr at the top
			for (
				TInt maskY = destVgRect.iTl.iY - scaledMaskYOffset; 
				maskY < destVgRect.iBr.iY; 
				maskY += scaledMaskSize.iHeight)
				{
				for (
					TInt maskX = destVgRect.iTl.iX - scaledMaskXOffset;
					maskX < destVgRect.iBr.iX;
					maskX += scaledMaskSize.iWidth)
					{
					vgMask(
						aScaledMaskImage, 
						vgMaskOp, 
						maskX,
						maskY, 
						scaledMaskSize.iWidth,
						scaledMaskSize.iHeight);
					}
				}
			}
		}		
	
	// Set up translation and scale for the current surface - note that translation must
	// occur first, as is unscaled.
	vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
	vgTranslate(aDestPos.iX, aDestPos.iY);
	VGfloat xScale = ((VGfloat)aDestSize.iWidth/sourceSize.iWidth);
	VGfloat yScale = ((VGfloat)aDestSize.iHeight/sourceSize.iHeight);
	vgScale(xScale, yScale);
	
	//  Rather than bracketing vgDrawImage with VG_MASKING on/off we may want to always enable masking,
	//  and remove the mask when finished:
	//  vgMask(VG_INVALID_HANDLE, VG_CLEAR_MASK, 0, 0, iRenderingTarget->Size().iWidth, iRenderingTarget->Size().iHeight);
	//  If the mask is not removed in some way, then subsequent rendering operations which intersect with the
	//  masking region will be affected.
	if (maskOK) 
		{
		vgSeti (VG_MASKING, VG_TRUE);
		for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
			vgDrawImage(aSourceImage);
		vgSeti (VG_MASKING, VG_FALSE);
		}
	else
		{
		for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
			vgDrawImage(aSourceImage);
		}
	// Reset the transform matrix.
	ResetVgMatrix(VG_MATRIX_IMAGE_USER_TO_SURFACE);
	
	if (destroySourceImageAtEnd)
		{
		vgDestroyImage (aSourceImage);
		}
	}

/** 
@see MDirectGdiEngine::DrawResource(const TPoint&, const RDirectGdiDrawableSource&, DirectGdi::TGraphicsRotation)
@see DrawResource(const TRect&, const RDirectGdiDrawableSource&, const TRect&, DirectGdi::TGraphicsRotation)
@see DrawResource(const TRect&, const RDirectGdiDrawableSource&, const TDesC8&)
 */
void CVgEngine::DrawResource(const TPoint& aPos, const RDirectGdiDrawableSource& aSource, DirectGdi::TGraphicsRotation aRotation)
	{
	MakeEngineCurrent();
	
	CDirectGdiImageSourceImpl* source = iDriver.GetImageSourceFromHandle(aSource.Handle());
	if (source)
		{			
		const TSize sourceSize = source->Size();				
		
		if ((sourceSize.iWidth > 0) && (sourceSize.iHeight > 0))
			{
			VGImage vgImage = source->VgImage();
			if (vgImage != VG_INVALID_HANDLE)
				{
				vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
				
				TPoint pos(aPos);
				
			
				if (aRotation == DirectGdi::EGraphicsRotationNone ||
					aRotation == DirectGdi::EGraphicsRotation180)
					{
					// Pixel-data in EGLImages appears to be upside down due to the Y-inversion 
					// effect of the Identity matrix.  Therefore must undo the Y-inversion here 
					// and adjust destination rect accordingly.
					pos.iY = iSize.iHeight - aPos.iY - sourceSize.iHeight - iOrigin.iY;
					pos.iX += iOrigin.iX;
					vgLoadIdentity();
					}
				else
					{
					// But if rotation is 90 or 270 degrees we need to mirror in the X-axis
					// and adjust destination translation accordingly.
					vgScale(-1, 1);
					}
							
				switch (aRotation)
					{				
					case DirectGdi::EGraphicsRotation90:
						vgTranslate(-pos.iX, pos.iY);
						vgRotate(90.0f);
						break;
					case DirectGdi::EGraphicsRotation180:
						vgTranslate(pos.iX+sourceSize.iWidth, pos.iY+sourceSize.iHeight);
						vgRotate(180.0f);				
						break;
					case DirectGdi::EGraphicsRotation270:
						vgTranslate(-pos.iX-sourceSize.iHeight, pos.iY+sourceSize.iWidth);
						vgRotate(270.0f);				
						break;
					default:
						// No rotation
						vgTranslate(pos.iX, pos.iY);									
						break;
					}
				
				for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
					vgDrawImage(vgImage);				
				
				ResetVgMatrix(VG_MATRIX_IMAGE_USER_TO_SURFACE);
				}
			}
		}
	}

/** 
@see MDirectGdiEngine::DrawResource(const TRect&, const RDirectGdiDrawableSource&, DirectGdi::TGraphicsRotation)
 */
void CVgEngine::DrawResource(const TRect& aDestRect,
		const RDirectGdiDrawableSource& aSource,
		DirectGdi::TGraphicsRotation aRotation)
	{
	CDirectGdiImageSourceImpl* source = iDriver.GetImageSourceFromHandle(aSource.Handle());
	if (source)
		{		
		TRect srcRect(TPoint(0, 0), source->Size());		
		DoDrawResource(aDestRect, source, srcRect, aRotation);		
		}
	}

/** 
@see MDirectGdiEngine::DrawResource(const TRect&, const RDirectGdiDrawableSource&, const TRect&, DirectGdi::TGraphicsRotation)
 */
void CVgEngine::DrawResource(const TRect& aDestRect,
							const RDirectGdiDrawableSource& aSource,
							const TRect& aSourceRect,
							DirectGdi::TGraphicsRotation aRotation)
	{	
	CDirectGdiImageSourceImpl* source = iDriver.GetImageSourceFromHandle(aSource.Handle());
	if (source)
		{
		// check source rectangle is fully contained within the image resource extent before drawing
		TSize size = source->Size();				
		if ((aSourceRect.iTl.iX < 0) 
			|| (aSourceRect.iTl.iY < 0) 
			|| (aSourceRect.iBr.iX > size.iWidth) 
			|| (aSourceRect.iBr.iY > size.iHeight)
			|| (aSourceRect.Width() <= 0) 
			|| (aSourceRect.Height() <= 0))
			{
			iDriver.SetError(KErrArgument);
			return;
			}
						
		if (((aSourceRect.Width() == aDestRect.Width())
			&& (aSourceRect.Height() == aDestRect.Height())
			&& (aRotation == DirectGdi::EGraphicsRotationNone || aRotation == DirectGdi::EGraphicsRotation180))
			||
			((aSourceRect.Width() == aDestRect.Height())
			&& (aSourceRect.Height() == aDestRect.Width())
			&& (aRotation == DirectGdi::EGraphicsRotation90 || aRotation == DirectGdi::EGraphicsRotation270)))
			{
			// No scaling
			DrawResource(TPoint(aDestRect.iTl.iX, aDestRect.iTl.iY), aSource, aRotation);
			}
		else
			{
			MakeEngineCurrent();			
			DoDrawResource(aDestRect, source, aSourceRect, aRotation);												
			}
		}		
	}

/** 
This method only supports drawing of image sources as Drawables. An attempt to draw
a Drawable that is not an image will result in a panic.

@see MDirectGdiEngine::DrawResource(const TRect&, const RDirectGdiDrawableSource&, const TDesC8&)

@panic DGDIAdapter 1, if an attempt is made to draw a drawable that is not an image source.
 */
void CVgEngine::DrawResource(
			const TRect& aDestRect,
			const RDirectGdiDrawableSource& aSource,
			const TDesC8& /*aParam*/)
	{
	MakeEngineCurrent();
	
	// Check to see if the passed drawable is actually an image as we only support drawing of images at present
	if (iDriver.IsImageSource(aSource.Handle()))
		{
		CDirectGdiImageSourceImpl* source = iDriver.GetImageSourceFromHandle(aSource.Handle());
		if (source)
			{		
			DoDrawResource(aDestRect, source, DirectGdi::EGraphicsRotationNone);
			}
		}
	else
		{
		// This method only supports drawing image sources at present
		GRAPHICS_ASSERT_ALWAYS(0, EDirectGdiPanicNotImplemented);
		}
	}

/**
@see MDirectGdiEngine::BeginDrawGlyph()

Sets the necessary OpenVG and engine state ready for receiving DrawGlyph() commands.
Any OpenVG state that is common for all DrawGlyph() operations are set.
 */
void CVgEngine::BeginDrawGlyph()
	{
	MakeEngineCurrent();	
	vgSetPaint(iTextBrush, VG_FILL_PATH);
	vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
#ifdef DRAWGLYPH_MULTIPLY_MODE
	vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_MULTIPLY);
#else
	vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_STENCIL);
#endif
	
#ifdef DRAWGLYPH_BUFFERED
	iDrawGlyphCount = 0;
#endif
	}

/**
Draws Glyph image to the given position and orientation. 
The function crops the output image to the clipping rectangle specified as a parameter. 
If the clipping region is defined on the current context, it will also be taken into consideration 

@param	aScrPos				Position to start drawing glyph after rotation has been applied (if necessary).
@param	aChar				Character being drawn. Signifies general Unicode character value.
@param	aGlyphImage			Pointer to the glyph image data.
@param	aGlyphBitmapType	Type of bitmap format.
@param	aGlyphImageSize		Glyph image size.
@param	aScrClipRect			Clipping rect.
@param	aRotation			Rotation specifying how the glyph will be drawn. The number can only be divisible by 90 degrees, 
							i.e. horizontal and vertical rotation.

@see  CFont::TTextDirection
@see MDirectGdiEngine::DrawGlyph()

@pre	The rendering target has been activated.
@post	Request to draw the Glyph has been accepted.
@panic  DGDIAdapter 8, if aClipRect is empty (debug-only).
@panic  DGDIAdapter 61, if font glyph image storage does not exist (debug-only).
*/
void CVgEngine::DrawGlyph(
			const TPoint& aScrPos, 
			const TChar aChar, 
			const TUint8* aGlyphImage,
			const TGlyphBitmapType aGlyphBitmapType,
			const TSize& aGlyphImageSize,
			const TRect& aScrClipRect,			
			const DirectGdi::TGraphicsRotation aRotation)
	{
	GRAPHICS_ASSERT_DEBUG(!aScrClipRect.IsEmpty(), EDirectGdiPanicInvalidRegion);
	GRAPHICS_ASSERT_DEBUG(iFontGlyphImageStorage, EDirectGdiPanicGlyphImageStorageNotCreated);
	
	TPoint pos = aScrPos;
	pos += iDrawOrigin;
	TRect clipRect = aScrClipRect;
	clipRect.iTl += iDrawOrigin;
	clipRect.iBr += iDrawOrigin;
	
	if(	aGlyphImageSize.iHeight <= 0 ||	aGlyphImageSize.iWidth <= 0 ||
		!clipRect.Intersects(iTargetRegion.BoundingRect()) || !iRegionManager.Intersects(clipRect))
		{
		// Just leave silently, as spaces could be passed with empty size.
		return;
		}
	
	// Clip the glyph against the target and the clipping rects.
	// Calculate the axis-aligned bounding box of the glyph.
	TRect glyphBoundingBox;
	switch(aRotation)
		{
		case DirectGdi::EGraphicsRotation90:
			glyphBoundingBox = TRect(TPoint(1+pos.iX-aGlyphImageSize.iHeight, pos.iY), TSize(aGlyphImageSize.iHeight, aGlyphImageSize.iWidth));
			break;
		case DirectGdi::EGraphicsRotation180:
			glyphBoundingBox = TRect(TPoint(pos.iX-aGlyphImageSize.iHeight, pos.iY-aGlyphImageSize.iWidth), aGlyphImageSize);
			break;
		case DirectGdi::EGraphicsRotation270:
			glyphBoundingBox = TRect(TPoint(pos.iX, 1+pos.iY-aGlyphImageSize.iWidth), TSize(aGlyphImageSize.iHeight, aGlyphImageSize.iWidth));
			break;
		default:
			glyphBoundingBox = TRect(pos, aGlyphImageSize);
			break;
		}
	if (!glyphBoundingBox.Intersects(iTargetRegion.BoundingRect()) || !iRegionManager.Intersects(glyphBoundingBox))
		{
		return;
		}
#ifdef DRAWGLYPH_BUFFERED
	iDrawGlyphCommand[iDrawGlyphCount].pos = pos;
	iDrawGlyphCommand[iDrawGlyphCount].aChar = aChar;
	iDrawGlyphCommand[iDrawGlyphCount].aGlyphBitmapType = aGlyphBitmapType;
	iDrawGlyphCommand[iDrawGlyphCount].aGlyphImageSize = aGlyphImageSize;
	iDrawGlyphCommand[iDrawGlyphCount].aClipRect = clipRect;
	iDrawGlyphCommand[iDrawGlyphCount].aRotation = aRotation;
	iDrawGlyphCommand[iDrawGlyphCount].aGlyphImage = const_cast<TUint8*>(aGlyphImage);	
	++iDrawGlyphCount;	
	if (iDrawGlyphCount == KMaxGlyphs)
		{
		FlushDrawGlyphs();
		iDrawGlyphCount = 0;
		}
#else	
	VGImage foreground = VG_INVALID_HANDLE;
	VGImage outline = VG_INVALID_HANDLE;
	VGImage shadow = VG_INVALID_HANDLE;

	TInt err = iFontGlyphImageStorage -> GlyphImage(iFontId, aChar, aGlyphBitmapType, aGlyphImage, aGlyphImageSize, &foreground, &shadow, &outline);
	if(err != KErrNone)
		{
		iDriver.SetError(err);
		if(err == KErrNoMemory)
			{
			if((foreground == VG_INVALID_HANDLE) || 
				((aGlyphBitmapType == EFourColourBlendGlyphBitmap) && ((shadow == VG_INVALID_HANDLE) || (outline == VG_INVALID_HANDLE))))
				{
				return;
				}
			}
		else
			{
			return;
			}
		}
	
	RRegion oldClippingRegion;
	oldClippingRegion.Copy(iRegionManager.ClippingRegion());
	iRegionManager.ClipTo(clipRect);
	
	//  Load the matrix which converts Symbian coordinate system to OpenVG coordinate system
	vgLoadMatrix(Identity());
	if(aRotation == DirectGdi::EGraphicsRotation90)
		{
		vgTranslate(pos.iX+1, pos.iY);
		vgRotate(90.0f);
		}
	else if(aRotation == DirectGdi::EGraphicsRotation270)
		{
		vgTranslate(pos.iX, pos.iY+1);
		vgRotate(270.0f);
		}
	else
		{
		vgTranslate(pos.iX, pos.iY);
		}		

	switch(aGlyphBitmapType)
		{
		case EMonochromeGlyphBitmap:
		case EAntiAliasedGlyphBitmap:
			for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
				vgDrawImage(foreground);
			break;
		case EFourColourBlendGlyphBitmap:
			{
			SetVgPaintColor(iTextBrush, iBrushColor);
			for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
				vgDrawImage(foreground);
	
			SetVgPaintColor(iTextBrush, iTextShadowColor);
			for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
				vgDrawImage(shadow);
	
			SetVgPaintColor(iTextBrush, iPenColor);
			for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
				vgDrawImage(outline);
			break;
			}
		}

	// Restore the clipping manager to its previous state.
	iRegionManager.SetClippingRegion(oldClippingRegion);
	oldClippingRegion.Close();
#endif
	}

/**
@see MDirectGdiEngine::EndDrawGlyph()

Undoes any OpenVG or engine state changes made in BeginDrawGlyph().
 */
void CVgEngine::EndDrawGlyph()
	{
#ifdef DRAWGLYPH_BUFFERED
	FlushDrawGlyphs();
	iDrawGlyphCount = 0;
#endif
	vgLoadMatrix(Identity());
	if (iOrigin != TPoint(0,0))
		{
		vgTranslate(iOrigin.iX, iOrigin.iY);
		}
		
	vgSetPaint(iBrush, VG_FILL_PATH);
	vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_NORMAL);
	}

#ifdef DRAWGLYPH_BUFFERED
void CVgEngine::FlushDrawGlyphs()
	{
	VGImage foreground[KMaxGlyphs];
	Mem::FillZ(foreground, iDrawGlyphCount*sizeof(VGImage));
	VGImage outline[KMaxGlyphs];
	VGImage shadow[KMaxGlyphs];
	
	for (TInt glyph = 0; glyph < iDrawGlyphCount; ++glyph)
		{
		if (foreground[glyph] == 0)
			{			
			TSize aGlyphImageSize = iDrawGlyphCommand[glyph].aGlyphImageSize;
			TChar aChar = iDrawGlyphCommand[glyph].aChar;
			TGlyphBitmapType aGlyphBitmapType = iDrawGlyphCommand[glyph].aGlyphBitmapType;
			TUint8* aGlyphImage = iDrawGlyphCommand[glyph].aGlyphImage;
		
			VGImage foreground1 = VG_INVALID_HANDLE;
			VGImage outline1 = VG_INVALID_HANDLE;
			VGImage shadow1 = VG_INVALID_HANDLE;
		
			TInt err = iFontGlyphImageStorage -> GlyphImage(iFontId, aChar, aGlyphBitmapType, aGlyphImage, aGlyphImageSize, &foreground1, &shadow1, &outline1);
			if(err != KErrNone)
				{
				iDriver.SetError(err);
				if(err == KErrNoMemory)
					{
					if((foreground1 == VG_INVALID_HANDLE) || 
						((aGlyphBitmapType == EFourColourBlendGlyphBitmap) && ((shadow1 == VG_INVALID_HANDLE) || (outline1 == VG_INVALID_HANDLE))))
						{
						return;
						}
					}
				else
					{
					return;
					}
				}
			
			foreground[glyph] = foreground1;
			outline[glyph] = outline1;
			shadow[glyph] = shadow1;
			
			for (TInt nextGlyph = glyph+1; nextGlyph < iDrawGlyphCount; nextGlyph++)
				{
				if (foreground[nextGlyph] == 0)
					{
					if (iDrawGlyphCommand[glyph].SameGlyph(iDrawGlyphCommand[nextGlyph]))
						{
						foreground[nextGlyph] = foreground[glyph];
						outline[nextGlyph] = outline[glyph];
						shadow[nextGlyph] = shadow[glyph];
						}
					}
				}
			}
		}
		
	RRegion oldClippingRegion;
	oldClippingRegion.Copy(iRegionManager.ClippingRegion());
	vgLoadMatrix(Identity());
	TPoint lastPos;
	for (TInt glyph = 0; glyph < iDrawGlyphCount; ++glyph)
		{
		TGlyphBitmapType aGlyphBitmapType = iDrawGlyphCommand[glyph].aGlyphBitmapType;
		TRect aClipRect = iDrawGlyphCommand[glyph].aClipRect;
		DirectGdi::TGraphicsRotation aRotation = iDrawGlyphCommand[glyph].aRotation;
		TPoint aPos = iDrawGlyphCommand[glyph].pos;
		
		iRegionManager.ClipTo(aClipRect);
		
		//  Load the matrix which converts Symbian coordinate system to OpenVG coordinate system
		
		if(aRotation == DirectGdi::EGraphicsRotation90)
			{
			vgTranslate(aPos.iX+1, aPos.iY);
			vgRotate(90.0f);
			}
		else if(aRotation == DirectGdi::EGraphicsRotation270)
			{
			vgTranslate(aPos.iX, aPos.iY+1);
			vgRotate(270.0f);
			}
		else
			{
			//vgTranslate(aPos.iX, aPos.iY);
			vgTranslate(aPos.iX-lastPos.iX, aPos.iY - lastPos.iY);
			lastPos = aPos;
			}		
	
		switch(aGlyphBitmapType)
			{
			case EMonochromeGlyphBitmap:
			case EAntiAliasedGlyphBitmap:
				for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
					vgDrawImage(foreground[glyph]);
				break;
			case EFourColourBlendGlyphBitmap:
				{
				SetVgPaintColor(iTextBrush, iBrushColor);
				for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
					vgDrawImage(foreground[glyph]);
		
				SetVgPaintColor(iTextBrush, iTextShadowColor);
				for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
					vgDrawImage(shadow[glyph]);
		
				SetVgPaintColor(iTextBrush, iPenColor);
				for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
					vgDrawImage(outline[glyph]);
				break;
				}
			}
		
		// Restore the clipping manager to its previous state.
		iRegionManager.SetClippingRegion(oldClippingRegion);
		}
	oldClippingRegion.Close();
	}
#endif

/**
@see MDirectGdiEngine::CopyRect()
 */
void CVgEngine::CopyRect(const TPoint& aOffset, const TRect& aRect)
	{
	MakeEngineCurrent();

	// Transformations, masking and blending are not applied.
	// So need to convert to VG coordinate system.
	// i.e. Need Bottom-Left coord of aRect in VG's coordinates.
	// Also need to allow for drawing engine coordinate system (iOrigin)
	const TPoint sourcePoint = ConvertToVgCoords(TPoint(aRect.iTl.iX, aRect.iBr.iY) + iOrigin);
	// Scissoring is applied to destination, but does not affect reading of pixels.
	for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
		vgCopyPixels(sourcePoint.iX + aOffset.iX, sourcePoint.iY - aOffset.iY,	// destination point
						sourcePoint.iX, sourcePoint.iY,							// source point
						aRect.Width(), aRect.Height());							// size of rect to copy
	}

/**
@see MDirectGdiEngine::ExternalizeL()
@see InternalizeL()
 */
void CVgEngine::ExternalizeL(RWriteStream& aWriteStream) 
	{
	aWriteStream.WriteUint32L(iPaintMode);
	aWriteStream << iLinePos;
	}

/**
@see MDirectGdiEngine::InternalizeL()
@see ExternalizeL()
 */
void CVgEngine::InternalizeL(RReadStream& aReadStream)
	{
	iPaintMode = aReadStream.ReadUint32L();
	aReadStream >> iLinePos;
	}

/**
@see MDirectGdiEngine::GetInterface()
 */
TInt CVgEngine::GetInterface(TUid aInterfaceId, TAny*& aInterface)
	{
	aInterface = NULL;
	TInt err = KErrNone;
	switch (aInterfaceId.iUid)
		{
		case KDirectGdiGetGlyphStorageUid:
			{
			aInterface = static_cast<MFontGlyphImageStorage*> (iDriver.FontGlyphImageStorage());
			break;	
			}
		case KDirectGdiVgImageCacheUid:
			{
			aInterface =  static_cast<MVgImageCache*> (iDriver.VgImageCache());
			break;
			}
		case KDrawDeviceOriginInterfaceID:
			{
			aInterface = static_cast<MDrawDeviceOrigin*>(this);
			break;
			}
		default:
			err = KErrNotSupported;
			break;
		}
	return err;
	}

/**
Converts a point from the Symbian OS graphics coordinate system to the OpenVG coordinate system.

The Symbian OS coordinate system's x-axis increases positively from the origin rightwards.
The y-axis increases positively from the origin downwards.

The OpenVG coordinate system's x-axis increases positively from the origin rightwards.
The y-axis increases positively from the origin upwards.

Therefore a point (X,Y) in the Symbian OS coordinate system would be equivalent to a point
(X',Y') in the OpenVG coordinate system by the following transformations:
X' = X
Y' = (Height of rendering target) - Y

@param	aPoint A point specified in the Symbian OS graphics coordinate system.

@return The point specified in the OpenVG-specific coordinate system.
 */
const TPoint CVgEngine::ConvertToVgCoords(const TPoint& aPoint)
	{
	MakeEngineCurrent();
	TInt targetHeight = iSize.iHeight;
	return TPoint(aPoint.iX, targetHeight - aPoint.iY);
	}

/**
Converts the position of a rectangle from the Symbian OS graphics coordinate system to the 
OpenVG coordinate system.

The Symbian OS coordinate system's x-axis increases positively from the origin rightwards.
The y-axis increases positively from the origin downwards.
A rectangle's position is specified by the top-left coordinate.

The OpenVG coordinate system's x-axis increases positively from the origin rightwards.
The y-axis increases positively from the origin upwards.
A rectangle's position is specified by the bottom-left coordinate.

A point (X,Y) in the Symbian OS coordinate system would be equivalent to point
(X',Y') in the OpenVG coordinate system by the following transformations:
X' = X
Y' = (Height of rendering target) - Y

@param	aRect	A rectangle whose position is to be converted for use in OpenVG.

@return The bottom-left point of the rectangle, specified in the OpenVG specific coordinate system.
 */
const TPoint CVgEngine::ConvertToVgCoords(const TRect& aRect)
	{
	MakeEngineCurrent();
	TInt targetHeight = iSize.iHeight;
	return TPoint(aRect.iTl.iX, targetHeight - aRect.iBr.iY);
	}

/**
Resets the user-to-surface OpenVG matrices to the default system matrix.
 */
void CVgEngine::ResetVgMatrix()
	{
	ResetVgMatrix(VG_MATRIX_PATH_USER_TO_SURFACE);
	ResetVgMatrix(VG_MATRIX_IMAGE_USER_TO_SURFACE);
	}

/**
Resets an OpenVG matrix to the default system matrix. Current origin offset applies.
@param aMatrixMode The OpenVG matrix being reset.
 */
void CVgEngine::ResetVgMatrix(const VGMatrixMode aMatrixMode)
	{
	vgSeti(VG_MATRIX_MODE, aMatrixMode);
	//  Load matrix which converts Symbian coordinate system to VG coordinate system
	vgLoadMatrix(Identity());
		
	// Add in translation for drawing engine coordinate system
	vgTranslate(iOrigin.iX, iOrigin.iY);
	}

/**
If aPath is a null handle, a VGPath is created with enough space to hold aExpectedCommandCount commands.
If the path is already a handle to a valid path, the path is simply cleared instead of recreated.
Also allocates memory for two arrays; one to hold all commands we will add to the newly
created path, and one to hold all coordinates we will add to the newly created path.
Commands and coordinates are not added to the path until FinishPath() is called for this path. 
Commands and coordinates are saved for adding to the path when FinishPath() is
called by calling AppendPathCommand(). Any failures are reported to the driver before returning.

@param  aPath A handle to the path being cleared/created.
@param	aExpectedCommandCount The number of commands the path is expected to hold. If this size
		is underestimated, the arrays that hold the current commands and coordinates will grow
		as additional items are added beyond the original estimated size. Once a path is finished, the current
		command and coordinate counters are reset, but the memory remains to cut down on memory allocations.
		
@return EFalse if memory allocation or path creation fails, ETrue otherwise.

@see CVgEngine::AppendPathCommand(VGubyte)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat, VGfloat)
@see CVgEngine::PrepareForPathCommand()
@see CVgEngine::FinishPath()
@see CVgEngine::AllocPathCommands()
@see CVgEngine::AllocPathCoords()
 */
TBool CVgEngine::PreparePath(VGPath& aPath, TInt aExpectedCommandCount)
	{	
	TInt err = KErrNone;
	err = AllocPathCommands(aExpectedCommandCount);		
	if(KErrNone == err)
		{
		err = AllocPathCoords(aExpectedCommandCount*2);	// guess at the number of coords needed, this will be reallocated if it is not big enough
		}
	if(KErrNone == err)
		{
		if (aPath != VG_INVALID_HANDLE)
			vgClearPath(aPath, VG_PATH_CAPABILITY_APPEND_TO);
		else
			{
			aPath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
							VG_PATH_DATATYPE_F,
							1.0f, //scale
							0.0f, //bias
							aExpectedCommandCount,
							aExpectedCommandCount*2, //expected coord count
							VG_PATH_CAPABILITY_APPEND_TO);
			
			if (aPath == VG_INVALID_HANDLE)
				err = KErrNoMemory;
			}
		}
	if (KErrNone != err)
		{
		iDriver.SetError(err);
		return EFalse;
		}
	return ETrue;
	}

/**
Adds a path command to the currently saved array of path commands. Any error that occurs is stored
with the driver.

@param aCommand	The VGPathCommand to add to the current path, e.g VG_CLOSE_PATH.

@see CVgEngine::CreatePath()
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat, VGfloat)
@see CVgEngine::PrepareForPathCommand()
@see CVgEngine::FinishPath()
@see CVgEngine::AllocPathCommands()
@see CVgEngine::AllocPathCoords()
 */
void CVgEngine::AppendPathCommand(VGubyte aCommand)
	{
	TInt err = PrepareForPathCommand(1, 0);
	if (KErrNone == err)
		{
		iPathCommands[iPathCommandCount++] = aCommand;
		}
	else
		{
		iDriver.SetError(err);
		}	
	}

/**
Adds a path command and a single coordinate to the currently saved array of path commands.
Any error that occurs is stored with the driver.  

@param	aCommand The VGPathCommand to add to the current path, e.g VG_HLINE_TO_ABS.
@param	aCoord	 The coordinate to add to the current path, e.g. 10.f.

@see CVgEngine::CreatePath()
@see CVgEngine::AppendPathCommand(VGubyte)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat, VGfloat)
@see CVgEngine::PrepareForPathCommand()
@see CVgEngine::FinishPath()
@see CVgEngine::AllocPathCommands()
@see CVgEngine::AllocPathCoords()
 */
void CVgEngine::AppendPathCommand(VGubyte aCommand, VGfloat aCoord)
	{
	TInt err = PrepareForPathCommand(1, 1);
	if (KErrNone == err)
		{				
		iPathCommands[iPathCommandCount++] = aCommand;			
		iPathCoords[iPathCoordCount++] = aCoord;		
		}
	else
		{
		iDriver.SetError(err);
		}	
	}

/**
Adds a path command and two coordinates to the currently saved array of path commands. 
Any error that occurs is stored with the driver.

@param	aCommand	The VGPathCommand to add to the current path, e.g VG_MOVE_TO_ABS.
@param	aCoord1		The coordinate to add to the current path, e.g. 10.f.
@param	aCoord2		The coordinate to add to the current path, e.g. 10.f.

@see CVgEngine::CreatePath()
@see CVgEngine::AppendPathCommand(VGubyte)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat)
@see CVgEngine::PrepareForPathCommand()
@see CVgEngine::FinishPath()
@see CVgEngine::AllocPathCommands()
@see CVgEngine::AllocPathCoords()
 */
void CVgEngine::AppendPathCommand(VGubyte aCommand, VGfloat aCoord1, VGfloat aCoord2)
	{
	TInt err = PrepareForPathCommand(1, 2);
	if (KErrNone == err)
		{			
		iPathCommands[iPathCommandCount++] = aCommand;					
		iPathCoords[iPathCoordCount++] = aCoord1;
		iPathCoords[iPathCoordCount++] = aCoord2;		
		}
	else
		{
		iDriver.SetError(err);
		}	
	}

/**
Allocates memory to store the passed number of commands and coordinates in the saved command and 
coordinate arrays. Any error that occurs is stored with the driver.

@param	aCommandCount	The number of new commands expected to be added to the current command array.
@param	aCoordCount		The number of new commands expected to be added to the current coordinate array.

@return	KErrNoMemory if memory allocation fails, KErrNone otherwise.

@see CVgEngine::CreatePath()
@see CVgEngine::AppendPathCommand(VGubyte)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat, VGfloat)
@see CVgEngine::FinishPath()
@see CVgEngine::AllocPathCommands()
@see CVgEngine::AllocPathCoords()
 */
TInt CVgEngine::PrepareForPathCommand(TInt aCommandCount, TInt aCoordCount)
	{
	// Do we need to add space for the new commands and coords?
	TInt err = AllocPathCommands(iPathCommandCount+aCommandCount);
	if (err == KErrNone)
		{
		err = AllocPathCoords(iPathCoordCount+aCoordCount);
		}
	if (err != KErrNone)
		{
		iDriver.SetError(err);
		}
	return err;
	}

/**
Adds the contents of the saved command and coordinate arrays to the passed VGPath ready for drawing.
Clears the counts of saved commands and coordinates.

@param	aPath	The path that the current commands and coordinates are to be added to. 

@see CVgEngine::CreatePath()
@see CVgEngine::AppendPathCommand(VGubyte)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat, VGfloat)
@see CVgEngine::PrepareForPathCommand()
@see CVgEngine::AllocPathCommands()
@see CVgEngine::AllocPathCoords()
 */
void CVgEngine::FinishPath(VGPath aPath)
	{
	vgAppendPathData(aPath, iPathCommandCount, iPathCommands, iPathCoords);
	iPathCommandCount = 0;
	iPathCoordCount = 0;
	}

/**
Allocates enough memory to hold aCommandCount path commands, unless the command array already holds
enough memory.

@param	aCommandCount The number of commands to allocate space for in the command array.

@return	KErrNoMemory if memory allocation fails, KErrNone otherwise.

@see CVgEngine::CreatePath(TInt)
@see CVgEngine::AppendPathCommand(VGubyte)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat, VGfloat)
@see CVgEngine::PrepareForPathCommand(TInt, TInt)
@see CVgEngine::FinishPath(VGPath)
@see CVgEngine::AllocPathCoords(TInt)
 */
TInt CVgEngine::AllocPathCommands(TInt aCommandCount)
	{
	TInt err = KErrNone;
	if (iCurrentMaxCommands < aCommandCount)
		{
		VGubyte* oldPathCommands = iPathCommands;
		iPathCommands = static_cast<VGubyte*>(User::ReAlloc(iPathCommands, sizeof(VGubyte)*aCommandCount));					
		if (iPathCommands)
			{
			iCurrentMaxCommands = aCommandCount;	
			}	
		else
			{
			delete oldPathCommands;
			iCurrentMaxCommands = 0;
			}
		}
	if(!iPathCommands)
		err = KErrNoMemory;
	return err;	
	}

/**
Allocates enough memory to hold aCoordCount path coordinates, unless the coordinate array already holds
enough memory.

@param	aCoordCount	The number of coordinates to allocate space for in the coordinate array.

@return	KErrNoMemory if memory allocation fails, KErrNone otherwise.

@see CVgEngine::CreatePath()
@see CVgEngine::AppendPathCommand(VGubyte)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat)
@see CVgEngine::AppendPathCommand(VGubyte, VGfloat, VGfloat)
@see CVgEngine::PrepareForPathCommand()
@see CVgEngine::FinishPath()
@see CVgEngine::AllocPathCommands()
 */
TInt CVgEngine::AllocPathCoords(TInt aCoordCount)
	{
	TInt err = KErrNone;
	if (iCurrentMaxCoords < aCoordCount)
		{
		VGfloat* oldPathCoords = iPathCoords;
		iPathCoords = static_cast<VGfloat*>(User::ReAlloc(iPathCoords, sizeof(VGfloat)*aCoordCount));			
		if (iPathCoords)
			{
			iCurrentMaxCoords = aCoordCount;	
			}	
		else
			{
			delete oldPathCoords;
			iCurrentMaxCoords = 0;
			}
		}
	if(!iPathCoords)
		err = KErrNoMemory;
	return err;	
	}

/**
Helper method for creating a VGImage from a CFbsBitmap. A temporary VGImageFormat-compatible 
copy of the image may be created, if the source bitmap pixel format is not directly supported 
by OpenVG. If there is not enough memory available, the error state on the driver is set to KErrNoMemory.
It sets the error in the driver if out-of-memory occurs when creating a VGImage. OpenVG will set its 
own internal error if creation of VGImage fails.

@param	aSource	The source bitmap.
@param  aFlipY If 'ETrue' then inverts the image in the y axis.
@param  aOrigin An offset from the top-left of the image in which to take the first pixel of the image.

@return	Returns a valid VGImage created using the passed CFbsBitmap. If unable to
		create a valid VGImage then VG_INVALID_HANDLE.
*/
VGImage CVgEngine::CreateSourceVGImage(const CFbsBitmap& aSource, TBool aFlipY, const TPoint& aOrigin)
	{		
	TDisplayMode srcDisplayMode = aSource.DisplayMode();
	TDisplayMode vgCompatibleDisplayMode = ClosestVgCompatibleDisplayMode(srcDisplayMode);
	VGImageFormat imageFormat = MapToVgDisplayMode(vgCompatibleDisplayMode);
	const TSize sourceSize = aSource.SizeInPixels();
	VGImage image = DoVgCreateImage(imageFormat, sourceSize.iWidth, sourceSize.iHeight, VG_IMAGE_QUALITY_NONANTIALIASED);
	if (image != VG_INVALID_HANDLE)
		{
		const TInt pixmapStride = CFbsBitmap::ScanLineLength(sourceSize.iWidth, vgCompatibleDisplayMode);	
		
		// Conversion is performed if changing display mode (pixel format), source is compressed, or want to flip the y orientation.
		if ((vgCompatibleDisplayMode != srcDisplayMode) || (aSource.Header().iCompression != ENoBitmapCompression) || aFlipY)
			{
			// May be worth using a static memory buffer for smaller scan-lines, to avoid overhead of alloc.
			TAny* data = User::Alloc(pixmapStride);
			if (data)
				{
				// Allocate memory and transform source into target format.
				TPoint sourcePoint (0, aFlipY ? (sourceSize.iHeight - 1) : 0);
				TPtr8 targetPoint ((TUint8*)data, pixmapStride, pixmapStride);
				TInt adj = aFlipY ? -1 : 1;
	
				if (aOrigin == TPoint(0,0)) // Not shifted
					{
					for (TInt targetY = 0; targetY < sourceSize.iHeight; targetY++, sourcePoint.iY += adj)
						{
						aSource.GetScanLine(targetPoint, sourcePoint, sourceSize.iWidth, vgCompatibleDisplayMode);
						vgImageSubData(image, data, pixmapStride, imageFormat, 0, targetY, sourceSize.iWidth, 1);
						}
					}
				else if (aOrigin.iX == 0) // Only shifted in Y.
					{
					for (TInt targetY = 0x00; targetY < sourceSize.iHeight; targetY++, sourcePoint.iY += adj)
						{
						aSource.GetScanLine(targetPoint, sourcePoint, sourceSize.iWidth, vgCompatibleDisplayMode);
						vgImageSubData(image, data, pixmapStride, imageFormat, 0, targetY + aOrigin.iY,                      sourceSize.iWidth, 1);
						vgImageSubData(image, data, pixmapStride, imageFormat, 0, targetY + aOrigin.iY - sourceSize.iHeight, sourceSize.iWidth, 1);
						}
					}
				else if (aOrigin.iY == 0) // Only shifted in X.
					{
					for (TInt targetY = 0x00; targetY < sourceSize.iHeight; targetY++, sourcePoint.iY += adj)
						{
						aSource.GetScanLine(targetPoint, sourcePoint, sourceSize.iWidth, vgCompatibleDisplayMode);
						vgImageSubData(image, data, pixmapStride, imageFormat, -aOrigin.iX,                     targetY, sourceSize.iWidth, 1);
						vgImageSubData(image, data, pixmapStride, imageFormat, -aOrigin.iX + sourceSize.iWidth, targetY, sourceSize.iWidth, 1);
						}				
					}
				else						  // Shifted in both X and Y.
					{
					for (TInt targetY = 0; targetY < sourceSize.iHeight; targetY++, sourcePoint.iY += adj)
						{
						aSource.GetScanLine(targetPoint, sourcePoint, sourceSize.iWidth, vgCompatibleDisplayMode);
						vgImageSubData(image, data, pixmapStride, imageFormat, -aOrigin.iX, 					targetY + aOrigin.iY, 						sourceSize.iWidth, 1);
						vgImageSubData(image, data, pixmapStride, imageFormat, -aOrigin.iX, 					targetY + aOrigin.iY - sourceSize.iHeight, sourceSize.iWidth, 1);
						vgImageSubData(image, data, pixmapStride, imageFormat, -aOrigin.iX + sourceSize.iWidth, targetY + aOrigin.iY, 						sourceSize.iWidth, 1);
						vgImageSubData(image, data, pixmapStride, imageFormat, -aOrigin.iX + sourceSize.iWidth, targetY + aOrigin.iY - sourceSize.iHeight, sourceSize.iWidth, 1);
						}
					}
				User::Free(data);
				}
			else
				{
				iDriver.SetError(KErrNoMemory);
				vgDestroyImage(image);
				return VG_INVALID_HANDLE;
				}
			}
		else
			{
			aSource.BeginDataAccess();
			const TInt sourceDataStride = aSource.DataStride();
			if (aOrigin == TPoint(0,0))			// Not shifted
				{
				vgImageSubData(image, aSource.DataAddress(), sourceDataStride, imageFormat, 0, 0, sourceSize.iWidth, sourceSize.iHeight);			
				}
			else
				{
				TUint32* dataAddress = aSource.DataAddress();
				
				if (aOrigin.iX == 0) 		// Only shifted in Y.
					{
					vgImageSubData(image, dataAddress, sourceDataStride, imageFormat, 0, aOrigin.iY,                      sourceSize.iWidth, sourceSize.iHeight);						
					vgImageSubData(image, dataAddress, sourceDataStride, imageFormat, 0, aOrigin.iY - sourceSize.iHeight, sourceSize.iWidth, sourceSize.iHeight);						
					}
				else if (aOrigin.iY == 0) 	// Only shifted in X.
					{
					vgImageSubData(image, dataAddress, sourceDataStride, imageFormat, -aOrigin.iX,                     0, sourceSize.iWidth, sourceSize.iHeight);						
					vgImageSubData(image, dataAddress, sourceDataStride, imageFormat, -aOrigin.iX + sourceSize.iWidth, 0, sourceSize.iWidth, sourceSize.iHeight);						
					}
				else							// Shifted in both X and Y.
					{
					vgImageSubData(image, dataAddress, sourceDataStride, imageFormat, -aOrigin.iX, aOrigin.iY,                      sourceSize.iWidth, sourceSize.iHeight);						
					vgImageSubData(image, dataAddress, sourceDataStride, imageFormat, -aOrigin.iX, aOrigin.iY - sourceSize.iHeight, sourceSize.iWidth, sourceSize.iHeight);							
					vgImageSubData(image, dataAddress, sourceDataStride, imageFormat, -aOrigin.iX + sourceSize.iWidth, aOrigin.iY,                      sourceSize.iWidth, sourceSize.iHeight);						
					vgImageSubData(image, dataAddress, sourceDataStride, imageFormat, -aOrigin.iX + sourceSize.iWidth, aOrigin.iY - sourceSize.iHeight, sourceSize.iWidth, sourceSize.iHeight);							
					}
				}
			aSource.EndDataAccess(ETrue);
			}
		}
	return image;
	}

/**
Creates an image which represents a standard brush pattern (e.g. EVerticalHatchBrush), by
drawing the pattern using the current pen and brush colour to an image.

@param	aPatternSize	The dimensions in pixels of the image to create.
@param	aBrushPattern	An array of 1s and 0s representing the pattern to create, the length
						of this array is aSize.iWidth*aSize.iHeight.	

@return	KErrNone if the brush is created successfully, KErrNoMemory if we fail to create 
		the brush image, KErrArgument if aBrushPattern is invalid.
 */
TInt CVgEngine::CreateStandardBrush(TSize& aPatternSize, VGbyte* aBrushPattern)
	{		
	if (aBrushPattern == NULL)
		return KErrArgument;
	
	TInt err = KErrNone;	
	MakeEngineCurrent();
	
	// The image format to use as the standard brush. If this changes, it also needs changing in 
	// GetCurrentBrush().	
	const VGImageFormat dataFormat = VG_sARGB_8888;
	
	// We want to create the brush to the nearest power of 4 size.
	TSize brushSize((aPatternSize.iWidth+3)&~3, (aPatternSize.iHeight+3)&~3);		
	
	// Allocate some memory to write the brush pattern to.
	TUint32* data = new TUint32[brushSize.iWidth*brushSize.iHeight];
	if (data == NULL)
		err = KErrNoMemory;		
	
	if (err == KErrNone)
		{
		if (iBrushPatternStandardRegion != VG_INVALID_HANDLE)
			{
			vgDestroyImage(iBrushPatternStandardRegion);
			iBrushPatternStandardRegion = VG_INVALID_HANDLE;
			}
		
		// Check the size of the existing standard brush as it can't be re-used if the
		// new brush to be created is a different size.
		if (iBrushPatternStandard != VG_INVALID_HANDLE)
			{
			if (iBrushPatternStandardSize != brushSize)
				{
				vgDestroyImage(iBrushPatternStandard);
				iBrushPatternStandard = VG_INVALID_HANDLE;
				}
			}					
		
		if (iBrushPatternStandard == VG_INVALID_HANDLE)
			{
			// Create an image to draw the brush pattern onto, this will be our offscreen buffer
			iBrushPatternStandardSize = brushSize;
			iBrushPatternStandard = DoVgCreateImage(dataFormat, brushSize.iWidth, brushSize.iHeight, VG_IMAGE_QUALITY_NONANTIALIASED);
			if (iBrushPatternStandard == VG_INVALID_HANDLE)
				err = KErrNoMemory;
			}
		}			

	if (err == KErrNone)
		{
		// Set the colour used for the pen. If not fully opaque and not in WriteAlpha mode,
		// blend the pen colour with the brush colour.
		TRgb penColor = iPenColor;
		if ((iPenColor.Alpha() != 255) && (iDrawMode != DirectGdi::EDrawModeWriteAlpha))
			{
			penColor.SetInternal(
				PMA2NonPMAPixel(
					PMAPixelBlend(
					    NonPMA2PMAPixel(iBrushColor.Internal()), 
						NonPMA2PMAPixel(iPenColor.Internal()))));
			}
		
		// Draw the pattern on to the brush, pixel by pixel.
		for (TInt j = 0; j < aPatternSize.iHeight; ++j)
			{
			for (TInt i = 0; i < aPatternSize.iWidth; ++i)
				{				
				if (aBrushPattern[(j*aPatternSize.iWidth)+i])			
					{					
					data[(j*brushSize.iWidth)+i] = penColor._Color16MA(); 
					}
				else
					{
					data[(j*brushSize.iWidth)+i] = iBrushColor._Color16MA();
					}
				}
			}					
				
		// Copy the pattern to the VGImage so we can set it as the current brush
		vgImageSubData(iBrushPatternStandard,	// the image to copy to		
					data, 						// the source data
					brushSize.iWidth*4,	 		// the stride of the source data
					dataFormat, 				// the format of the source data
					0, 							// x
					0, 							// y
					brushSize.iWidth, 			// width
					brushSize.iHeight);			// height
		iBrushPatternStandardSize = brushSize;
		
		// We only want to use the region of the brush we just created that is the size of the pattern
		iBrushPatternStandardRegion = vgChildImage(iBrushPatternStandard, 
													0, 
													0, 
													aPatternSize.iWidth, 
													aPatternSize.iHeight);
		iBrushPatternStandardRegionSize = aPatternSize;
		}		
	
	// Clean up
	delete [] data;

	return err;
	}

/**
Internal function to return the currently active brush and its properties.
@param aBrush On success, holds the current VGImage brush being used.
@param aSize On success, holds the dimensions of VGImage being used as the brush.
@param aFormat On success, holds the VGImageFormat of the brush. 
@return ETrue if a brush is currently being used, EFalse otherwise.
*/
TBool CVgEngine::GetCurrentBrushPattern(VGImage& aBrush, TSize& aSize, VGImageFormat& aFormat) const
	{
	TBool success = ETrue;
	if (iBrushStyle == DirectGdi::EPatternedBrush)
		{
		aBrush = iBrushPatternUser;
		aSize = iBrushPatternUserSize;
		aFormat = static_cast<VGImageFormat>(vgGetParameteri(aBrush, VG_IMAGE_FORMAT));
		}
	else if (iBrushStyle > DirectGdi::EPatternedBrush)
		{
		aBrush = iBrushPatternStandardRegion;
		aSize = iBrushPatternStandardRegionSize;
		// Currently we only ever use VG_sARGB_8888 for the standard brush format.
		aFormat = VG_sARGB_8888;
		}
	else 
		success = EFalse;
	return success;
	}

/**
Copies the current brush pattern (if a brush pattern is set) into iBrushPatternNonZeroOrigin.
This function should only be used if the current brush origin is not (0,0). When copying the
current brush pattern, it is shifted to take into account the non-zero origin. This shifted brush
pattern should be used for all brush operations while a non-zero origin is set.

@return	KErrNone if successful, KErrNotFound if the brush pattern could not be copied.
 */
TInt CVgEngine::CopyCurrentBrushPatternForNonZeroOrigin()
	{
	MakeEngineCurrent();
	TInt ret = KErrNotFound;
	VGImage brush = VG_INVALID_HANDLE;
	TSize brushSize;
	VGImageFormat imageFormat;
	
	if (GetCurrentBrushPattern(brush, brushSize, imageFormat))
		{
		const TInt width = brushSize.iWidth;
		const TInt height = brushSize.iHeight;
		
		if ((width != 0) && (height != 0))
			{
			if (iBrushPatternNonZeroOrigin != VG_INVALID_HANDLE)
				{
				vgDestroyImage(iBrushPatternNonZeroOrigin);
				iBrushPatternNonZeroOrigin = VG_INVALID_HANDLE;
				}
			
			// Create the brush we are going to copy the current brush into
			iBrushPatternNonZeroOrigin = DoVgCreateImage(imageFormat,
													width,
													height,
													VG_IMAGE_QUALITY_FASTER);
			if (iBrushPatternNonZeroOrigin != VG_INVALID_HANDLE)
				{
				TInt offsetX = width - (iBrushOrigin.iX % width);
				TInt offsetY = height - (iBrushOrigin.iY % height);	
				
				// Top left to bottom right			
				if (offsetX != 0 && offsetY != 0) // check the width and height we are copying are not 0
					vgCopyImage(iBrushPatternNonZeroOrigin, width-offsetX, height-offsetY, brush, 0, 0, offsetX, offsetY, VG_FALSE);
				
				// Top right to bottom left
				if ((width-offsetX) != 0 && offsetY != 0) 
					vgCopyImage(iBrushPatternNonZeroOrigin, 0, height-offsetY, brush, offsetX, 0, width-offsetX, offsetY, VG_FALSE);
				
				// Bottom left to top right
				if (offsetX != 0 && (height-offsetY) != 0) 
					vgCopyImage(iBrushPatternNonZeroOrigin, width-offsetX, 0, brush, 0, offsetY, offsetX, height-offsetY, VG_FALSE);				
				
				// Bottom right to top left
				if ((width-offsetX) != 0 && (height-offsetY) != 0) 
					vgCopyImage(iBrushPatternNonZeroOrigin, 0, 0, brush, offsetX, offsetY, width-offsetX, height-offsetY, VG_FALSE);
				
				// Paint with the new non-zero origin brush
				vgPaintPattern(iBrush, iBrushPatternNonZeroOrigin);
				
				ret = KErrNone;
				}	
			else
				{
				ret = KErrNoMemory;
				}
			}
		}
	
	return ret;
	}

/**
Calculates the angle in degrees formed anti-clockwise between vector V1 and V2, where V1 is a 
horizontal vector to the right from aOriginX, and V2 is the vector (aPointX-aOriginX, aPointY-aOriginY).

@param aOriginX	The x coordinate of a point which represents the origin of our calculation.
@param aOriginY	The y coordinate of a point which represents the origin of our calculation.
@param aPointX	The x coordinate of the point which defines the angle with the origin's x-axis.
@param aPointY 	The y coordinate of the point which defines the angle with the origin's y-axis.
@param aWidth	Width of the rectangle which defines where to draw the ellipse.
@param aHeight 	Height of the rectangle which defines where to draw the ellipse.

@panic DGDIAdapter 1006, if either width or height are less than 1 (debug-only).
@return	The angle in degrees between the vectors V1 and V2 described above.
 */
TReal CVgEngine::GetAngleFromXAxisAnticlockwise(const TReal aOriginX, const TReal aOriginY, const TReal aPointX, const TReal aPointY, const TReal aWidth, const TReal aHeight)
	{
	GRAPHICS_ASSERT_DEBUG((aWidth > 0) && (aHeight > 0), EDirectGdiPanicInvalidParameter);

// The angle is calculated from the radius line that joins the point to the origin.
// The point initially provided defines a line relative to the ellipse.
// But the VG spec states that the required angle is that for a perfect circle
// before that circle is scaled by the bounding rect into an ellipse.
// Therefore, downscale the position of the point relative to the origin, by the
// relative dimensions of the width/height of the ellipse to make it relative to
// the underlying circle. Then use the resulting circle radius line to calculate the angle.

	TReal angle = 0.0f;		
	TReal pointX = aPointX-aOriginX;
	TReal pointY = aPointY-aOriginY;

	const TReal scalingFactor = (aWidth / aHeight);
	pointY *= scalingFactor;
	Math::ATan(angle, pointY, pointX);
	
	// Adjust the angle for Q2 and Q3
	if (pointY < 0)
		angle = (KPi*2)+angle; 
		
	return angle*KRadToDeg;
	}

/**
Method for drawing arcs or pies. An arc is a segment of an ellipse which is defined by a given rectangle. 
The arc is drawn anti-clockwise from the arc start point to the arc end point. The arc start point is the 
intersection between vectors from the centre of the ellipse to the given start position and the ellipse.
The arc end point is defined in the same way.

@param	aRect		The rectangle which defines where to draw the ellipse.
@param	aStart		Position to be used in defining the arc start point.
@param	aEnd		Position to be used in defining the arc end point.
@param 	aArcType	The type of arc to draw; an arc, a chord or a pie.	

@post	Request to draw an arc has been accepted. There is no guarantee that the request 
		has been processed when the method returns.
		
@see	CVgEngine::DrawPie()
@see	CVgEngine::DrawArc()
 */
void CVgEngine::DoDrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd, VGUArcType aArcType)
	{
	MakeEngineCurrent();
	
	// Only draw if we are not painting with a NULL pen and a NULL brush
	if (iPaintMode == 0)
		return;
		
	// If the pen width and height are the same then draw as normal. If they are different but we should be filling
	// this shape we need to draw the filled area only as normal (not the outline). The outline of the shape is drawn 
	// in the block of code below to allow the effect of a different width and height pen to be applied.
	if ((iPenSize.iWidth == iPenSize.iHeight) || ((iPaintMode & VG_FILL_PATH) && (aArcType == VGU_ARC_PIE)))
		{
		TReal originX = aRect.iTl.iX + (static_cast<TReal>(aRect.Width())*0.5);
		TReal originY = aRect.iTl.iY + (static_cast<TReal>(aRect.Height())*0.5);
		TReal startAngle = GetAngleFromXAxisAnticlockwise(originX, originY, aStart.iX, aStart.iY, aRect.Width(), aRect.Height());
		TReal endAngle = GetAngleFromXAxisAnticlockwise(originX, originY, aEnd.iX, aEnd.iY, aRect.Width(), aRect.Height());		
		TReal extent = endAngle - startAngle;
		
		// The extent defines what direction the arc is drawn in, so make sure we always draw
		// anti-clockwise (-ve extent)
		if (extent > 0.0f)
			extent -= 360.0f;
		
		// If the start and end points are the same, make sure we draw arc all the way round the ellipse
		if ((aStart == aEnd) || (extent > -0.0001f))
			extent = -360.0f;
		
		// Before any vgu command, call SetError() as this stores the current vg error state (if any) in the 
		// driver. Some implementations of vgu clears error state so we'd lose error codes otherwise.
		iDriver.SetError(KErrNone);
		
		if (PreparePath(iVgPath, 5)) // N.B. 5 is just an initial hint as to how large the path may be, not its final size
			{
			VGUErrorCode err = vguArc(iVgPath, 
				originX + 0.5f, 
				originY + 0.5f, 
				aRect.Width(), 
				aRect.Height(), 
				startAngle, 
				extent, 
				aArcType);
			
			if (err == VGU_NO_ERROR)
				{
				VGbitfield paintMode = iPaintMode;		
				if(aArcType == VGU_ARC_OPEN)
					{
					paintMode &= ~VG_FILL_PATH;  
					}
				for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
					vgDrawPath(iVgPath, (iPenSize.iWidth == iPenSize.iHeight) ? paintMode : VG_FILL_PATH);				
				}
			else
				{
				SetVguError(err);
				}
			}
		}
	
	if ((iPenSize.iWidth != iPenSize.iHeight)
	&& (iPaintMode & VG_STROKE_PATH)		
	&& (iPenSize.iWidth != 0) && (iPenSize.iHeight != 0))
		{
		// Setting a pen with different width and height is not available on OpenVG, so we need to scale 
		// the coordinates we are drawing and apply a scaling matrix that scales by the width and height 
		// of the pen to get the effect of a pen width different width and height.
		TSize penSize = iPenSize;
		SetPenSize(TSize(1, 1));
		vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
		vgScale(penSize.iWidth, penSize.iHeight);			
		VGfloat scaleX = 1.0f/(float)penSize.iWidth;
		VGfloat scaleY = 1.0f/(float)penSize.iHeight;
		
		TReal originX = aRect.iTl.iX + (static_cast<TReal>(aRect.Width())*0.5);
		TReal originY = aRect.iTl.iY + (static_cast<TReal>(aRect.Height())*0.5);
		TReal startAngle = GetAngleFromXAxisAnticlockwise(originX, originY, aStart.iX, aStart.iY, aRect.Width(), aRect.Height());
		TReal endAngle = GetAngleFromXAxisAnticlockwise(originX, originY, aEnd.iX, aEnd.iY, aRect.Width(), aRect.Height());		
		TReal extent = endAngle - startAngle;
		
		// The extent defines what direction the arc is drawn in, so make sure we always draw
		// anti-clockwise (-ve extent)
		if (extent > 0.0f)
			extent -= 360.0f;
		
		// If the start and end points are the same, make sure we draw arc all the way round the ellipse
		if ((aStart == aEnd) || (extent > -0.0001f))
			extent = -360.0f;
		
		// Before any vgu command, call SetError() as this stores the current vg error state (if any) in the 
		// driver. Some implementations of vgu clears error state so we'd lose error codes otherwise.
		iDriver.SetError(KErrNone);
		
		if (PreparePath(iVgPath, 5))
			{
			VGUErrorCode err = vguArc(iVgPath, 
				(originX + 0.5f) * scaleX, 
				(originY + 0.5f) * scaleY, 
				(float)aRect.Width() * scaleX, 
				(float)aRect.Height() * scaleY, 
				startAngle, 
				extent, 
				aArcType);
			
			if (err == VGU_NO_ERROR)
				{	
				for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
					vgDrawPath(iVgPath, VG_STROKE_PATH);				
				}
			else
				{
				SetVguError(err);
				}
			}
		
		ResetVgMatrix(VG_MATRIX_PATH_USER_TO_SURFACE);
		SetPenSize(penSize);
		}
	
	}

/**
Helper function for drawing a source as a CDirectGdiImageSource.
 
@see DrawResource(const TRect&, const RDirectGdiDrawableSource&, DirectGdi::TGraphicsRotation).
 */
void CVgEngine::DoDrawResource(const TRect& aDestRect,
					CDirectGdiImageSourceImpl* aSource,
					DirectGdi::TGraphicsRotation aRotation)

	{
	TSize size = aSource->Size();
	TRect srcRect(0, 0, size.iWidth, size.iHeight);
	
	DoDrawResource(aDestRect, aSource, srcRect, aRotation);
	}

/**
Helper function for drawing a source as a CDirectGdiImageSource. 

@see DrawResource(const TRect&, const RDirectGdiDrawableSource&, const TRect&, DirectGdi::TGraphicsRotation). 
 */
void CVgEngine::DoDrawResource(const TRect& aDestRect,
					CDirectGdiImageSourceImpl* aSource,
					const TRect& aSourceRect,
					DirectGdi::TGraphicsRotation aRotation)
	{				 
	// If the source rect is smaller than the actual source size then we need to create a child VGImage to draw
	VGImage vgImage = aSource->VgImage();
	TSize size = aSource->Size();
	if ((aSourceRect.Width() < size.iWidth) || (aSourceRect.Height() < size.iHeight))
		{
		vgImage = vgChildImage(vgImage, aSourceRect.iTl.iX, aSourceRect.iTl.iY, aSourceRect.Width(), aSourceRect.Height());
		}
		
	if (vgImage != VG_INVALID_HANDLE)
		{
		vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);	
		
		TRect destRect(aDestRect);
		TRect sourceRect(aSourceRect);

		if (aRotation == DirectGdi::EGraphicsRotationNone ||
			aRotation == DirectGdi::EGraphicsRotation180)
			{
			// Pixel-data in EGLImages appears to be upside down due to the Y-inversion 
			// effect of the Identity matrix.  Therefore must undo the Y-inversion here 
			// and adjust destination rect accordingly.			
			const TInt destRectHeight = aDestRect.Height();
			destRect.iTl.iY = (iSize.iHeight - aDestRect.iTl.iY - iOrigin.iY) - destRectHeight;
			destRect.iTl.iX += iOrigin.iX;
			destRect.iBr.iX += iOrigin.iX;
			destRect.iBr.iY = destRect.iTl.iY + destRectHeight;
			sourceRect.iBr.iY = aSource->Size().iHeight - sourceRect.iTl.iY;
			sourceRect.iTl.iY = sourceRect.iBr.iY - aSourceRect.Height();
			vgLoadIdentity();
			}
		else
			{
			// But if rotation is 90 or 270 degrees, only need to mirror in the X-axis.
			vgScale(-1, 1);
			}

		VGfloat xScale = 1.f;
		VGfloat yScale = 1.f;				
		VGint posX = destRect.iTl.iX;
		VGint posY = destRect.iTl.iY;		
					
		switch (aRotation)
			{									
			case DirectGdi::EGraphicsRotation90:
				xScale = ((VGfloat)destRect.Width()/(VGfloat)sourceRect.Height());
				yScale = ((VGfloat)destRect.Height()/(VGfloat)sourceRect.Width());																	
				vgTranslate(-posX, posY);
				vgScale(xScale, yScale);
				vgRotate(90.0f);					
				break;
			case DirectGdi::EGraphicsRotation180:								
				xScale = ((VGfloat)destRect.Width()/(VGfloat)sourceRect.Width());
				yScale = ((VGfloat)destRect.Height()/(VGfloat)sourceRect.Height());
				vgTranslate(posX+destRect.Width(), posY+destRect.Height());
				vgScale(xScale, yScale);
				vgRotate(180.0f);												
				break;
			case DirectGdi::EGraphicsRotation270:
				xScale = ((VGfloat)destRect.Width()/(VGfloat)sourceRect.Height());
				yScale = ((VGfloat)destRect.Height()/(VGfloat)sourceRect.Width());
				vgTranslate(-posX-destRect.Width(), (posY+destRect.Height()));
				vgScale(xScale, yScale);
				vgRotate(270.0f);
				break;
			default: // DirectGdi::EGraphicsRotationNone
				xScale = ((VGfloat)destRect.Width()/(VGfloat)sourceRect.Width());
				yScale = ((VGfloat)destRect.Height()/(VGfloat)sourceRect.Height());
				vgTranslate(posX, posY);
				vgScale(xScale, yScale);
				break;
			}																							
		
		for (iRegionManager.Begin(); iRegionManager.ApplyClipRegion(); iRegionManager.Next())
			vgDrawImage(vgImage);
		
		if (vgImage != aSource->VgImage())
			{
			// Created a child VGImage, so destroy after use.
			vgDestroyImage(vgImage);
			}
		
		ResetVgMatrix(VG_MATRIX_IMAGE_USER_TO_SURFACE);
		}
	}

/**
Maps a VGU error code to a Symbian OS error code, and sets the driver's error state. If the 
error is unrecognised, the error is set to KErrGeneral.

@param aErr The return value (error state) from a VGU command.
@post If empty, the driver's error state is updated to the mapped error code.
*/
void CVgEngine::SetVguError(VGUErrorCode aErr)
	{
	switch(aErr)
		{
		case VGU_NO_ERROR:
			break;
		case VGU_OUT_OF_MEMORY_ERROR:
			iDriver.SetError(KErrNoMemory);
			break;
		case VGU_BAD_HANDLE_ERROR:
			iDriver.SetError(KErrBadHandle);
			break;
		case VGU_ILLEGAL_ARGUMENT_ERROR:
			iDriver.SetError(KErrArgument);
			break;
		case VGU_PATH_CAPABILITY_ERROR:
			iDriver.SetError(KErrNotSupported);
			break;
		default:
			iDriver.SetError(KErrGeneral);
			break;
		}
	}	

/**
Helper method for creating a VGImage. This method clears the VG image cache in an attempt to  
reclaim some memory if creation of a VGImage fails due to no memory being available, 
it then tries to create the image again. If image creation fails again it then clears the glyph 
cache and tries to create the image again. If image creation still fails, OpenVG is forced to 
complete all currently outstanding drawing requests, so that any OpenVG objects marked for deletion,
such as VGImages that are currently waiting to be drawn, are freed. This is an attempt to make sure 
that images are still displayed in low memory conditions. Use this method instead of calling 
vgCreateImage() directly. Clearing the VG image cache in this way will have a negative effect on 
performance regarding speed, but it is more important that an attempt is made to draw something 
when memory is low.

@param aFormat The pixel format of the image to be created
@param aWidth The width of the image to be created
@param aHeight The height of the image to be created
@param aAllowedQuality One of the VGImageQuality flags

@return A VGImage handle if the image was created successfully, VG_INVALID_HANDLE otherwise 
 */
VGImage CVgEngine::DoVgCreateImage(VGImageFormat aFormat, VGint aWidth, VGint aHeight, VGbitfield aAllowedQuality)
	{
	const TInt oldVgError = CDirectGdiDriverImpl::GetVgError();
	VGImage imageRet = vgCreateImage(aFormat, aWidth, aHeight, aAllowedQuality);
	
	if (imageRet == VG_INVALID_HANDLE)
		{
		// If the new error is anything other than KErrNoMemory, there is nothing that can be done.
		TInt newVgError = CDirectGdiDriverImpl::GetVgError();		
		if (newVgError != KErrNoMemory)
			{
			iDriver.SetError(oldVgError != KErrNone ? oldVgError : newVgError);
			return imageRet;
			}

		// From here on, we are assuming any failure to create the image is due to OOM.
		if (iDriver.VgImageCache())
			{
			// Delete all the images that are currently in the cache then try and create the image again
			iDriver.VgImageCache()->ResetCache();
			imageRet = vgCreateImage(aFormat, aWidth, aHeight, aAllowedQuality);
			}
		if ((imageRet == VG_INVALID_HANDLE) && iFontGlyphImageStorage)
			{
			// Clear the glyph cache as well then try and create the image again
			iFontGlyphImageStorage->CleanGlyphImageCache();
			imageRet = vgCreateImage(aFormat, aWidth, aHeight, aAllowedQuality);
			}
		if ((imageRet == VG_INVALID_HANDLE))
			{
			// Finally, force completion of any outstanding drawing, may free any VGImages marked for deletion.
			// Empty the current OpenVG error state before calling Finish(), as Finish() may call SetError(),
			// and could prematurely set the driver error state to KErrNoMemory.
			//coverity[check_return]
			//coverity[unchecked_value]
			vgGetError();
			iDriver.Finish();
			imageRet = vgCreateImage(aFormat, aWidth, aHeight, aAllowedQuality);
			}

		// If the above worked, empty any OpenVG error state set by any failed attempts to create the image.
		if (imageRet != VG_INVALID_HANDLE)
			{
			//coverity[check_return]
			//coverity[unchecked_value]
			vgGetError();
			}
		}
	
	// Reset the error code to the original VG error code. If oldVgError is KErrNone, 
	// SetError() will use the current OpenVG error state.
	iDriver.SetError(oldVgError);
	
	return imageRet;
	}

/**
Helper method for setting the colour property of a VGPaint object from a TRgb structure.

@param aPaint The VGPaint object to change the colour property of.
@param aColor The colour to set the paint to.
*/ 
void CVgEngine::SetVgPaintColor(VGPaint& aPaint, const TRgb& aColor)
	{
	// Need to swap from internal ARGB to RGBA for OpenVG.
	const TUint argb = aColor.Internal();
	const VGuint rgba = ((argb & 0xFFFFFF) << 8) + ((argb & 0xFF000000) >> 24);
	vgSetColor(aPaint, rgba);
	}