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

// OpenVG C API for Symbian DLL

#include "vgstate.h"

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

 (other than VG_NO_CONTEXT_ERROR) that it may generate.  For more details and diagrams see the

 full Open VG specification.

 */

/*

 The vgGetParameter functions return the value of a parameter on a given VGHandlebased

 object.

 The original value passed to vgSetParameter (provided the call to

 vgSetParameter completed without error) should be returned by

 vgGetParameter (except where specifically noted), even if the implementation

 makes use of a truncated or quantized value internally.

 ERRORS

   VG_BAD_HANDLE_ERROR

   – if object is not a valid handle, or is not shared with the current context

   VG_ILLEGAL_ARGUMENT_ERROR

   – if paramType is not a valid value from the appropriate enumeration

   – if paramType refers to a vector parameter in vgGetParameterf or

     vgGetParameteri

 */

EXPORT_C VGint

	vgGetParameteri(VGHandle object,

		VGint paramType)

	{

	OPENVG_TRACE("vgGetParameteri object=0x%x, paramType=0x%x -->", object, paramType);

	VGint value = TGuestOpenVg::vgGetParameteri(object, paramType);

	OPENVG_TRACE("vgGetParameteri value=0x%x <--", value);

	return value;

	}

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

//Functions returning value

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

/*

 Returns the oldest error code provided by an API call on the current context since the

 previous  call to vgGetError on that context (or since the creation of the context). No

 error is indicated by a return value of 0 (VG_NO_ERROR). After the call, the error code is

 cleared to 0. The possible errors that may be generated by each OpenVG function (apart from

 VG_OUT_OF_MEMORY_ERROR) are shown below the definition of the function.

 If no context is current at the time vgGetError is called, the error code

 VG_NO_CONTEXT_ERROR is returned. Pending error codes on existing contexts are not affected

 by the call.

 */

EXPORT_C VGErrorCode

	vgGetError(void)

	{

	OPENVG_TRACE("vgGetError");

	MVgContext* vgContext = CVghwUtils::VgContext();

	VGErrorCode error = VG_NO_CONTEXT_ERROR;

	if (vgContext)

		{ // thread state already exists - get client or Host VG error

		error = vgContext->VgError();

		}

	return error;

	}

/*

 Returns the paint object currently set for the given paintMode, or VG_INVALID_HANDLE

 if an error occurs or if no paint object is set (i.e., the default paint is present) on

 the given context with the given paintMode.

 ERRORS

   VG_ILLEGAL_ARGUMENT_ERROR

   – if paintMode is not a valid value from the VGPaintMode enumeration

 */

EXPORT_C VGPaint

	vgGetPaint(VGPaintMode paintMode)

	{

	OPENVG_TRACE("vgGetPaint paintMode=0x%x -->", paintMode);

	VGPaint paintHandle = TGuestOpenVg::vgGetPaint(paintMode);

	OPENVG_TRACE("vgGetPaint handle=0x%x <--", paintHandle);

	return paintHandle;

	}

/*

 Creates a new paint object that is initialized to a set of default values and returns

 a VGPaint handle to it. If insufficient memory is available to allocate a new object,

 VG_INVALID_HANDLE is returned.

 */

EXPORT_C VGPaint

	vgCreatePaint(void)

	{

	OPENVG_TRACE("vgCreatePaint -->");

	VGPaint paintHandle = TGuestOpenVg::vgCreatePaint();

	OPENVG_TRACE("vgCreatePaint handle=0x%x <--", paintHandle);

	return paintHandle;

	}

