// 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"


// defintions for all static member data for CVgHandleBase family of classes
THandleGen   CVgHandleBase::iHandleGen; // for creating local UIDs for clients to use as VG Handles



/////////////////////////////////////////////////////////////////////////////////////////////
// THandleGen
/////////////////////////////////////////////////////////////////////////////////////////////

void THandleGen::Init(TUint aInit)
	{
	OPENVG_TRACE("THandleGen::Init aInit=0x%x", aInit);
	VGPANIC_ASSERT_DEBUG(aInit != 0, EVgPanicUidGeneratorZeroSeed);
	iValue = aInit;
	}


TUint THandleGen::NextUid()
	{
	VGPANIC_ASSERT_DEBUG(iValue != 0, EVgPanicUidGeneratorZeroSeed);
	TUint result = iValue;
	++iValue;
	if (iValue == 0)
		iValue = 1;
	return result;
	}


/////////////////////////////////////////////////////////////////////////////////////////////
// CVgHandleBase = base class for CVgImageInfo etc...
/////////////////////////////////////////////////////////////////////////////////////////////

// Client Handle generates local UIDs for each VG Handle based object created
void CVgHandleBase::InitStatics()
	{
	// valued of first Client side VG Handle
	TUint seed = 0x00010000;
	iHandleGen.Init(seed);
	}


void CVgHandleBase::Destroy(MVgContext& aVgContext)
	{
	VGPANIC_ASSERT_DEBUG(!IsDestroyed(), EVgPanicHandleAlreadyMarkedDestroyed);
	iIsDestroyed = ETrue;
	if (DestroyObject(aVgContext))
		{
		RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();
		OpenVgState.UnMapHandle(iClientHandle);
		delete this;
		CVghwUtils::SwitchFromVghwHeap(clientHeap);
		}
	}


VGint CVgHandleBase::HostVgGetParameterVectorSize(MVgContext& aVgContext, VGint aParamType)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgGetParameterVectorSize);
	vgApiData.AppendParam(HostHandle());
	vgApiData.AppendParam(aParamType);
	VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
	aVgContext.ExecuteVgCommand(vgApiData);
	return static_cast<VGint>(vgApiData.ReturnValue());
	}


VGint CVgHandleBase::HostVgGetParameteri(MVgContext& aVgContext, VGint aParamType)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgGetParameteri);
	vgApiData.AppendParam(HostHandle());
	vgApiData.AppendParam(aParamType);
	VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
	aVgContext.ExecuteVgCommand(vgApiData);
	return static_cast<VGint>(vgApiData.ReturnValue());
	}


VGfloat CVgHandleBase::HostVgGetParameterf(MVgContext& aVgContext, VGint aParamType)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgGetParameterf);
	vgApiData.AppendParam(HostHandle());
	vgApiData.AppendParam(aParamType);
	VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
	aVgContext.ExecuteVgCommand(vgApiData);
	return static_cast<VGfloat>(vgApiData.ReturnValue());
	}


void CVgHandleBase::HostVgGetParameterfv(MVgContext& aVgContext, VGint aParamType, VGint aCount, const VGfloat * aValues)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgGetParameterfv);
	vgApiData.AppendParam(iHostHandle);
	vgApiData.AppendParam(aParamType);
	vgApiData.AppendParam(aCount);
	vgApiData.AppendVector(aValues, aCount, RemoteFunctionCallData::EOut);
	aVgContext.ExecuteVgCommand(vgApiData);
	}


void CVgHandleBase::HostVgGetParameteriv(MVgContext& aVgContext, VGint aParamType, VGint aCount, const VGint * aValues)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgGetParameteriv);
	vgApiData.AppendParam(iHostHandle);
	vgApiData.AppendParam(aParamType);
	vgApiData.AppendParam(aCount);
	vgApiData.AppendVector(aValues, aCount, RemoteFunctionCallData::EOut);
	aVgContext.ExecuteVgCommand(vgApiData);
	}


void CVgHandleBase::HostVgSetParameterf(MVgContext& aVgContext, VGint aParamType, VGfloat aValue)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgSetParameterf, RemoteFunctionCallData::EOpRequest);
	vgApiData.AppendParam(iHostHandle);
	vgApiData.AppendParam(aParamType);
	vgApiData.AppendParam(aValue);
	aVgContext.ExecuteVgCommand(vgApiData);
	}


