// Copyright (c) 2010 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:

// Client-side state information for Open VG handle based objects

#include "vgstate.h"

#include "remotefunctioncall.h"

#include "openvgrfc.h"

/////////////////////////////////////////////////////////////////////////////////////////////

// CVgPaintInfo

/////////////////////////////////////////////////////////////////////////////////////////////

CVgPaintInfo* CVgPaintInfo::New()

	{

	RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();

	CVgPaintInfo* self = new CVgPaintInfo();

	CVghwUtils::SwitchFromVghwHeap(clientHeap);

	return self;

	}

CVgPaintInfo::~CVgPaintInfo()

	{}

CVgPaintInfo::CVgPaintInfo() :

		CVgHandleBase(EVgHandleForPaint),

		iPaintType(VG_PAINT_TYPE_COLOR), iColorRampSpreadMode(VG_COLOR_RAMP_SPREAD_PAD),

		iColorRampPremultiplied(VG_TRUE), iPatternTilingMode(VG_TILE_FILL)

	{}

TBool CVgPaintInfo::DestroyObject(MVgContext& aVgContext)

	{

	VGPANIC_ASSERT_DEBUG(iIsDestroyed, EVgPanicTemp);

	OPENVG_TRACE("  CVgPaintInfo::DestroyObject HostHandle=0x%x", iHostHandle);

	if (iHostHandle)

		{

		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

		vgApiData.Init(OpenVgRFC::EvgDestroyPaint, RemoteFunctionCallData::EOpRequest);

		vgApiData.AppendParam(iHostHandle);

		aVgContext.ExecuteVgCommand(vgApiData);

		}

	return ETrue;

	}

VGint CVgPaintInfo::GetParameterVectorSize(MVgContext& aVgContext, VGint aParamType)

	{

	switch (aParamType)

		{

		case VG_PAINT_TYPE:

		case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

		case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

		case VG_PAINT_PATTERN_TILING_MODE:

			return 1;

		case VG_PAINT_COLOR:

		case VG_PAINT_LINEAR_GRADIENT:

			return 4;

		case VG_PAINT_COLOR_RAMP_STOPS:

			return 10000; // note: finite limit due to Guest serialisation limits 

		case VG_PAINT_RADIAL_GRADIENT:

			return 5;

		}

	// invalid ParamType

	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

	return 0;

	}

VGfloat CVgPaintInfo::GetParameterf(MVgContext& aVgContext, VGint aParamType)

	{

	switch (aParamType)

		{

		case VG_PAINT_TYPE:

			return (VGfloat) iPaintType;

		case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

			return (VGfloat) iColorRampSpreadMode;

		case VG_PAINT_PATTERN_TILING_MODE:

			return (VGfloat) iPatternTilingMode;

		case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

			return (VGfloat) iColorRampPremultiplied;

		case VG_PAINT_COLOR:

		case VG_PAINT_COLOR_RAMP_STOPS:

		case VG_PAINT_LINEAR_GRADIENT:

		case VG_PAINT_RADIAL_GRADIENT:

			return HostVgGetParameterf(aVgContext, aParamType);

		}

	// invalid ParamType

	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

	return 0;

	}

VGint CVgPaintInfo::GetParameteri(MVgContext& aVgContext, VGint aParamType)

	{

	switch (aParamType)

		{

		case VG_PAINT_TYPE:

			return iPaintType;

		case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

			return iColorRampSpreadMode;

		case VG_PAINT_PATTERN_TILING_MODE:

			return iPatternTilingMode;

		case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

			return iColorRampPremultiplied;

		case VG_PAINT_COLOR:

		case VG_PAINT_COLOR_RAMP_STOPS:

		case VG_PAINT_LINEAR_GRADIENT:

		case VG_PAINT_RADIAL_GRADIENT:

			return HostVgGetParameteri(aVgContext, aParamType);

		}

	// invalid ParamType

	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

	return 0;

	}

void CVgPaintInfo::GetParameterfv(MVgContext& aVgContext, VGint aParamType, VGint aCount, VGfloat * aValues)

	{

	if (aCount > 0)

		{

		// vSize = 0 means the ParamType is not valid for this object, and VG error is already set 

		VGint vSize = GetParameterVectorSize(aVgContext, aParamType);

		if (vSize == 0)

			{ // VG Error already set

			return;

			}

		if ( (aCount <= vSize) )

			{

			switch (aParamType)

				{

				case VG_PAINT_TYPE:

					*aValues = (VGfloat) iPaintType;

					return;

				case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

					*aValues = (VGfloat) iColorRampSpreadMode;

					return;

				case VG_PAINT_PATTERN_TILING_MODE:

					*aValues = (VGfloat) iPatternTilingMode;

					return;

				case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

					*aValues = (VGfloat) iColorRampPremultiplied;

					return;

				case VG_PAINT_COLOR:

				case VG_PAINT_COLOR_RAMP_STOPS:

				case VG_PAINT_LINEAR_GRADIENT:

				case VG_PAINT_RADIAL_GRADIENT:

					HostVgGetParameterfv(aVgContext, aParamType, aCount, aValues);

					return;

				}

			}

		}

	// invalid ParamType

	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

	return;

	}