/*

 Appends a path, defined by interpolation (or extrapolation) between the paths

 startPath and endPath by the given amount, to the path dstPath. It returns

 VG_TRUE if interpolation was successful (i.e., the paths had compatible segment

 types after normalization), and VG_FALSE otherwise. If interpolation is

 unsuccessful, dstPath is left unchanged. It is legal for dstPath to be a handle

 to the same path object as either startPath or endPath or both, in which case

 the contents of the source path or paths referenced by dstPath will have the

 interpolated path appended. If dstPath is not the a handle to the same path

 object as either startPath or endPath, the contents of startPath and endPath

 will not be affected by the call.

 ERRORS

   VG_BAD_HANDLE_ERROR

   – if any of dstPath, startPath, or endPath is not a valid path handle, or is

     not shared with the current context

   VG_PATH_CAPABILITY_ERROR

   – if VG_PATH_CAPABILITY_INTERPOLATE_TO is not enabled for dstPath

   – if VG_PATH_CAPABILITY_INTERPOLATE_FROM is not enabled for startPath or endPath

 */

EXPORT_C VGboolean

	vgInterpolatePath(VGPath dstPath,

		VGPath startPath,

		VGPath endPath,

		VGfloat amount)

	{

	OPENVG_TRACE("vgInterpolatePath dstPath=0x%x, startPath=0x%x, endPath=0x%x, amount=%f",

			dstPath, startPath, endPath, amount);

	return TGuestOpenVg::vgInterpolatePath(dstPath, startPath, endPath, amount);

	}

/*

 Returns the length of a given portion of a path in the user coordinate system

 (that is, in the path’s own coordinate system, disregarding any matrix

 settings). Only the subpath consisting of the numSegments path segments beginning

 with startSegment (where the initial path segment has index 0) is used. If an

 error occurs, -1.0f is returned.

 ERRORS

   VG_BAD_HANDLE_ERROR

   – if path is not a valid path handle, or is not shared with the current context

   VG_PATH_CAPABILITY_ERROR

   – if VG_PATH_CAPABILITY_PATH_LENGTH is not enabled for path

   VG_ILLEGAL_ARGUMENT_ERROR

   – if startSegment is less than 0 or greater than the index of the final path

     segment

   – if numSegments is less than or equal to 0

   – if (startSegment + numSegments – 1) is greater than the index of the final

     path segment

 */

EXPORT_C VGfloat

	vgPathLength(VGPath path,

		VGint startSegment,

		VGint numSegments)

	{

	OPENVG_TRACE("vgPathLength path=0x%x, startSegment=%d, numSegments=%d", path, startSegment, numSegments);

	return TGuestOpenVg::vgPathLength(path, startSegment, numSegments);

	}

/*

 Returns the current capabilities of the path, as a bitwise OR of

 VGPathCapabilities constants. If an error occurs, 0 is returned.

 ERRORS

   VG_BAD_HANDLE_ERROR

   – if path is not a valid path handle, or is not shared with the current context

 */

EXPORT_C VGbitfield

	vgGetPathCapabilities(VGPath path)

	{

	OPENVG_TRACE("vgGetPathCapabilities path=0x%x", path);

	return TGuestOpenVg::vgGetPathCapabilities(path);

	}

/*

 Create a new path that is ready to accept segment data and return a VGPath handle

 to it. The path data will be formatted in the format given by pathFormat, typically

 VG_PATH_FORMAT_STANDARD. The datatype parameter contains a value from the

 VGPathDatatype enumeration indicating the datatype that will be used for coordinate

 data. The capabilities argument is a bitwise OR of the desired VGPathCapabilities

 values. Bits of capabilities that do not correspond to values from VGPathCapabilities

 have no effect.

 If an error occurs, VG_INVALID_HANDLE is returned.

 ERRORS

   VG_UNSUPPORTED_PATH_FORMAT_ERROR

   – if pathFormat is not a supported format

   VG_ILLEGAL_ARGUMENT_ERROR

   – if datatype is not a valid value from the VGPathDatatype enumeration

   – if scale is equal to 0

 */

EXPORT_C VGPath

	vgCreatePath(VGint pathFormat,

		VGPathDatatype datatype,

		VGfloat scale, VGfloat bias,

		VGint segmentCapacityHint,

		VGint coordCapacityHint,

		VGbitfield capabilities)

	{

	OPENVG_TRACE("vgCreatePath pathFormat=%d, datatype=0x%x, scale=%f, bias=%f, segCapHint=%d, coordCapHint=%d, caps=0x%x -->",

			pathFormat, datatype, scale, bias, segmentCapacityHint, coordCapacityHint, capabilities);

	VGPath pathHandle = TGuestOpenVg::vgCreatePath(pathFormat, datatype, scale, bias, segmentCapacityHint, coordCapacityHint, capabilities);

	OPENVG_TRACE("vgCreatePath handle=0x%x <--", pathHandle);

	return pathHandle;

	}

