// 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 OpenVG handle based objects

#include "vgstate.h"
#include "remotefunctioncall.h"
#include "openvgrfc.h"


/////////////////////////////////////////////////////////////////////////////////////////////
// CVgPathInfo
/////////////////////////////////////////////////////////////////////////////////////////////

CVgPathInfo* CVgPathInfo::New(VGPathDatatype aDatatype, VGfloat aScale, VGfloat aBias, VGbitfield aCapabilities)
	{
	RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();
	CVgPathInfo* self = new CVgPathInfo(aDatatype, aScale, aBias, aCapabilities);
	CVghwUtils::SwitchFromVghwHeap(clientHeap);
	return self;
	}


void CVgPathInfo::ClearPath(MVgContext& aVgContext, VGbitfield aCapabilities)
	{
	iCapabilities = aCapabilities & VG_PATH_CAPABILITY_ALL;
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgClearPath, RemoteFunctionCallData::EOpRequest);
	vgApiData.AppendParam(HostHandle());
	vgApiData.AppendParam(aCapabilities);
	aVgContext.ExecuteVgCommand(vgApiData);
	}


void CVgPathInfo::RemovePathCapabilities(MVgContext& aVgContext, VGbitfield aCapabilities)
	{
	if (aCapabilities & VG_PATH_CAPABILITY_ALL)
		{
		iCapabilities = (iCapabilities & ~aCapabilities);
		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
		vgApiData.Init(OpenVgRFC::EvgRemovePathCapabilities, RemoteFunctionCallData::EOpRequest);
		vgApiData.AppendParam(HostHandle());
		vgApiData.AppendParam(aCapabilities & VG_PATH_CAPABILITY_ALL);
		aVgContext.ExecuteVgCommand(vgApiData);
		}
	}


VGbitfield CVgPathInfo::GetPathCapabilities(MVgContext& aVgContext)
	{
	// value is tracked in Client side - but Debug builds verify state with the Host Open VG
#ifdef _DEBUG
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgGetPathCapabilities);
	vgApiData.AppendParam(HostHandle());
	VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
	aVgContext.ExecuteVgCommand(vgApiData);
	VGbitfield hostCapabilities = static_cast<VGbitfield>(vgApiData.ReturnValue());
	VGPANIC_ASSERT_DEBUG(hostCapabilities == iCapabilities, EVgPanicTemp);
#endif
	return iCapabilities;
	}


CVgPathInfo::~CVgPathInfo()
	{}

CVgPathInfo::CVgPathInfo(VGPathDatatype aDatatype, VGfloat aScale, VGfloat aBias, VGbitfield aCapabilities) :
	CVgHandleBase(EVgHandleForPath), iDatatype(aDatatype), iScale(aScale), iBias(aBias), iCapabilities(aCapabilities)
	{}


VGPathDatatype CVgPathInfo::PathDatatype() const
	{
	return iDatatype;
	}


TBool CVgPathInfo::CheckHasPathCapabilities(MVgContext& aVgContext, VGbitfield aCapabilities)
	{
	if ( aCapabilities == (aCapabilities & iCapabilities) )
		{
		return ETrue;
		}

	OPENVG_TRACE("CVgPathInfo::CheckHasPathCapabilities (iCapabilities=0x%x, aCapabilities=0x%x) setting VG_PATH_CAPABILITY_ERROR",
			iCapabilities, aCapabilities);
	aVgContext.SetVgError(VG_PATH_CAPABILITY_ERROR);
	return EFalse;
	}


TBool CVgPathInfo::CheckPathDataAlignment(MVgContext& aVgContext, const void* aPathData)
	{
	TBool result = EFalse;
	if (aPathData != NULL)
		{
		switch (iDatatype)
			{
			case VG_PATH_DATATYPE_S_8:
				result = ETrue;
				break;
			case VG_PATH_DATATYPE_S_16:
				result = !( 1ul & (unsigned)aPathData );
				break;
			case VG_PATH_DATATYPE_S_32:
			case VG_PATH_DATATYPE_F:
				result = !( 3ul & (unsigned)aPathData );
				break;
			}
		}
	if (!result)
		{
		OPENVG_TRACE("CVgPathInfo::CheckPathDataAlignment (iDatatype=%d, aPathData=0x%x) setting VG_ILLEGAL_ARGUMENT_ERROR",
				iDatatype, aPathData);
		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
		}
	return result;
	}