void CVgPaintInfo::GetParameteriv(MVgContext& aVgContext, VGint aParamType, VGint aCount, VGint * aValues)

	{

	if (aCount > 0)

		{

		// vSize = 0 means the ParamType is not valid for this object, and VG error is already set 

		VGint vSize = GetParameterVectorSize(aVgContext, aParamType);

		if (vSize == 0)

			{ // VG Error already set

			return;

			}

		if ( (aCount <= vSize) )

			{

			switch (aParamType)

				{

				case VG_PAINT_TYPE:

					*aValues = iPaintType;

					return;

				case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

					*aValues = iColorRampSpreadMode;

					return;

				case VG_PAINT_PATTERN_TILING_MODE:

					*aValues = iPatternTilingMode;

					return;

				case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

					*aValues = iColorRampPremultiplied;

					return;

				case VG_PAINT_COLOR:

				case VG_PAINT_COLOR_RAMP_STOPS:

				case VG_PAINT_LINEAR_GRADIENT:

				case VG_PAINT_RADIAL_GRADIENT:

					HostVgGetParameteriv(aVgContext, aParamType, aCount, aValues);

					return;

				}

			}

		}

	// invalid ParamType

	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

	return;

	}

void CVgPaintInfo::SetParameterf(MVgContext& aVgContext, VGint aParamType, VGfloat aValue)

	{

	switch (aParamType)

		{

		case VG_PAINT_TYPE:

		case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

		case VG_PAINT_PATTERN_TILING_MODE:

		case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

			SetParameteri(aVgContext, aParamType, (VGint) aValue);

			return;

			// **** desireable: add full checks for valid Values

		case VG_PAINT_COLOR:

		case VG_PAINT_COLOR_RAMP_STOPS:

		case VG_PAINT_LINEAR_GRADIENT:

		case VG_PAINT_RADIAL_GRADIENT:

			HostVgSetParameterf(aVgContext, aParamType, aValue);

			return;

		}

	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR); // invalid or Read-Only parameter

	}

void CVgPaintInfo::SetParameteri(MVgContext& aVgContext, VGint aParamType, VGint aValue)

	{

	switch (aParamType)

		{

		case VG_PAINT_TYPE:

			if ( (aValue >= VG_PAINT_TYPE_COLOR) && (aValue <= VG_PAINT_TYPE_PATTERN) )

				{

				iPaintType = (VGPaintType) aValue;

				HostVgSetParameteri(aVgContext, aParamType, aValue);

				return;

				}

			break;

		case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

			if ( (aValue >= VG_COLOR_RAMP_SPREAD_PAD) && (aValue <= VG_COLOR_RAMP_SPREAD_REFLECT) )

				{

				iColorRampSpreadMode = (VGColorRampSpreadMode) aValue;

				HostVgSetParameteri(aVgContext, aParamType, aValue);

				return;

				}

			break;

		case VG_PAINT_PATTERN_TILING_MODE:

			if ( (aValue >= VG_TILE_FILL) && (aValue <= VG_TILE_REFLECT) )

				{

				iPatternTilingMode = (VGTilingMode) aValue;

				HostVgSetParameteri(aVgContext, aParamType, aValue);

				return;

				}

			break;

		case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

			if ( (aValue == VG_FALSE) || (aValue == VG_TRUE) )

				{

				iColorRampPremultiplied = (VGboolean) aValue;

				HostVgSetParameteri(aVgContext, aParamType, aValue);

				return;

				}

			break;

			// **** desireable: add full checks for valid Values

		case VG_PAINT_COLOR:

		case VG_PAINT_COLOR_RAMP_STOPS:

		case VG_PAINT_LINEAR_GRADIENT:

		case VG_PAINT_RADIAL_GRADIENT:

			HostVgSetParameteri(aVgContext, aParamType, aValue);

			return;

		}

	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR); // invalid or Read-Only parameter

	}