/*

 The vgGet functions return the value of a parameter on the current context.

 The original value passed to vgSet (except as specifically noted, and provided the call to

 vgSet completed without error) is returned by vgGet, even if the implementation makes

 use of a truncated or quantized value internally. This rule ensures that OpenVG state may

 be saved and restored without degradation.

 If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value

 is undefined.

 ERRORS

   VG_ILLEGAL_ARGUMENT_ERROR

   – if paramType is not a valid value from the VGParamType enumeration

   – if paramType refers to a vector parameter in vgGetf or vgGeti

 */

EXPORT_C VGfloat

	vgGetf(VGParamType type)

	{

	OPENVG_TRACE("vgGetf type=0x%x", type);

	return TGuestOpenVg::vgGetf(type);

	}

/*

 The vgGet functions return the value of a parameter on the current context.

 The original value passed to vgSet (except as specifically noted, and provided the call to

 vgSet completed without error) is returned by vgGet, even if the implementation makes

 use of a truncated or quantized value internally. This rule ensures that OpenVG state may

 be saved and restored without degradation.

 If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value

 is undefined.

 ERRORS

   VG_ILLEGAL_ARGUMENT_ERROR

   – if paramType is not a valid value from the VGParamType enumeration

   – if paramType refers to a vector parameter in vgGetf or vgGeti

 */

EXPORT_C VGint

	vgGeti(VGParamType type)

	{

	OPENVG_TRACE("vgGeti type=0x%x", type);

	return TGuestOpenVg::vgGeti(type);

	}

/*

 The vgGetVectorSize function returns the maximum number of elements in the vector

 that will be retrieved by the vgGetiv or vgGetfv functions if called with the given

 paramType argument. For scalar values, 1 is returned. If vgGetiv or vgGetfv is

 called with a smaller value for count than that returned by vgGetVectorSize,

 only the first count elements of the vector are retrieved. Use of a greater value

 for count will result in an error.

 The original value passed to vgSet (except as specifically noted, and provided the call to

 vgSet completed without error) is returned by vgGet, even if the implementation makes

 use of a truncated or quantized value internally. This rule ensures that OpenVG state may

 be saved and restored without degradation.

 If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value

 is undefined.

 ERRORS

   VG_ILLEGAL_ARGUMENT_ERROR

   – if paramType is not a valid value from the VGParamType enumeration

 */

EXPORT_C VGint

	vgGetVectorSize(VGParamType type)

	{

	OPENVG_TRACE("vgGetVectorSize type=0x%x", type);

	return TGuestOpenVg::vgGetVectorSize(type);

	}

/*

 The vgGetParameter functions return the value of a parameter on a given VGHandlebased

 object.

 The original value passed to vgSetParameter (provided the call to

 vgSetParameter completed without error) should be returned by

 vgGetParameter (except where specifically noted), even if the implementation

 makes use of a truncated or quantized value internally.

 ERRORS

   VG_BAD_HANDLE_ERROR

   – if object is not a valid handle, or is not shared with the current context

   VG_ILLEGAL_ARGUMENT_ERROR

   – if paramType is not a valid value from the appropriate enumeration

   – if paramType refers to a vector parameter in vgGetParameterf or

     vgGetParameteri

 */

EXPORT_C VGfloat

	vgGetParameterf(VGHandle object,

		VGint paramType)

	{

	OPENVG_TRACE("vgGetParameterf object=0x%x, paramType=0x%x -->", object, paramType);

	VGfloat value = TGuestOpenVg::vgGetParameterf(object, paramType);

	OPENVG_TRACE("vgGetParameterf value=%f <--", value);

	return value;

	}