//
TBool CVgPathInfo::CheckPathDataSize(MVgContext& aVgContext, const VGubyte* aPathSegments, VGint aNumSegments, VGint* aPathDataSize)
	{
	TBool checkOkay = EFalse;
	VGint pathDataSize = 0;

	if ( (aNumSegments > 0) && (aPathSegments != NULL) )
		{
		checkOkay = ETrue;

#define SEGMENT_COMMAND(command) ((command) >> 1)
		// Number of coordinates for each command
		static const VGint KNumCoords[] = {0,2,2,1,1,4,6,2,4,5,5,5,5};

		for (VGint segIdx = 0; segIdx < aNumSegments; )
			{
			VGubyte segmentType = aPathSegments[segIdx++];
			if (segmentType > 25) // VGPathSegment max value 12 << 1 or'd with 0|1
				{
				OPENVG_TRACE("   CheckPathDataSize - unknown segmentType-0x%x", segmentType);
				checkOkay = EFalse;
				break;
				}
			VGint command = SEGMENT_COMMAND(segmentType);
			pathDataSize += KNumCoords[command];
			OPENVG_TRACE("   CheckPathDataSize segmentType=0x%x: command=0x%x, Total Coord Count=%d", segmentType, command, pathDataSize);
			}
		}

	if ( !checkOkay )
		{
		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
		OPENVG_TRACE("   CheckPathDataSize - Illegal Argument Error, aPathSegments=0x%x, aNumSegments=%d", aPathSegments, aNumSegments);
		}
	else
		{
		// Number of bytes for each VGPathDatatype
		static const VGint KNumBytes[] = {1,2,4,4};
		// convert coord count to bytes
		pathDataSize *= KNumBytes[iDatatype];

		*aPathDataSize = pathDataSize;
		OPENVG_TRACE("   CheckPathDataSize - success, pathDataSize=%d bytes", pathDataSize);
		}
	return checkOkay;
	}


// Check path parameters for vgAppendPathData
TBool CVgPathInfo::CheckAppendPathData(MVgContext& aVgContext, VGint aNumSegments, const VGubyte* aPathSegments, const void* aPathData,
		VGint* aPathDataSize)
	{
	return CheckPathDataAlignment(aVgContext, aPathData) && CheckPathDataSize(aVgContext, aPathSegments, aNumSegments, aPathDataSize);
	}


TBool CVgPathInfo::DestroyObject(MVgContext& aVgContext)
	{
	VGPANIC_ASSERT_DEBUG(iIsDestroyed, EVgPanicTemp);
	OPENVG_TRACE("  CVgPathInfo::DestroyObject HostHandle=0x%x", iHostHandle);

	if (iHostHandle)
		{
		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
		vgApiData.Init(OpenVgRFC::EvgDestroyPath, RemoteFunctionCallData::EOpRequest);
		vgApiData.AppendParam(iHostHandle);
		aVgContext.ExecuteVgCommand(vgApiData);
		}

	return ETrue;
	}


VGint CVgPathInfo::GetParameterVectorSize(MVgContext& aVgContext, VGint aParamType)
	{
	switch (aParamType)
		{
		case VG_PATH_FORMAT:
		case VG_PATH_DATATYPE:
		case VG_PATH_SCALE:
		case VG_PATH_BIAS:
		case VG_PATH_NUM_SEGMENTS:
		case VG_PATH_NUM_COORDS:
			return 1;
		}

	// invalid ParamType
	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
	return 0;
	}


VGfloat CVgPathInfo::GetParameterf(MVgContext& aVgContext, VGint aParamType)
	{
	switch (aParamType)
		{
		case VG_PATH_DATATYPE:
			return (VGfloat) iDatatype;

		case VG_PATH_SCALE:
			return iScale;

		case VG_PATH_BIAS:
			return iBias;

		case VG_PATH_FORMAT:
		case VG_PATH_NUM_SEGMENTS:
		case VG_PATH_NUM_COORDS:
			return HostVgGetParameterf(aVgContext, aParamType);
		}

	// invalid ParamType
	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
	return 0;
	}


VGint CVgPathInfo::GetParameteri(MVgContext& aVgContext, VGint aParamType)
	{
	switch (aParamType)
		{
		case VG_PATH_DATATYPE:
			return iDatatype;

		case VG_PATH_SCALE:
			return (VGint) iScale;

		case VG_PATH_BIAS:
			return (VGint) iBias;

		case VG_PATH_FORMAT:
		case VG_PATH_NUM_SEGMENTS:
		case VG_PATH_NUM_COORDS:
			return HostVgGetParameteri(aVgContext, aParamType);
		}

	// invalid ParamType
	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
	return 0;
	}


