// 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:
// Implementation of OpenVGU stub functions

#include "vghwutils.h"

#define __VG_OPENVG_H_
#include <VG/1.1/openvg.h>

#include "openvgrfc.h"

class RemoteFunctionCall;

// tracing
#ifdef _DEBUG
	#include <e32debug.h>
    #define OPENVGU_TRACE(fmt, args...) RDebug::Printf(fmt, ##args)
#else
    #define OPENVGU_TRACE(fmt, args...)
#endif


extern "C" {
/*
 Note: Comments at the start of each Open VG api are adapted from the Open VG 1.1 specification.
 The text has been chosen/adapted to give a helpful overview of the function, and the errors
 that it may generate.  For more details and diagrams see the full Open VG specification.
 */


/*
 Append a line segment to a path.

 ERRORS
   VGU_BAD_HANDLE_ERROR
   – if path is not a valid path handle, or is not shared with the current context
   VGU_PATH_CAPABILITY_ERROR
   – if VG_PATH_CAPABILITY_APPEND_TO is not enabled for path
 */
EXPORT_C VGUErrorCode
     vguLine(VGPath path,
        VGfloat x0, VGfloat y0,
        VGfloat x1, VGfloat y1)
    {
	OPENVGU_TRACE("vguLine path=%d x0=0x%x, y0=0x%x, x1=0x%x, y1=0x%x", path, x0, y0, x1, y1);

	MVgContext* vgContext = CVghwUtils::VgContext();
	VGUErrorCode error = VGU_OUT_OF_MEMORY_ERROR;  // nearest VGU has to an Invalid Context error
	if (vgContext)
		{
		RemoteFunctionCallData rfcdata; OpenVgRFC vguApiData(rfcdata);
		vguApiData.Init(OpenVgRFC::EvguLine);
		vguApiData.AppendParam(path);
		vguApiData.AppendParam(x0);
		vguApiData.AppendParam(y0);
		vguApiData.AppendParam(x1);
		vguApiData.AppendParam(y1);
		// TODO return type specific functions for VGU operations
		vgContext->ExecuteVgCommand(vguApiData);
		error = (VGUErrorCode)vguApiData.ReturnValue();
		}
	return error;
    }

/*
 Append a polyline (connected sequence of line segments) or polygon to a path.

 ERRORS
   VGU_BAD_HANDLE_ERROR
   – if path is not a valid path handle, or is not shared with the current context
   VGU_PATH_CAPABILITY_ERROR
   – if VG_PATH_CAPABILITY_APPEND_TO is not enabled for path
   VGU_ILLEGAL_ARGUMENT_ERROR
   – if points is NULL
   – if points is not properly aligned
   – if count is less than or equal to 0
 */
EXPORT_C VGUErrorCode
     vguPolygon(VGPath path,
        const VGfloat * points,
        VGint count,
        VGboolean closed)
    {
	OPENVGU_TRACE("vguPolygon path=%d, points=0x%x, count=%d, closed=%d", path, points, count, closed);

	MVgContext* vgContext = CVghwUtils::VgContext();
	VGUErrorCode error = VGU_OUT_OF_MEMORY_ERROR;  // nearest VGU has to an Invalid Context error
	if (vgContext)
		{
		if ( (points == NULL) || (count <= 0) || (3ul & (unsigned)points) )
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else
			{
			RemoteFunctionCallData rfcdata; OpenVgRFC vguApiData(rfcdata);
			vguApiData.Init(OpenVgRFC::EvguPolygon);
			vguApiData.AppendParam(path);
			vguApiData.AppendParam(count);
			vguApiData.AppendParam(closed);
			vguApiData.AppendVector(points, count * 2);

			vgContext->ExecuteVgCommand(vguApiData);
			error = (VGUErrorCode)vguApiData.ReturnValue();
			}
		}
	return error;
    }

/*
 Append an axis-aligned rectangle with its lower-left corner at (x, y) and
 a given width and height to a path.

 ERRORS
   VGU_BAD_HANDLE_ERROR
   – if path is not a valid path handle, or is not shared with the current context
   VGU_PATH_CAPABILITY_ERROR
   – if VG_PATH_CAPABILITY_APPEND_TO is not enabled for path
   VGU_ILLEGAL_ARGUMENT_ERROR
   – if width or height are less than or equal to 0
 */
EXPORT_C VGUErrorCode
     vguRect(VGPath path,
        VGfloat x, VGfloat y,
        VGfloat width, VGfloat height)
    {
	OPENVGU_TRACE("vguRect path=%d, x=0x%x, y=0x%x, width=0x%x, height=0x%x", path, x, y, width, height);

	MVgContext* vgContext = CVghwUtils::VgContext();
	VGUErrorCode error = VGU_OUT_OF_MEMORY_ERROR;  // nearest VGU has to an Invalid Context error
	if (vgContext)
		{
		if ( (width <= 0) || (height <= 0) )
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else
			{
			RemoteFunctionCallData rfcdata; OpenVgRFC vguApiData(rfcdata);
			vguApiData.Init(OpenVgRFC::EvguRect);
			vguApiData.AppendParam(path);
			vguApiData.AppendParam(x);
			vguApiData.AppendParam(y);
			vguApiData.AppendParam(width);
			vguApiData.AppendParam(height);

			vgContext->ExecuteVgCommand(vguApiData);
			error = (VGUErrorCode)vguApiData.ReturnValue();
			}
		}
	return error;
    }

/*
 Append an axis-aligned round-cornered rectangle with the lower-left corner of
 its rectangular bounding box at (x, y) and a given width, height, arcWidth,
 and arcHeight to a path.

 ERRORS
   VGU_BAD_HANDLE_ERROR
   – if path is not a valid path handle, or is not shared with the current context
   VGU_PATH_CAPABILITY_ERROR
   – if VG_PATH_CAPABILITY_APPEND_TO is not enabled for path
   VGU_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
 */
EXPORT_C VGUErrorCode
     vguRoundRect(VGPath path,
        VGfloat x, VGfloat y,
        VGfloat width,
        VGfloat height,
        VGfloat arcWidth,
        VGfloat arcHeight)
    {
	OPENVGU_TRACE("vguRoundRect path=%d, x=0x%x, y=0x%x, width=0x%x, height=0x%x, arcWidth=0x%x, arcHeight=0x%x",
			path, x, y, width, height, arcWidth, arcHeight);

	MVgContext* vgContext = CVghwUtils::VgContext();
	VGUErrorCode error = VGU_OUT_OF_MEMORY_ERROR;  // nearest VGU has to an Invalid Context error
	if (vgContext)
		{
		if ( (width <= 0) || (height <= 0) )
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else
			{
			RemoteFunctionCallData rfcdata; OpenVgRFC vguApiData(rfcdata);
			vguApiData.Init(OpenVgRFC::EvguRoundRect);
			vguApiData.AppendParam(path);
			vguApiData.AppendParam(x);
			vguApiData.AppendParam(y);
			vguApiData.AppendParam(width);
			vguApiData.AppendParam(height);
			vguApiData.AppendParam(arcWidth);
			vguApiData.AppendParam(arcHeight);

			vgContext->ExecuteVgCommand(vguApiData);
			error = (VGUErrorCode)vguApiData.ReturnValue();
			}
		}
	return error;
    }

/*
 Append an axis-aligned ellipse to a path. The center of the ellipse is given by
 (cx, cy) and the dimensions of the axis-aligned rectangle enclosing the ellipse are
 given by width and height. The ellipse begins at (cx + width/2, cy) and is stroked
 as two equal counter-clockwise arcs.

 ERRORS
   VGU_BAD_HANDLE_ERROR
   – if path is not a valid path handle, or is not shared with the current context
   VGU_PATH_CAPABILITY_ERROR
   – if VG_PATH_CAPABILITY_APPEND_TO is not enabled for path
   VGU_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
 */
EXPORT_C VGUErrorCode
     vguEllipse(VGPath path,
        VGfloat cx, VGfloat cy,
        VGfloat width,
        VGfloat height)
    {
	OPENVGU_TRACE("vguEllipse path=%d, cx=0x%x, cy=0x%x, width=0x%x, height=0x%x", path, cx, cy, width, height);

	MVgContext* vgContext = CVghwUtils::VgContext();
	VGUErrorCode error = VGU_OUT_OF_MEMORY_ERROR;  // nearest VGU has to an Invalid Context error
	if (vgContext)
		{
		if ( (width <= 0) || (height <= 0) )
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else
			{
			RemoteFunctionCallData rfcdata; OpenVgRFC vguApiData(rfcdata);
			vguApiData.Init(OpenVgRFC::EvguEllipse);
			vguApiData.AppendParam(path);
			vguApiData.AppendParam(cx);
			vguApiData.AppendParam(cy);
			vguApiData.AppendParam(width);
			vguApiData.AppendParam(height);

			vgContext->ExecuteVgCommand(vguApiData);
			error = (VGUErrorCode)vguApiData.ReturnValue();
			}
		}
	return error;
    }

/*
 Append an elliptical arc to a path, possibly along with one or two line segments,
 according to the arcType parameter. The startAngle and angleExtent parameters are
 given in degrees, proceeding counter-clockwise from the positive X axis. The arc
 is defined on the unit circle, then scaled by the width and height of the ellipse.

 ERRORS
   VGU_BAD_HANDLE_ERROR
   – if path is not a valid path handle, or is not shared with the current context
   VGU_PATH_CAPABILITY_ERROR
   – if VG_PATH_CAPABILITY_APPEND_TO is not enabled for path
   VGU_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
   – if arcType is not one of the values from the VGUArcType enumeration
 */
EXPORT_C VGUErrorCode
     vguArc(VGPath path,
        VGfloat x, VGfloat y,
        VGfloat width, VGfloat height,
        VGfloat startAngle,
        VGfloat angleExtent,
        VGUArcType arcType)
    {
	OPENVGU_TRACE("vguArc path=%d, x=0x%x, y=0x%x, width=0x%x, height=0x%x, startAngle=0x%x, angleExtent=0x%x, arcType=%d",
			path, x, y, width, height, startAngle, angleExtent, arcType);

	MVgContext* vgContext = CVghwUtils::VgContext();
	VGUErrorCode error = VGU_OUT_OF_MEMORY_ERROR;  // nearest VGU has to an Invalid Context error
	if (vgContext)
		{
		const unsigned int n_posinf = 0x7f800000u;
		const unsigned int n_neginf = 0xff800000u;
		VGfloat posinf = *(VGfloat*)&n_posinf;
		VGfloat neginf = *(VGfloat*)&n_neginf;

		if ( (width <= 0) || (height <= 0) || ( (arcType != VGU_ARC_OPEN) && (arcType == VGU_ARC_CHORD) && (arcType == VGU_ARC_PIE) ) )
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		// Tony TODO review NaN detection; not convinced that this works
		else if ( ((x + x - x) != x) || ((y + y - y) != y) ) /* NaN's */
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else if ( ((startAngle + startAngle - startAngle) != startAngle) || ((angleExtent + angleExtent - angleExtent) != angleExtent) )
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else if ( (startAngle <= neginf) || (startAngle >= posinf) )
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else if ( (angleExtent <= neginf) || (angleExtent >= posinf) )
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else if ( (x <= neginf) || (x >= posinf) ) /*Infinity x */
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else if ( (y <= neginf) || (y >= posinf) ) /*Infinity x */
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else
			{
			RemoteFunctionCallData rfcdata; OpenVgRFC vguApiData(rfcdata);
			vguApiData.Init(OpenVgRFC::EvguArc);
			vguApiData.AppendParam(path);
			vguApiData.AppendParam(x);
			vguApiData.AppendParam(y);
			vguApiData.AppendParam(width);
			vguApiData.AppendParam(height);
			vguApiData.AppendParam(startAngle);
			vguApiData.AppendParam(angleExtent);
			vguApiData.AppendParam(arcType);

			vgContext->ExecuteVgCommand(vguApiData);
			error = (VGUErrorCode)vguApiData.ReturnValue();
			}
		}
	return error;
    }

/*
 Sets the entries of matrix to a projective transformation that maps the point
 (sx0, sy0) to (0, 0); (sx1, sy1) to (1, 0); (sx2, sy2) to (0, 1); and (sx3, sy3)
 to (1, 1). If no non-degenerate matrix satisfies the constraints,
 VGU_BAD_WARP_ERROR is returned and matrix is unchanged.

 ERRORS
   VGU_ILLEGAL_ARGUMENT_ERROR
   – if matrix is NULL
   – if matrix is not properly aligned
   VGU_BAD_WARP_ERROR
   – if no non-degenerate transformation satisfies the constraints
 */
EXPORT_C VGUErrorCode
    vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0,
        VGfloat sx1, VGfloat sy1,
        VGfloat sx2, VGfloat sy2,
        VGfloat sx3, VGfloat sy3,
        VGfloat * matrix)
    {
	OPENVGU_TRACE("vguComputeWarpQuadToSquare sx0=0x%x, sy0=0x%x, sx1=0x%x, sy1=0x%x, sx2=0x%x, sy2=0x%x, sx3=0x%x, sy3=0x%x, matrix=0x%x",
			sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3, matrix);

	MVgContext* vgContext = CVghwUtils::VgContext();
	VGUErrorCode error = VGU_OUT_OF_MEMORY_ERROR;  // nearest VGU has to an Invalid Context error
	if (vgContext)
		{
		if ( (matrix == NULL) || (3ul & (unsigned)matrix))
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else
			{
			RemoteFunctionCallData rfcdata; OpenVgRFC vguApiData( rfcdata );
			vguApiData.Init(OpenVgRFC::EvguComputeWarpQuadToSquare);
			vguApiData.AppendParam(sx0);
			vguApiData.AppendParam(sy0);
			vguApiData.AppendParam(sx1);
			vguApiData.AppendParam(sy1);
			vguApiData.AppendParam(sx2);
			vguApiData.AppendParam(sy2);
			vguApiData.AppendParam(sx3);
			vguApiData.AppendParam(sy3);
			vguApiData.AppendVector(matrix, 9, RemoteFunctionCallData::EOut);

			vgContext->ExecuteVgCommand(vguApiData);
			error = (VGUErrorCode)vguApiData.ReturnValue();
			}
		}
	return error;
    }