void CVgPaintInfo::SetParameterfv(MVgContext& aVgContext, VGint aParamType, VGint aCount, const VGfloat * aValues)

	{

	VGint vSize = GetParameterVectorSize(aVgContext, aParamType);

	if (vSize > 0)

		{

		if ( (aCount == 0) && (aValues == NULL) )

			{ // pointless but legal according to Open VG 1.1 spec

			return;

			}

		if ( (aCount > 0) && (aCount <= vSize) )

			{

			switch (aParamType)

				{

				case VG_PAINT_TYPE:

				case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

				case VG_PAINT_PATTERN_TILING_MODE:

				case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

					SetParameteri(aVgContext, aParamType, (VGint) *aValues);

					return;

				case VG_PAINT_COLOR:

				case VG_PAINT_COLOR_RAMP_STOPS:

				case VG_PAINT_LINEAR_GRADIENT:

				case VG_PAINT_RADIAL_GRADIENT:

					HostVgSetParameterfv(aVgContext, aParamType, aCount, aValues);

					return;

				}

			}

		// VGPaint parameter is Read-Only or should have a smaller vector

		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR); 

		}

	}

void CVgPaintInfo::SetParameteriv(MVgContext& aVgContext, VGint aParamType, VGint aCount, const VGint * aValues)

	{

	VGint vSize = GetParameterVectorSize(aVgContext, aParamType);

	if (vSize > 0)

		{

		if ( (aCount == 0) && (aValues == NULL) )

			{ // pointless but legal according to Open VG 1.1 spec

			return;

			}

		if ( (aCount > 0) && (aCount <= vSize) )

			{

			switch (aParamType)

				{

				case VG_PAINT_TYPE:

				case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

				case VG_PAINT_PATTERN_TILING_MODE:

				case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

					SetParameteri(aVgContext, aParamType, *aValues);

					return;

				case VG_PAINT_COLOR:

				case VG_PAINT_COLOR_RAMP_STOPS:

				case VG_PAINT_LINEAR_GRADIENT:

				case VG_PAINT_RADIAL_GRADIENT:

					HostVgSetParameteriv(aVgContext, aParamType, aCount, aValues);

					return;

				}

			}

		// VGPaint parameter is Read-Only or should have a smaller vector

		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

		}

	}

void CVgPaintInfo::SetPaint(MVgContext& aVgContext, VGbitfield aPaintModes)

	{

	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

	vgApiData.Init(OpenVgRFC::EvgSetPaint, RemoteFunctionCallData::EOpRequest);

	vgApiData.AppendParam(iHostHandle);

	vgApiData.AppendParam(aPaintModes);

	aVgContext.ExecuteVgCommand(vgApiData);

	}

//static

void CVgPaintInfo::ResetPaint(MVgContext& aVgContext)

	{

	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

	vgApiData.Init(OpenVgRFC::EvgSetPaint, RemoteFunctionCallData::EOpRequest);

	vgApiData.AppendParam(VG_INVALID_HANDLE);

	const VGuint KZero = 0; 

	vgApiData.AppendParam(KZero);

	aVgContext.ExecuteVgCommand(vgApiData);

	}

void CVgPaintInfo::SetColor(MVgContext& aVgContext, VGuint aRgba)

	{

	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

	vgApiData.Init(OpenVgRFC::EvgSetColor, RemoteFunctionCallData::EOpRequest);

	vgApiData.AppendParam(iHostHandle);

	vgApiData.AppendParam(aRgba);

	aVgContext.ExecuteVgCommand(vgApiData);

	}

VGuint CVgPaintInfo::GetColor(MVgContext& aVgContext)

	{

	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

	vgApiData.Init(OpenVgRFC::EvgGetColor);

	vgApiData.AppendParam(iHostHandle);

	VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);

	aVgContext.ExecuteVgCommand(vgApiData);

	return vgApiData.ReturnValue();

	}

void CVgPaintInfo::PaintPattern(MVgContext& aVgContext, CVgImageInfo* aPatternInfo)

	{

	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

	vgApiData.Init(OpenVgRFC::EvgPaintPattern, RemoteFunctionCallData::EOpRequest);

	vgApiData.AppendParam(iHostHandle);

	TUint64 sgId(0L);

	if (aPatternInfo == NULL)

		{

		vgApiData.AppendParam(VG_INVALID_HANDLE);

		}

	else

		{

		vgApiData.AppendParam(aPatternInfo->HostHandle());

		if (aPatternInfo->IsEglSibling())

			{

			sgId = aPatternInfo->SgImageId();

			}

		}

	vgApiData.AppendTUint64(sgId);

	aVgContext.ExecuteVgCommand(vgApiData);

	}

// end of file vgpaint.cpp