/*

 The vgGetParameterVectorSize function returns the number of elements in the vector

 that will be returned by the vgGetParameteriv or vgGetParameterfv functions if called

 with the given paramType argument. For scalar values, 1 is returned.

 ERRORS

   VG_BAD_HANDLE_ERROR

   – if object is not a valid handle, or is not shared with the current context

   VG_ILLEGAL_ARGUMENT_ERROR

   – if paramType is not a valid value from the appropriate enumeration

 */

EXPORT_C VGint

	vgGetParameterVectorSize(VGHandle object,

		VGint paramType)

	{

	OPENVG_TRACE("vgGetParameterVectorSize object=0x%x, paramType=0x%x -->", object, paramType);

	VGint size = TGuestOpenVg::vgGetParameterVectorSize(object, paramType);

	OPENVG_TRACE("vgGetParameterVectorSize size=%i <--", size);

	return size;

	}

/*

 Creates an object capable of storing a mask layer with the given width and

 height and returns a VGMaskLayer handle to it. The mask layer is defined to

 be compatible with the format and multisampling properties of the current

 drawing surface. If there is no current drawing surface, no mask is

 configured for the current drawing surface, or an error occurs,

 VG_INVALID_HANDLE is returned. All mask layer values are initially set to one.

  ERRORS

   VG_ILLEGAL_ARGUMENT_ERROR

   – if width or height are less than or equal to 0

   – if width is greater than VG_MAX_IMAGE_WIDTH

   – if height is greater than VG_MAX_IMAGE_HEIGHT

   – if width*height is greater than VG_MAX_IMAGE_PIXELS

 */

EXPORT_C VGMaskLayer

	vgCreateMaskLayer(VGint width, VGint height)

	{

	OPENVG_TRACE("vgCreateMaskLayer width=%d, height=%d -->", width, height);

	VGMaskLayer maskHandle = TGuestOpenVg::vgCreateMaskLayer(width, height);

	OPENVG_TRACE("vgCreateMaskLayer handle=0x%x <--", maskHandle);

	return maskHandle;

	}

/*

 The current setting of the VG_PAINT_COLOR parameter on a given paint object may

 be queried as a 32-bit non-premultiplied sRGBA_8888 value. Each color channel or

 alpha value is clamped to the range [0, 1] , multiplied by 255, and rounded to obtain an

 8-bit integer; the resulting values are packed into a 32-bit value in the same format as for

 vgSetColor.

 ERRORS

   VG_BAD_HANDLE_ERROR

   – if paint is not a valid paint handle, or is not shared with the current context

 */

EXPORT_C VGuint

	vgGetColor(VGPaint paint)

	{

	OPENVG_TRACE("vgGetColor paint=0x%x", paint);

	return TGuestOpenVg::vgGetColor(paint);

	}

/*

 Creates an image with the given width, height, and pixel format and returns a

 VGImage handle to it. If an error occurs, VG_INVALID_HANDLE is returned. All

 color and alpha channel values are initially set to zero. The format parameter

 must contain a value from the VGImageFormat enumeration.

 The allowedQuality parameter is a bitwise OR of values from the

 VGImageQuality enumeration, indicating which levels of resampling quality may be

 used to draw the image. It is always possible to draw an image using the

 VG_IMAGE_QUALITY_NONANTIALIASED quality setting even if it is not explicitly

 specified.

 ERRORS

   VG_UNSUPPORTED_IMAGE_FORMAT_ERROR

   – if format is not a valid value from the VGImageFormat enumeration

   VG_ILLEGAL_ARGUMENT_ERROR

   – if width or height are less than or equal to 0

   – if width is greater than VG_MAX_IMAGE_WIDTH

   – if height is greater than VG_MAX_IMAGE_HEIGHT

   – if width*height is greater than VG_MAX_IMAGE_PIXELS

   – if width*height*(pixel size of format) is greater than

   VG_MAX_IMAGE_BYTES

   – if allowedQuality is not a bitwise OR of values from the

     VGImageQuality enumeration

 */