/*
 Sets the entries of matrix to a projective transformation that maps the point
 (0, 0) to (dx0, dy0); (1, 0) to (dx1, dy1); (0, 1) to (dx2, dy2); and (1, 1) to
 (dx3, dy3). If no non-degenerate matrix satisfies the constraints, VGU_BAD_WARP_ERROR
 is returned and matrix is unchanged.

 ERRORS
   VGU_ILLEGAL_ARGUMENT_ERROR
   – if matrix is NULL
   – if matrix is not properly aligned
   VGU_BAD_WARP_ERROR
   – if no non-degenerate transformation satisfies the constraints
 */
EXPORT_C VGUErrorCode
    vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0,
        VGfloat dx1, VGfloat dy1,
        VGfloat dx2, VGfloat dy2,
        VGfloat dx3, VGfloat dy3,
        VGfloat * matrix)
    {
	OPENVGU_TRACE("vguComputeWarpSquareToQuad dx0=0x%x, dy0=0x%x, dx1=0x%x, dy1=0x%x, dx2=0x%x, dy2=0x%x, dx3=0x%x, dy3=0x%x, matrix=0x%x",
			dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3, matrix);

	MVgContext* vgContext = CVghwUtils::VgContext();
	VGUErrorCode error = VGU_OUT_OF_MEMORY_ERROR;  // nearest VGU has to an Invalid Context error
	if (vgContext)
		{
		if ( (matrix == NULL) || (3ul & (unsigned)matrix))
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else
			{
			RemoteFunctionCallData rfcdata; OpenVgRFC vguApiData(rfcdata);
			vguApiData.Init(OpenVgRFC::EvguComputeWarpSquareToQuad);
			vguApiData.AppendParam(dx0);
			vguApiData.AppendParam(dy0);
			vguApiData.AppendParam(dx1);
			vguApiData.AppendParam(dy1);
			vguApiData.AppendParam(dx2);
			vguApiData.AppendParam(dy2);
			vguApiData.AppendParam(dx3);
			vguApiData.AppendParam(dy3);
			vguApiData.AppendVector(matrix, 9, RemoteFunctionCallData::EOut);

			vgContext->ExecuteVgCommand(vguApiData);
			error = (VGUErrorCode)vguApiData.ReturnValue();
			}
		}
    return error;
    }