void CVgHandleBase::HostVgSetParameteri(MVgContext& aVgContext, VGint aParamType, VGint aValue)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgSetParameteri, RemoteFunctionCallData::EOpRequest);
	vgApiData.AppendParam(iHostHandle);
	vgApiData.AppendParam(aParamType);
	vgApiData.AppendParam(aValue);
	aVgContext.ExecuteVgCommand(vgApiData);
	}


void CVgHandleBase::HostVgSetParameterfv(MVgContext& aVgContext, VGint aParamType, VGint aCount, const VGfloat * aValues)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgSetParameterfv, RemoteFunctionCallData::EOpRequest);
	vgApiData.AppendParam(iHostHandle);
	vgApiData.AppendParam(aParamType);
	vgApiData.AppendParam(aCount);
	vgApiData.AppendVector(aValues, aCount);
	aVgContext.ExecuteVgCommand(vgApiData);
	}


void CVgHandleBase::HostVgSetParameteriv(MVgContext& aVgContext, VGint aParamType, VGint aCount, const VGint * aValues)
	{
	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
	vgApiData.Init(OpenVgRFC::EvgSetParameteriv, RemoteFunctionCallData::EOpRequest);
	vgApiData.AppendParam(iHostHandle);
	vgApiData.AppendParam(aParamType);
	vgApiData.AppendParam(aCount);
	vgApiData.AppendVector(aValues, aCount);
	aVgContext.ExecuteVgCommand(vgApiData);
	}


// Base version of  GetParameter* use GetParameterVectorSize to validate aParamType then cal Host VG
VGfloat CVgHandleBase::GetParameterf(MVgContext& aVgContext, VGint aParamType)
	{
	VGint vSize = GetParameterVectorSize(aVgContext, aParamType);
	if (vSize > 0)
		{
		return HostVgGetParameterf(aVgContext, aParamType);
		}
	return KFloatMinusOne;
	}


VGint CVgHandleBase::GetParameteri(MVgContext& aVgContext, VGint aParamType)
	{
	VGint vSize = GetParameterVectorSize(aVgContext, aParamType);
	if (vSize > 0)
		{
		return HostVgGetParameteri(aVgContext, aParamType);
		}
	return 0;
	}


/* Base versions of GetParameter*v call:
   * GetParameterVectorSize to validate aParamtType, 
   * if aCount is 1 they call GetParameterf/i for the object
   * otherwise if aCount is valid they call HostVgGetParameter*v
   * */
void CVgHandleBase::GetParameterfv(MVgContext& aVgContext, VGint aParamType, VGint aCount, VGfloat * aValues)
	{
	VGint vSize = GetParameterVectorSize(aVgContext, aParamType);
	if (vSize > 0)
		{
		if (aCount == 1)
			{
			*aValues = GetParameterf(aVgContext, aParamType);
			return;
			}
		else if ( (aCount > 0) && (aCount <= vSize) )
			{
			return HostVgGetParameterfv(aVgContext, aParamType, aCount, aValues);
			}

		// invalid aCount
		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
		}
	return;
	}


void CVgHandleBase::GetParameteriv(MVgContext& aVgContext, VGint aParamType, VGint aCount, VGint * aValues)
	{
	VGint vSize = GetParameterVectorSize(aVgContext, aParamType);
	if (vSize > 0)
		{
		if (aCount == 1)
			{
			*aValues = GetParameteri(aVgContext, aParamType);
			return;
			}
		else if ( (aCount > 0) && (aCount <= vSize) )
			{
			return HostVgGetParameteriv(aVgContext, aParamType, aCount, aValues);
			}

		// invalid aCount
		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
		}
	return;
	}


// Base versions of SetParameter* assume any parameters are read-only, and give an error return
void CVgHandleBase::SetParameterf(MVgContext& aVgContext, VGint, VGfloat)
	{
	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
	}


void CVgHandleBase::SetParameteri(MVgContext& aVgContext, VGint, VGint)
	{
	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
	}


void CVgHandleBase::SetParameterfv(MVgContext& aVgContext, VGint, VGint, const VGfloat *)
	{
	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
	}


void CVgHandleBase::SetParameteriv(MVgContext& aVgContext, VGint, VGint, const VGint *)
	{
	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
	}


// end of file vghandle.cpp