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