EXPORT_C VGImage

	vgCreateImage(VGImageFormat format,

		VGint width, VGint height,

		VGbitfield allowedQuality)

	{

	OPENVG_TRACE("vgCreateImage format=0x%x, width=%d, height=%d, allowedQuality=0x%x -->",

			format, width, height, allowedQuality);

	VGImage imageHandle = TGuestOpenVg::vgCreateImage(format, width, height, allowedQuality);

	OPENVG_TRACE("vgCreateImage handle=0x%x <--", imageHandle);

	return imageHandle;

	}

/*

 Returns a new VGImage handle that refers to a portion of the parent image. The

 region is given by the intersection of the bounds of the parent image with the

 rectangle beginning at pixel (x, y) with dimensions width and height, which

 must define a positive region contained entirely within parent.

 ERRORS

   VG_BAD_HANDLE_ERROR

   – if parent is not a valid image handle, or is not shared with the current

     context

   VG_IMAGE_IN_USE_ERROR

   – if parent is currently a rendering target

   VG_ILLEGAL_ARGUMENT_ERROR

   – if x is less than 0 or greater than or equal to the parent width

   – if y is less than 0 or greater than or equal to the parent height

   – if width or height is less than or equal to 0

   – if x + width is greater than the parent width

   – if y + height is greater than the parent height

 */

EXPORT_C VGImage

	vgChildImage(VGImage parent,

		VGint x, VGint y,

		VGint width, VGint height)

	{

	OPENVG_TRACE("vgChildImage parent=oc%x, x=%d, y=%d, width=%d, height=%d -->",

			parent, x, y, width, height);

	VGImage imageHandle = TGuestOpenVg::vgChildImage(parent, x, y, width, height);

	OPENVG_TRACE("vgChildImage handle=0x%x <--", imageHandle);

	return imageHandle;

	}

/*

 Returns the closest valid ancestor (i.e., one that has not been the target of

 a vgDestroyImage call) of the given image. If image has no ancestors, image is

 returned.

 ERRORS

   VG_BAD_HANDLE_ERROR

   – if image is not a valid image handle, or is not shared with the current

     context

   VG_IMAGE_IN_USE_ERROR

   – if image is currently a rendering target

 */

EXPORT_C VGImage vgGetParent(VGImage image)

	{

	OPENVG_TRACE("vgGetParent image=0x%x", image);

	return TGuestOpenVg::vgGetParent(image);

	}

/*

 Creates a new font object and returns a VGFont handle to it. The glyphCapacityHint

 argument provides a hint as to the capacity of a VGFont, i.e., the total number of

 glyphs that this VGFont object will be required to accept. A value of 0 indicates that

 the value is unknown. If an error occurs during execution, VG_INVALID_HANDLE is returned.

 ERRORS

   VG_ILLEGAL_ARGUMENT_ERROR

   – if glyphCapacityHint is negative

 */

EXPORT_C VGFont vgCreateFont(VGint glyphCapacityHint)

	{

	OPENVG_TRACE("vgCreateFont glyphCapacityHint=%d -->", glyphCapacityHint);

	VGFont fontHandle = TGuestOpenVg::vgCreateFont(glyphCapacityHint);

	OPENVG_TRACE("vgCreateFont handle=0x%x <--", fontHandle);

	return fontHandle;

	}

/* Hardware Queries */

/*

 Returns a value indicating whether a given setting of a property of a type given

 by key is generally accelerated in hardware on the currently running OpenVG

 implementation.

 ERRORS

   VG_ILLEGAL_ARGUMENT_ERROR

   – if key is not one of the values from the VGHardwareQueryType enumeration

   – if setting is not one of the values from the enumeration associated with

     key

 */

EXPORT_C VGHardwareQueryResult

	vgHardwareQuery

		(VGHardwareQueryType key,

		VGint setting)

	{

	OPENVG_TRACE("vgHardwareQuery key=0x%x, setting=%d", key, setting);

	return TGuestOpenVg::vgHardwareQuery(key, setting);

	}

/*

 The vgGetString function returns information about the OpenVG implementation,