/*
 Sets the entries of matrix to a projective transformation that maps the point
 (sx0, sy0) to (dx0, dy0); (sx1, sy1) to (dx1, dy1); (sx2, sy2) to (dx2, dy2);
 and (sx3, sy3) to (dx3, dy3). If no non-degenerate matrix satisfies the constraints,
 VGU_BAD_WARP_ERROR is returned and matrix is unchanged.

 ERRORS
   VGU_ILLEGAL_ARGUMENT_ERROR
   – if matrix is NULL
   – if matrix is not properly aligned
   VGU_BAD_WARP_ERROR
   – if no non-degenerate transformation satisfies the constraints
 */
EXPORT_C VGUErrorCode
    vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0,
        VGfloat dx1, VGfloat dy1,
        VGfloat dx2, VGfloat dy2,
        VGfloat dx3, VGfloat dy3,
        VGfloat sx0, VGfloat sy0,
        VGfloat sx1, VGfloat sy1,
        VGfloat sx2, VGfloat sy2,
        VGfloat sx3, VGfloat sy3,
        VGfloat * matrix)
    {
	OPENVGU_TRACE("vguComputeWarpQuadToQuad");
	MVgContext* vgContext = CVghwUtils::VgContext();

	VGUErrorCode error = VGU_OUT_OF_MEMORY_ERROR;  // nearest VGU has to an Invalid Context error
	if (vgContext)
		{
		if ( (matrix == NULL) || (3ul & (unsigned)matrix))
			{
			error = VGU_ILLEGAL_ARGUMENT_ERROR;
			}
		else
			{
			RemoteFunctionCallData rfcdata; OpenVgRFC vguApiData(rfcdata);
			vguApiData.Init(OpenVgRFC::EvguComputeWarpQuadToQuad);
			vguApiData.AppendParam(dx0);
			vguApiData.AppendParam(dy0);
			vguApiData.AppendParam(dx1);
			vguApiData.AppendParam(dy1);
			vguApiData.AppendParam(dx2);
			vguApiData.AppendParam(dy2);
			vguApiData.AppendParam(dx3);
			vguApiData.AppendParam(dy3);
			vguApiData.AppendParam(sx0);
			vguApiData.AppendParam(sy0);
			vguApiData.AppendParam(sx1);
			vguApiData.AppendParam(sy1);
			vguApiData.AppendParam(sx2);
			vguApiData.AppendParam(sy2);
			vguApiData.AppendParam(sx3);
			vguApiData.AppendParam(sy3);
			vguApiData.AppendVector(matrix, 9, RemoteFunctionCallData::EOut);

			vgContext->ExecuteVgCommand(vguApiData);
			error = (VGUErrorCode)vguApiData.ReturnValue();
			}
		}
	return error;
    }

} /* extern "C" */