void CVgPathInfo::AppendPath(MVgContext& aVgContext, CVgPathInfo& aSrcPathInfo)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgAppendPath, RemoteFunctionCallData::EOpRequest);
	vgApiData.AppendParam(iHostHandle);
	vgApiData.AppendParam(aSrcPathInfo.HostHandle());
	aVgContext.ExecuteVgCommand(vgApiData);
	}


void CVgPathInfo::AppendPathData(MVgContext& aVgContext, VGint aNumSegments, const VGubyte * aPathSegments, const void* aPathData)
	{
	VGint pathDataSize = 0;
	if ( CheckAppendPathData(aVgContext, aNumSegments, aPathSegments, aPathData, &pathDataSize) )
		{
		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
		vgApiData.Init(OpenVgRFC::EvgAppendPathData, RemoteFunctionCallData::EOpRequest);
		vgApiData.AppendParam(iHostHandle);
		vgApiData.AppendParam(aNumSegments);
		vgApiData.AppendVector(aPathSegments, aNumSegments);
		vgApiData.AppendVector(aPathData, pathDataSize);
		aVgContext.ExecuteVgCommand(vgApiData);
		}
	}


//Private extension to Open VG API to get the path length
VGint CVgPathInfo::HostVgeGetPathCoordsSizeInBytes(MVgContext& aVgContext, VGint aStartIndex, VGint aNumSegments)
	{
	RemoteFunctionCallData rfcdata; OpenVgRFC vgApiData(rfcdata);
	vgApiData.Init(OpenVgRFC::EvgePathCoordsSizeInBytes);
	vgApiData.AppendParam(iHostHandle);
	vgApiData.AppendParam(aStartIndex);
	vgApiData.AppendParam(aNumSegments);
	VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
	aVgContext.ExecuteVgCommand(vgApiData);
	return static_cast<VGint>(vgApiData.ReturnValue());
	}


void CVgPathInfo::ModifyPathCoords(MVgContext& aVgContext, VGint aStartIndex, VGint aNumSegments, const void* aPathData)
	{
	if (CheckPathDataAlignment(aVgContext, aPathData))
		{
		// The host OpenVG implementation returns -1 if vgePathCoordsSizeInBytes is not supported
		// It does not seem simple to reliably implement vgePathCoordsSizeInBytes in the Symbian client
		VGint dataSize = HostVgeGetPathCoordsSizeInBytes(aVgContext, aStartIndex, aNumSegments);
		OPENVG_TRACE("TGuestOpenVg::vgModifyPathCoords - dataSize=%d", dataSize);
		if (dataSize <= 0)
			{
			aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
			}
		else
			{
			RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
			vgApiData.Init(OpenVgRFC::EvgModifyPathCoords, RemoteFunctionCallData::EOpRequest);
			vgApiData.AppendParam(iHostHandle);
			vgApiData.AppendParam(aStartIndex);
			vgApiData.AppendParam(aNumSegments);
			vgApiData.AppendVector(aPathData, dataSize);
			aVgContext.ExecuteVgCommand(vgApiData);
			}
		}
	}


void CVgPathInfo::TransformPath(MVgContext& aVgContext, CVgPathInfo& aSrcPathInfo)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgTransformPath, RemoteFunctionCallData::EOpRequest);
	vgApiData.AppendParam(iHostHandle);
	vgApiData.AppendParam(aSrcPathInfo.HostHandle());
	aVgContext.ExecuteVgCommand(vgApiData);
	}


VGboolean CVgPathInfo::InterpolatePath(MVgContext& aVgContext, CVgPathInfo& aStartPathInfo, CVgPathInfo& aEndPathInfo, VGfloat aAmount)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgInterpolatePath);
	vgApiData.AppendParam(iHostHandle);
	vgApiData.AppendParam(aStartPathInfo.HostHandle());
	vgApiData.AppendParam(aEndPathInfo.HostHandle());
	vgApiData.AppendParam(aAmount);
	VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
	aVgContext.ExecuteVgCommand(vgApiData);
	return static_cast<VGboolean>(vgApiData.ReturnValue());
	}


VGfloat CVgPathInfo::PathLength(MVgContext& aVgContext, VGint aStartSegment, VGint aNumSegments)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgPathLength);
	vgApiData.AppendParam(iHostHandle);
	vgApiData.AppendParam(aStartSegment);
	vgApiData.AppendParam(aNumSegments);
	VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
	aVgContext.ExecuteVgCommand(vgApiData);
	return static_cast<VGfloat>(vgApiData.ReturnValue());
	}


void CVgPathInfo::PointAlongPath(MVgContext& aVgContext, VGint aStartSegment, VGint aNumSegments, VGfloat aDistance,
		VGfloat* aX, VGfloat* aY, VGfloat* aTangentX, VGfloat* aTangentY)
	{
	TBool getPoint = (aX && aY);
	TBool getTangent = (aTangentX && aTangentY);

	if ( getPoint && !TCheck::Chk2x32bitPtr(aVgContext, aX, aY) )
		{
		return;
		}
	if ( getTangent && !TCheck::Chk2x32bitPtr(aVgContext, aTangentX, aTangentY) )
		{
		return;
		}
	if (getPoint || getTangent)
		{
		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
		vgApiData.Init(OpenVgRFC::EvgPointAlongPath);
		vgApiData.AppendParam(iHostHandle);
		vgApiData.AppendParam(aStartSegment);
		vgApiData.AppendParam(aNumSegments);
		vgApiData.AppendParam(aDistance);
		vgApiData.AppendVector(aX, getPoint ? 1 : 0, RemoteFunctionCallData::EOut);
		vgApiData.AppendVector(aY, getPoint ? 1 : 0, RemoteFunctionCallData::EOut);
		vgApiData.AppendVector(aTangentX, getTangent ? 1 : 0, RemoteFunctionCallData::EOut);
		vgApiData.AppendVector(aTangentY, getTangent ? 1 : 0, RemoteFunctionCallData::EOut);
		aVgContext.ExecuteVgCommand(vgApiData);
		}
	}


void CVgPathInfo::PathBounds(MVgContext& aVgContext, VGfloat* aMinX, VGfloat* aMinY, VGfloat* aWidth, VGfloat* aHeight)
	{
	if (TCheck::Chk4x32bitPtr(aVgContext, aMinX, aMinY, aWidth, aHeight) )
		{
		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
		vgApiData.Init(OpenVgRFC::EvgPathBounds);
		vgApiData.AppendParam(iHostHandle);
		vgApiData.AppendVector(aMinX, 1, RemoteFunctionCallData::EOut);
		vgApiData.AppendVector(aMinY, 1, RemoteFunctionCallData::EOut);
		vgApiData.AppendVector(aWidth, 1, RemoteFunctionCallData::EOut);
		vgApiData.AppendVector(aHeight, 1, RemoteFunctionCallData::EOut);
		aVgContext.ExecuteVgCommand(vgApiData);
		}
	}


void CVgPathInfo::PathTransformedBounds(MVgContext& aVgContext, VGfloat* aMinX, VGfloat* aMinY, VGfloat* aWidth, VGfloat* aHeight)
	{
	if (TCheck::Chk4x32bitPtr(aVgContext, aMinX, aMinY, aWidth, aHeight) )
		{
		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
		vgApiData.Init(OpenVgRFC::EvgPathTransformedBounds);
		vgApiData.AppendParam(iHostHandle);
		vgApiData.AppendVector(aMinX, 1, RemoteFunctionCallData::EOut);
		vgApiData.AppendVector(aMinY, 1, RemoteFunctionCallData::EOut);
		vgApiData.AppendVector(aWidth, 1, RemoteFunctionCallData::EOut);
		vgApiData.AppendVector(aHeight, 1, RemoteFunctionCallData::EOut);
		aVgContext.ExecuteVgCommand(vgApiData);
		}
	}


void CVgPathInfo::DrawPath(MVgContext& aVgContext, VGbitfield aPaintModes)
	{
	if ( TCheck::ChkVGPaintModesCombination(aVgContext, aPaintModes) )
		{
		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
		vgApiData.Init(OpenVgRFC::EvgDrawPath, RemoteFunctionCallData::EOpRequest);
		vgApiData.AppendParam(iHostHandle);
		vgApiData.AppendParam(aPaintModes);
		aVgContext.ExecuteVgCommand(vgApiData);
		}
	}


void CVgPathInfo::RenderToMask(MVgContext& aVgContext, VGbitfield aPaintModes, VGMaskOperation aOperation)
	{
	if ( TCheck::ChkVGPaintModesCombination(aVgContext, aPaintModes) && TCheck::ChkVGMaskOperation(aVgContext, aOperation) )
		{
		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
		vgApiData.Init(OpenVgRFC::EvgRenderToMask, RemoteFunctionCallData::EOpRequest);
		vgApiData.AppendParam(iHostHandle);
		vgApiData.AppendParam(aPaintModes);
		vgApiData.AppendParam(aOperation);
		aVgContext.ExecuteVgCommand(vgApiData);
		}
	}


// end of file vgpath.cpp