// 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,
 including extension information. The values returned may vary according to
 the display (e.g., the EGLDisplay when using EGL) associated with the current
 context.

 Returns NULL if no context is current.
 */
EXPORT_C const VGubyte *
	vgGetString(VGStringID name)
	{
	OPENVG_TRACE("vgGetString name=0x%x", name);

	switch (name)
		{
		case VG_VENDOR:
			return (const VGubyte *)"Nokia";
		case VG_RENDERER:
			return (const VGubyte *)"Guest 1.0";
		case VG_VERSION:
			return (const VGubyte *)"1.1";
		case VG_EXTENSIONS: // supported VG extensions, (associated function addresses are fetched with eglGetProcAddress)
			return (const VGubyte *)"VG_KHR_EGL_image";
		}
	return (const VGubyte *)NULL;
	}

/*
 The vgGetParameter functions return the value of a parameter on a given VGHandlebased
 object.

 If vgGetParameteriv or vgGetParameterfv is called with a smaller value for
 count than that returned by vgGetParameterVectorSize, 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 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 values is NULL in vgGetParameterfv or vgGetParameteriv
   – if values is not properly aligned in vgGetParameterfv or vgGetParameteriv
   – if count is less than or equal to 0 in vgGetParameterfv or vgGetParameteriv
   – if count is greater than the value returned by vgGetParameterVectorSize for
     the given parameter in vgGetParameterfv or vgGetParameteriv
 */
EXPORT_C void
	vgGetParameterfv(VGHandle object,
		VGint paramType,
		VGint count,
		VGfloat * values)
	{
	OPENVG_TRACE("vgGetParameterfv object=0x%x, paramType=0x%x, count=%d, values=0x%x",
			object, paramType, count, values);

	TGuestOpenVg::vgGetParameterfv(object, paramType, count, values);
	}

EXPORT_C void
	vgGetParameteriv(VGHandle object,
		VGint paramType,
		VGint count,
		VGint * values)
	{
	OPENVG_TRACE("vgGetParameteriv object=0x%x, paramType=0x%x, count=%d, values=0x%x",
			object, paramType, count, values);

	TGuestOpenVg::vgGetParameteriv(object, paramType, count, values);
	}

/* Renderer and Extension Information */

/*
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 vgGetfv or vgGetiv, nothing is
written to values.

ERRORS
VG_ILLEGAL_ARGUMENT_ERROR
– if paramType is not a valid value from the VGParamType enumeration
– if values is NULL in vgGetfv or vgGetiv
– if values is not properly aligned in vgGetfv or vgGetiv
– if count is less than or equal to 0 in vgGetfv or vgGetiv
– if count is greater than the value returned by vgGetVectorSize for the
given parameter in vgGetfv or vgGetiv
 */
EXPORT_C void
	vgGetfv(VGParamType type, VGint count,
		VGfloat * values)
	{
	OPENVG_TRACE("vgGetfv type=0x%x, count=%d, values=0x%x", type, count, values);

	TGuestOpenVg::vgGetfv(type, count, values);
	}

EXPORT_C void
	vgGetiv(VGParamType type, VGint count,
		VGint * values)
	{
	OPENVG_TRACE("vgGetiv type=0x%x, count=%d, values=0x%x", type, count, values);

	TGuestOpenVg::vgGetiv(type, count, values);
	}

/*
 Retrieve the value of the current transformation.
 Nine values are written to m in the order:
 { sx, shy, w0, shx, sy, w1, tx, ty, w2 }
 For an affine matrix, w0 and w1 will always be 0 and w2 will always be 1.

 ERRORS
 VG_ILLEGAL_ARGUMENT_ERROR
 – if m is NULL
 – if m is not properly aligned
 */
EXPORT_C void
	vgGetMatrix(VGfloat * m)
	{
	OPENVG_TRACE("vgGetMatrix m=0x%x", m);

	TGuestOpenVg::vgGetMatrix(m);
	}

/*
 Read pixel values from a rectangular portion of an image, performs format conversion
 if necessary, and stores the resulting pixels into memory.

 Pixel values are written starting at the address given by the pointer data; adjacent
 scanlines are separated by dataStride bytes. Negative or zero values of
 dataStride are allowed. The region to be read is given by x, y, width, and
 height, which must define a positive region. Pixels that fall outside the bounds
 of the image are ignored.
 Pixel values in memory are formatted according to the dataFormat parameter, which
 must contain a value from the VGImageFormat enumeration. If dataFormat
 specifies a premultiplied format (VG_sRGBA_8888_PRE or VG_lRGBA_8888_PRE),
 color channel values of a pixel that are greater than their corresponding alpha value are
 clamped to the range [0, alpha]. The data pointer alignment and the pixel layout in
 memory are as described in the vgImageSubData section.

 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
   VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
   – if dataFormat is not a valid value from the VGImageFormat enumeration
   VG_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
   – if data is NULL
   – if data is not properly aligned
 */
EXPORT_C void
	vgGetImageSubData(VGImage image,
		void * data,
		VGint dataStride,
		VGImageFormat dataFormat,
		VGint x, VGint y,
		VGint width, VGint height)
	{
	OPENVG_TRACE("vgGetImageSubData image=0x%x, data=0x%x, dataStride=%d, dataFormat=0x%x, x=%d, y=%d, width=%d, height=%d",
			image, data, dataStride, dataFormat, x, y, width, height);

	TGuestOpenVg::vgGetImageSubData(image, data, dataStride, dataFormat, x, y, width, height);
	}

/*
 Copy pixel data from the drawing surface without the creation of a VGImage object.
 Pixel values are written starting at the address given by the pointer data; adjacent
 scanlines are separated by dataStride bytes. Negative or zero values of
 dataStride are allowed. The region to be read is given by x, y, width, and
 height, which must define a positive region.

 Pixel values in memory are formatted according to the dataFormat parameter, which
 must contain a value from the VGImageFormat enumeration. The data pointer
 alignment and the pixel layout in memory is as described for vgImageSubData.

 Pixels whose source lies outside of the bounds of the drawing surface are
 ignored. Pixel format conversion is applied as needed. The scissoring region
 does not affect the reading of pixels.

 ERRORS
   VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
   – if dataFormat is not a valid value from the VGImageFormat enumeration
   VG_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
   – if data is NULL
   – if data is not properly aligned
 */
EXPORT_C void
	vgReadPixels(void * data, VGint dataStride,
		VGImageFormat dataFormat,
		VGint sx, VGint sy,
		VGint width, VGint height)
	{
	OPENVG_TRACE("vgReadPixels data=0x%x, dataStride=%d, dataFormat=0x%x, sx=%d, sy=%d, width=%d, height=%d",
			data, dataStride, dataFormat, sx, sy, width, height);

	TGuestOpenVg::vgReadPixels(data, dataStride, dataFormat, sx, sy, width, height);
	}

/*
 Returns an axis-aligned bounding box that tightly bounds the interior of the given
 path. Stroking parameters are ignored. If path is empty, minX and minY are set to 0
 and width and height are set to -1. If path contains a single point, minX and minY
 are set to the coordinates of the point and width and height are set to 0.

 The VG_PATH_CAPABILITY_PATH_BOUNDS capability must be enabled for path.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if path is not a valid path handle, or is not shared with the current context
   VG_ILLEGAL_ARGUMENT_ERROR
   – if minX, minY, width, or height is NULL
   – if minX, minY, width, or height is not properly aligned
   VG_PATH_CAPABILITY_ERROR
   – if VG_PATH_CAPABILITY_PATH_BOUNDS is not enabled for path
 */
EXPORT_C void
	vgPathBounds(VGPath path,
		VGfloat * minX,
		VGfloat * minY,
		VGfloat * width,
		VGfloat * height)
	{
	OPENVG_TRACE("vgPathBounds path=0x%x, minX=0x%x, minY=0x%x, width=0x%x, height=0x%x",
			path, minX, minY, width, height);

	TGuestOpenVg::vgPathBounds(path, minX, minY, width, height);
	}

/*
 The vgPathTransformedBounds function returns an axis-aligned bounding box
 that is guaranteed to enclose the geometry of the given path following
 transformation by the current path-user-to-surface transform. The returned
 bounding box is not guaranteed to fit tightly around the path geometry. If path
 is empty, minX and minY are set to 0 and width and height are set to -1. If
 path contains a single point, minX and minY are set to the transformed
 coordinates of the point and width and height are set to 0.
 The VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS capability must be
 enabled for path.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if path is not a valid path handle, or is not shared with the current context
   VG_ILLEGAL_ARGUMENT_ERROR
   – if minX, minY, width, or height is NULL
   – if minX, minY, width, or height is not properly aligned
   VG_PATH_CAPABILITY_ERROR
   – if VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS is not enabled
     for path
 */
EXPORT_C void
	vgPathTransformedBounds(VGPath path,
		VGfloat * minX,
		VGfloat * minY,
		VGfloat * width,
		VGfloat * height)
	{
	OPENVG_TRACE("vgPathTransformedBounds path=0x%x, minX=0x%x, minY=0x%x, width=0x%x, height=0x%x",
					path, minX, minY, width, height);

	TGuestOpenVg::vgPathTransformedBounds(path, minX, minY, width, height);
	}

////////////////////////////////////////////////////////////////////////////////////////////
//Syncing methods
////////////////////////////////////////////////////////////////////////////////////////////

/*
 Ensures that all outstanding requests on the current context will complete in finite time.
 vgFlush may return prior to the actual completion of all requests.
 */
EXPORT_C void
	vgFlush(void)
	{
	// ToDo comment
	OPENVG_TRACE("vgFlush");

	MVgContext* vgContext = CVghwUtils::VgContext();
	if (vgContext)
		{
		vgContext->ExecuteVgFlushCommand();
		}
	}

/*
 The vgFinish function forces all outstanding requests on the current context to
 complete, returning only when the last request has completed.
 */
EXPORT_C void
	vgFinish(void)
	{
	// ToDo comment
	OPENVG_TRACE("vgFinish");

	MVgContext* vgContext = CVghwUtils::VgContext();
	if (vgContext)
		{
		vgContext->ExecuteVgFinishCommand();
		}
	}

////////////////////////////////////////////////////////////////////////////////////////////
//Functions not returning value (possible to buffer)
////////////////////////////////////////////////////////////////////////////////////////////
/* Getters and Setters */

/*
 The vgSet functions set the value of a parameter on the current context.

 ERRORS
   VG_ILLEGAL_ARGUMENT_ERROR
   – if paramType is not a valid value from the VGParamType enumeration
   – if paramType refers to a vector parameter in vgSetf or vgSeti
   – if value is not a legal enumerated value for the given parameter in vgSetf or
     vgSeti
 */
EXPORT_C void
   vgSetf (VGParamType type, VGfloat value)
	{
	OPENVG_TRACE("vgSetf type=0x%x, value=%f", type, value);

	TGuestOpenVg::vgSetf(type, value);
	}

EXPORT_C void
	vgSeti (VGParamType type, VGint value)
	{
	OPENVG_TRACE("vgSeti type=0x%x, value=%d", type, value);

	TGuestOpenVg::vgSeti(type, value);
	}

/*
 The vgSet functions set the value of a parameter on the current context.

 ERRORS
   VG_ILLEGAL_ARGUMENT_ERROR
   – if paramType is not a valid value from the VGParamType enumeration
   – if paramType refers to a scalar parameter in vgSetfv or vgSetiv and count is
     not equal to 1
   – if values[i] is not a legal enumerated value for the given parameter in vgSetfv
     or vgSetiv for 0 <= i < count
   – if values is NULL in vgSetfv or vgSetiv and count is greater than 0
   – if values is not properly aligned in vgSetfv or vgSetiv
   – if count is less than 0 in vgSetfv or vgSetiv
   – if count is not a valid value for the given parameter
 */
EXPORT_C void
	vgSetfv(VGParamType type, VGint count,
		const VGfloat * values)
	{
	OPENVG_TRACE("vgSetfv type=0x%x, count=%d, values=0x%x", type, count, values);

	TGuestOpenVg::vgSetfv(type, count, values);
	}

EXPORT_C void
	vgSetiv(VGParamType type, VGint count,
		const VGint * values)
	{
	OPENVG_TRACE("vgSetiv type=0x%x, count=%d, values=0x%x", type, count, values);

	TGuestOpenVg::vgSetiv(type, count, values);
	}

/*
 For vgSetParameterf and vgSetParameteri.

 The vgSetParameter functions set the value of a parameter on a given VGHandlebased
 object.

 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 vgSetParameterf or
     vgSetParameteri
   – if value is not a legal enumerated value for the given parameter in
     vgSetParameterf or vgSetParameteri
 */
EXPORT_C void
	vgSetParameterf(VGHandle object,
		VGint paramType,
		VGfloat value)
	{
	OPENVG_TRACE("vgSetParameterf object=0x%x, paramType=0x%x, value=%f -->", object, paramType, value);

	TGuestOpenVg::vgSetParameterf(object, paramType, value);
	}

EXPORT_C void
	vgSetParameteri(VGHandle object,
		VGint paramType,
		VGint value)
	{
	OPENVG_TRACE("vgSetParameteri object=0x%x, paramType=0x%x, value=0x%x", object, paramType, value);

	TGuestOpenVg::vgSetParameteri(object, paramType, value);
	}

/*
 For vgSetParameterfv and vgSetParameteriv.

 The vgSetParameter functions set the value of a parameter on a given VGHandlebased
 object.

 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 scalar parameter in vgSetParameterfv or
     vgSetParameteriv and count is not equal to 1
   – if values[i] is not a legal enumerated value for the given parameter
     in vgSetParameterfv or vgSetParameteriv for 0 <= i < count
   – if values is NULL in vgSetParameterfv or vgSetParameteriv and count is
     greater than 0
   – if values is not properly aligned in vgSetParameterfv or vgSetParameteriv
   – if count is less than 0 in vgSetParameterfv or vgSetParameteriv
   – if count is not a valid value for the given parameter
 */
EXPORT_C void
	vgSetParameterfv(VGHandle object,
		VGint paramType,
		VGint count,
		const VGfloat * values)
	{
	OPENVG_TRACE("vgSetParameterfv object=0x%x, paramType=%d, count=%d, values=0x%x", object, paramType, count, values);

	TGuestOpenVg::vgSetParameterfv(object, paramType, count, values);
	}

EXPORT_C void
	vgSetParameteriv(VGHandle object,
		VGint paramType,
		VGint count,
		const VGint * values)
	{
	OPENVG_TRACE("vgSetParameteriv object=0x%x, paramType=%d, count=%d, values=0x%x", object, paramType, count, values);

	TGuestOpenVg::vgSetParameteriv(object, paramType, count, values);
	}

/* Matrix Manipulation */

/*
 Sets the current matrix M to the identity matrix:
 */
EXPORT_C void
	vgLoadIdentity(void)
	{
	OPENVG_TRACE("vgLoadIdentity");

	TGuestOpenVg::vgLoadIdentity();
	}

/*
 Loads an arbitrary set of matrix values into the current
 matrix. Nine matrix values are read from m, in the order:
   { sx, shy, w0, shx, sy, w1, tx, ty, w2 }
 However, if the targeted matrix is affine (i.e., the matrix mode is not
 VG_MATRIX_IMAGE_USER_TO_SURFACE), the values { w0, w1, w2 } are ignored and
 replaced by the values { 0, 0, 1 }.

 ERRORS
   VG_ILLEGAL_ARGUMENT_ERROR
   – if m is NULL
   – if m is not properly aligned
 */
EXPORT_C void
	vgLoadMatrix(const VGfloat * m)
	{
	OPENVG_TRACE("vgLoadMatrix m=0x%x", m);

	TGuestOpenVg::vgLoadMatrix(m);
	}

/*
 Right-multiplies the current matrix M by a given matrix:
   Nine matrix values are read from m in the order:
   { sx, shy, w0, shx, sy, w1, tx, ty, w2 }
 and the current matrix is multiplied by the resulting matrix. However, if the
 targeted matrix is affine (i.e., the matrix mode is not
 VG_MATRIX_IMAGE_USER_TO_SURFACE), the values { w0, w1, w2 } are ignored
 and replaced by the values { 0, 0, 1 } prior to multiplication.

 ERRORS
   VG_ILLEGAL_ARGUMENT_ERROR
   – if m is NULL
   – if m is not properly aligned
 */
EXPORT_C void
	vgMultMatrix(const VGfloat * m)
	{
	OPENVG_TRACE("vgMultMatrix m=0x%x", m);

	TGuestOpenVg::vgMultMatrix(m);
	}

/*
 Modifies the current transformation by appending a  translation. This is equivalent
 to right-multiplying the current matrix M by a translation matrix:
    [ 1  0  tx ]
    [ 0  1  ty ]
    [ 0  0  1  ]
 */
EXPORT_C void
	vgTranslate(VGfloat tx, VGfloat ty)
	{
	OPENVG_TRACE("vgTranslate tx=%f, ty=%f", tx, ty);

	TGuestOpenVg::vgTranslate(tx, ty);
	}

/*
 Modifies the current transformation by appending a scale. This is equivalent to
 right-multiplying the current matrix M by a scale matrix:
    [ sx  0   0 ]
    [ 0   sy  0 ]
    [ 0   0   1 ]
 */
EXPORT_C void
	vgScale(VGfloat sx, VGfloat sy)
	{
	OPENVG_TRACE("vgScale sx=%f, sy=%f", sx, sy);

	TGuestOpenVg::vgScale(sx, sy);
	}

/*
 Modifies the current transformation by appending a shear. This is equivalent to
 right-multiplying the current matrix M by a shear matrix:
   [  1  shx  0 ]
   [ shy  1   0 ]
   [  0   0   1 ]
 */
EXPORT_C void
	vgShear(VGfloat shx, VGfloat shy)
	{
	OPENVG_TRACE("vgShear shx=%f, shy=%f", shx, shy);

	TGuestOpenVg::vgShear(shx, shy);
	}

/*
 Modifies the current transformation by appending a counterclockwise rotation by a given
 angle (expressed in degrees) about the origin. This is equivalent to right-multiplying
 the current matrix M by the following matrix (using the symbol a to represent the value
 of the angle parameter):
   [ cos(a) -sin(a)  0 ]
   [ sin(a)  cos(a)  0 ]
   [  0       0      1 ]
 */
EXPORT_C void
	vgRotate(VGfloat angle)
	{
	OPENVG_TRACE("vgRotate angle=%f");

	TGuestOpenVg::vgRotate(angle);
	}

/*
 Modifies the drawing surface mask values according to a given operation, possibly
 using coverage values taken from a mask layer or bitmap image given by the mask
 parameter. If no mask is configured for the current drawing surface, vgMask has
 no effect.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if operation is not VG_CLEAR_MASK or VG_FILL_MASK, and mask is not a
     valid mask layer or image handle, or is not shared with the current context
   VG_IMAGE_IN_USE_ERROR
   – if mask is a VGImage that is currently a rendering target
   VG_ILLEGAL_ARGUMENT_ERROR
   – if operation is not a valid value from the VGMaskOperation
     enumeration
   – if width or height is less than or equal to 0
   – if mask is a VGMaskLayer and is not compatible with the current surface
     mask
 */
EXPORT_C void
	vgMask(VGHandle mask, VGMaskOperation operation,
		VGint x, VGint y,
		VGint width, VGint height)
	{
	OPENVG_TRACE("vgMask mask=0x%x, operation=0x%x, x=%d, y=%d, width=%d, height=%d",
			mask, operation, x, y, width, height);

	TGuestOpenVg::vgMask(mask, operation, x, y, width, height);
	}

/*
 Modifies the current surface mask by applying the given operation to the set of
 coverage values associated with the rendering of the given path. If paintModes
 contains VG_FILL_PATH, the path is filled; if it contains VG_STROKE_PATH, the path
 is stroked. If both are present, the mask operation is performed in two passes,
 first on the filled path geometry, then on the stroked path geometry.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if path is not a valid path handle
   VG_ILLEGAL_ARGUMENT_ERROR
   – if paintModes is not a valid bitwise OR of values from the VGPaintMode
     enumeration
   – if operation is not a valid value from the VGMaskOperation enumeration
 */
EXPORT_C void
	vgRenderToMask(VGPath path,
		VGbitfield paintModes,
		VGMaskOperation operation)
	{
	OPENVG_TRACE("vgRenderToMask path=0x%x, paintModes=0x%x, operation=0x%x", path, paintModes, operation);

	TGuestOpenVg::vgRenderToMask(path, paintModes, operation);
	}

/*
 Deallocate the resources associated with a mask layer. Following the call,
 the maskLayer handle is no longer valid in the current context.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if maskLayer is not a valid mask handle
 */
EXPORT_C void vgDestroyMaskLayer(VGMaskLayer maskLayer)
	{
	OPENVG_TRACE("vgDestroyMaskLayer maskLayer=0x%x", maskLayer);

	TGuestOpenVg::vgDestroyMaskLayer(maskLayer);
	}

/*
 Set the values of a given maskLayer within a given rectangular region to a given
 value. The floating-point value value must be between 0 and 1. The value is rounded
 to the closest available value supported by the mask layer. If two values are equally
 close, the larger value is used.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if maskLayer is not a valid mask layer handle, or is not shared with the
     current context
   VG_ILLEGAL_ARGUMENT_ERROR
   – if value is less than 0 or greater than 1
   – if width or height is less than or equal to 0
   – if x or y is less than 0
   – if x + width is greater than the width of the mask
   – if y + height is greater than the height of the mask
 */
EXPORT_C void
	vgFillMaskLayer(VGMaskLayer maskLayer,
		VGint x, VGint y,
		VGint width, VGint height,
		VGfloat value)
	{
	OPENVG_TRACE("vgFillMaskLayer maskLayer=0x%x, x=%d, y=%d, width=%d, height=%d, value=%f",
			maskLayer, x, y, width, height, value);

	TGuestOpenVg::vgFillMaskLayer(maskLayer, x, y, width, height, value);
	}

/*
 Copies a portion of the current surface mask into a VGMaskLayer object. The source
 region starts at (sx, sy) in the surface mask, and the destination region starts
 at (dx, dy) in the destination maskLayer. The copied region is clipped to the given
 width and height and the bounds of the source and destination. If the current context
 does not contain a surface mask, vgCopyMask does nothing.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if maskLayer is not a valid mask layer handle
   VG_ILLEGAL_ARGUMENT_ERROR
   – if width or height are less than or equal to 0
   – if maskLayer is not compatible with the current surface mask
 */
EXPORT_C void
	vgCopyMask(VGMaskLayer maskLayer,
		VGint sx, VGint sy,
		VGint dx, VGint dy,
		VGint width, VGint height)
	{
	OPENVG_TRACE("vgCopyMask maskLayer=0x%x, sx=%d, sy=%d, dx=%d, dy=%d, width=%d, height=%d",
			maskLayer, sx, sy, dx, dy, width, height);

	TGuestOpenVg::vgCopyMask(maskLayer, sx, sy, dx, dy, width, height);
	}

/*
 Fills the portion of the drawing surface intersecting the rectangle extending from
 pixel (x, y) and having the given width and height with a constant color value, taken
 from the VG_CLEAR_COLOR parameter. The color value is expressed in non-premultiplied
 sRGBA (sRGB color plus alpha)format. Values outside the [0, 1] range are interpreted
 as the nearest endpoint of the range. The color is converted to the destination color
 space in the same manner as if a rectangular path were being filled. Clipping and
 scissoring take place in the usual fashion, but antialiasing, masking, and blending
 do not occur.

 ERRORS
   VG_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
 */
EXPORT_C void
	vgClear(VGint x, VGint y,
		VGint width, VGint height)
	{
	OPENVG_TRACE("vgClear x=%d, y=%d, width=%d, height=%d", x, y, width, height);

	TGuestOpenVg::vgClear(x, y, width, height);
	}


/* Paths */

/*
 Remove all segment command and coordinate data associated with a path. The handle
 continues to be valid for use in the future, and the path format and datatype retain
 their existing values. 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. Using vgClearPath may be more efficient than
 destroying and re-creating a path for short-lived paths.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if path is not a valid path handle, or is not shared with the current context
 */
EXPORT_C void
	vgClearPath(VGPath path, VGbitfield capabilities)
	{
	OPENVG_TRACE("vgClearPath path=0x%x, capabilities=0x%x", path, capabilities);

	TGuestOpenVg::vgClearPath(path, capabilities);
	}

/*
 Release any resources associated with path, and makes the handle invalid in all
 contexts that shared it.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if path is not a valid path handle, or is not shared with the current context
 */
EXPORT_C void vgDestroyPath(VGPath path)
	{
	OPENVG_TRACE("vgDestroyPath path=0x%x", path);

	TGuestOpenVg::vgDestroyPath(path);
	}

/*
 Requests the set of capabilities specified in the capabilities argument to
 be disabled for the given path. The capabilities argument is a bitwise OR of
 the VGPathCapabilities values whose removal is requested. Attempting to
 remove a capability that is already disabled has no effect. Bits of
 capabilities that do not correspond to values from VGPathCapabilities have
 no effect.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if path is not a valid path handle, or is not shared with the current context
 */
EXPORT_C void
	vgRemovePathCapabilities(VGPath path,
		VGbitfield capabilities)
	{
	OPENVG_TRACE("vgRemovePathCapabilities path=0x%x, capabilities=0x%x", path, capabilities);

	TGuestOpenVg::vgRemovePathCapabilities(path, capabilities);
	}

/*
 Appends a copy of all path segments from srcPath onto the end of the existing
 data in dstPath. It is legal for srcPath and dstPath to be handles to the same
 path object, in which case the contents of the path are duplicated. If srcPath
 and dstPath are handles to distinct path objects, the contents of srcPath will
 not be affected by the call.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if either dstPath or srcPath is not a valid path handle, or is not shared
     with the current context
   VG_PATH_CAPABILITY_ERROR
   – if VG_PATH_CAPABILITY_APPEND_FROM is not enabled for srcPath
   – if VG_PATH_CAPABILITY_APPEND_TO is not enabled for dstPath
 */
EXPORT_C void
	vgAppendPath(VGPath dstPath, VGPath srcPath)
	{
	OPENVG_TRACE("vgAppendPath dstPath=0x%x, srcPath=0x%x", dstPath, srcPath);

	TGuestOpenVg::vgAppendPath(dstPath, srcPath);
	}

/*
 Appends data taken from pathData to the given path dstPath. The data are formatted
 using the path format of dstPath (as returned by querying the path’s VG_PATH_FORMAT
 parameter using vgGetParameteri). The numSegments parameter gives the total number
 of entries in the pathSegments array, and must be greater than 0. Legal values for
 the pathSegments array are the values from the VGPathCommand enumeration as well as
 VG_CLOSE_PATH and (VG_CLOSE_PATH | VG_RELATIVE) (which are synonymous).

 The pathData pointer must be aligned on a 1-, 2-, or 4-byte boundary (as defined in
 the “Bytes” column of Open VG spec Table 7) depending on the size of the coordinate
 datatype (as returned by querying the path’s VG_PATH_DATATYPE parameter using
 vgGetParameteri). The VG_PATH_CAPABILITY_APPEND_TO capability must be enabled for
 path.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if dstPath is not a valid path handle, or is not shared with the current
     context
   VG_PATH_CAPABILITY_ERROR
   – if VG_PATH_CAPABILITY_APPEND_TO is not enabled for dstPath
   VG_ILLEGAL_ARGUMENT_ERROR
   – if pathSegments or pathData is NULL
   – if pathData is not properly aligned
   – if numSegments is less than or equal to 0
   – if pathSegments contains an illegal command
 */
EXPORT_C void
	vgAppendPathData(VGPath dstPath,
		VGint numSegments,
		const VGubyte * pathSegments,
		const void * pathData)
	{
	OPENVG_TRACE("vgAppendPathData dstPath=0x%x, numSegments=%d, pathSegments=0x%x, pathData=0x%x",
			dstPath, numSegments, pathSegments, pathData);

	TGuestOpenVg::vgAppendPathData(dstPath, numSegments, pathSegments, pathData);
	}

/*
 Modifies the coordinate data for a contiguous range of segments of dstPath, starting
 at startIndex (where 0 is the index of the first path segment) and having length
 numSegments. The data in pathData must be formatted in exactly the same manner as the
 original coordinate data for the given segment range, unless the path has been
 transformed using vgTransformPath or interpolated using vgInterpolatePath. In these
 cases, the path will have been subject to the segment promotion rules specified in
 those functions.

 The pathData pointer must be aligned on a 1-, 2-, or 4-byte boundary
 depending on the size of the coordinate datatype (as returned by querying the
 path’s VG_PATH_DATATYPE parameter using vgGetParameteri). The
 VG_PATH_CAPABILITY_MODIFY capability must be enabled for path.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if dstPath is not a valid path handle, or is not shared with the current
     context
   VG_PATH_CAPABILITY_ERROR
   – if VG_PATH_CAPABILITY_MODIFY is not enabled for dstPath
   VG_ILLEGAL_ARGUMENT_ERROR
   – if pathData is NULL
   – if pathData is not properly aligned
   – if startIndex is less than 0
   – if numSegments is less than or equal to 0
   – if startIndex + numSegments is greater than the number of segments in the path
 */
EXPORT_C void
	vgModifyPathCoords(VGPath dstPath,
		VGint startIndex,
		VGint numSegments,
		const void * pathData)
	{
	OPENVG_TRACE("vgModifyPathCoords dstPath=0x%x, startIndex=%d, numSegments=%d, pathData=0x%x",
			dstPath, startIndex, numSegments, pathData);

	TGuestOpenVg::vgModifyPathCoords(dstPath, startIndex, numSegments, pathData);
	}

/*
 Appends a transformed copy of srcPath to the current contents of dstPath.
 The appended path is equivalent to the results of applying the current
 pathuser-to-surface transformation (VG_MATRIX_PATH_USER_TO_SURFACE) to srcPath.

 It is legal for srcPath and dstPath to be handles to the same path object, in
 which case the transformed path will be appended to the existing path. If
 srcPath and dstPath are handles to distinct path objects, the contents of
 srcPath will not be affected by the call.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if either dstPath or srcPath is not a valid path handle, or is not shared with
     the current context
   VG_PATH_CAPABILITY_ERROR
   – if VG_PATH_CAPABILITY_TRANSFORM_FROM is not enabled for srcPath
   – if VG_PATH_CAPABILITY_TRANSFORM_TO is not enabled for dstPath
 */
EXPORT_C void
	vgTransformPath(VGPath dstPath, VGPath srcPath)
	{
	OPENVG_TRACE("vgTransformPath dstPath=0x%x, srcPath=0x%x", dstPath, srcPath);

	TGuestOpenVg::vgTransformPath(dstPath, srcPath);
	}

/*
 Returns the point lying a given distance along a given portion of a path and
 the unit-length tangent vector at that point. Only the subpath consisting of the
 numSegments path segments beginning with startSegment (where the initial path
 segment has index 0) is used. For the remainder of this section we refer only to
 this subpath when discussing paths.

 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 x and y are both non-NULL, and the VG_PATH_CAPABILITY_POINT_ALONG_PATH is
     not enabled for path
   – If tangentX and tangentY are both non-NULL, and the
     VG_PATH_CAPABILITY_TANGENT_ALONG_PATH capability 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 less than 0 or greater than the index
     of the final path segment
   – if x, y, tangentX or tangentY is not properly aligned
 */
EXPORT_C void
	vgPointAlongPath(VGPath path,
		VGint startSegment,
		VGint numSegments,
		VGfloat distance,
		VGfloat * x, VGfloat * y,
		VGfloat * tangentX,
		VGfloat * tangentY)
	{
	OPENVG_TRACE("vgPointAlongPath path=0x%x, startSeg=%d, numSegs=%d, distance=%f, x=0x%x, y=0x%x, tangentX=0x%x, tangentY=0x%x",
			path, startSegment, numSegments, distance, x, y, tangentX, tangentY);

	TGuestOpenVg::vgPointAlongPath(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
	}

/*
 Performs filling and stroking. The paintModes argument is a bitwise OR of
 values from the VGPaintMode enumeration, determining whether the path is to be
 filled (VG_FILL_PATH), stroked (VG_STROKE_PATH), or both (VG_FILL_PATH |
 VG_STROKE_PATH). If both filling and stroking are to be performed, the path is
 first filled, then stroked.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if path is not a valid path handle, or is not shared with the current context
   VG_ILLEGAL_ARGUMENT_ERROR
   – if paintModes is not a valid bitwise OR of values from the VGPaintMode
     enumeration
 */
EXPORT_C void
	vgDrawPath(VGPath path, VGbitfield paintModes)
	{
	OPENVG_TRACE("vgDrawPath path=0x%x paintModes=0x%x", path, paintModes);

	TGuestOpenVg::vgDrawPath(path, paintModes);
	}

/* Paint */

/*
 Deallocates the resources associated with a paint object. Following the call, the
 paint handle is no longer valid in any of the contexts that shared it. If the paint
 object is currently active in a drawing context, the context continues to access it
 until it is replaced or the context is destroyed.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if paint is not a valid paint handle, or is not shared with the current context
 */
EXPORT_C void vgDestroyPaint(VGPaint paint)
	{
	OPENVG_TRACE("vgDestroyPaint paint=0x%x", paint);

	TGuestOpenVg::vgDestroyPaint(paint);
	}

/*
 Set paint definitions on the current context. The paintModes argument is a
 bitwise OR of values from the VGPaintMode enumeration, determining whether
 the paint object is to be used for filling (VG_FILL_PATH), stroking
 (VG_STROKE_PATH), or both (VG_FILL_PATH | VG_STROKE_PATH). The current paint
 replaces the previously set paint object, if any, for the given paint mode
 or modes. If paint is equal to VG_INVALID_HANDLE, the previously set paint
 object for the given mode (if present) is removed and the paint settings are
 restored to their default values.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if paint is neither a valid paint handle nor equal to VG_INVALID_HANDLE,
     or is not shared with the current context
   VG_ILLEGAL_ARGUMENT_ERROR
   – if paintModes is not a valid bitwise OR of values from the VGPaintMode
     enumeration
 */
EXPORT_C void
	vgSetPaint(VGPaint paint, VGbitfield paintModes)
	{
	OPENVG_TRACE("vgSetPaint paint=0x%x, paintModes=0x%x", paint, paintModes);

	TGuestOpenVg::vgSetPaint(paint, paintModes);
	}

/*
 As a shorthand, the vgSetColor function allows the VG_PAINT_COLOR parameter of a
 given paint object to be set using a 32-bit non-premultiplied sRGBA_8888
 representation. The rgba parameter is a VGuint with 8 bits of red starting at the
 most significant bit, followed by 8 bits each of green, blue, and alpha. Each color
 or alpha channel value is conceptually divided by 255. So as to obtain a value
 between 0 and 1.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if paint is not a valid paint handle, or is not shared with the current context
 */
EXPORT_C void
	vgSetColor(VGPaint paint, VGuint rgba)
	{
	OPENVG_TRACE("vgSetColor paint=0x%x, rgba=0x%x", paint, rgba);

	TGuestOpenVg::vgSetColor(paint, rgba);
	}

/*
 Replaces any previous pattern image defined on the given paint object for the given
 set of paint modes with a new pattern image. A value of VG_INVALID_HANDLE for the
 pattern parameter removes the current pattern image from the paint object.
 If the current paint object has its VG_PAINT_TYPE parameter set to VG_PAINT_TYPE_PATTERN,
 but no pattern image is set, the paint object behaves as if VG_PAINT_TYPE were set to
 VG_PAINT_TYPE_COLOR. While an image is set as the paint pattern for any paint object, it
 may not be used as a rendering target. Conversely, an image that is currently a rendering
 target may not be set as a paint pattern.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if paint is not a valid paint handle, or is not shared with the current context
   – if pattern is neither a valid image handle nor equal to VG_INVALID_HANDLE, or is not
     shared with the current context
   VG_IMAGE_IN_USE_ERROR
   – if pattern is currently a rendering target
 */
EXPORT_C void
	vgPaintPattern(VGPaint paint, VGImage pattern)
	{
	OPENVG_TRACE("vgPaintPattern paint=0x%x, pattern=0x%x", paint, pattern);

	TGuestOpenVg::vgPaintPattern(paint, pattern);
	}

/* Images */

/*
 Deallocates the resources associated with an image. Following the call, the image
 handle is no longer valid in any context that shared it. If the image is currently
 in use as a rendering target, is the ancestor of another image (see vgChildImage),
 is set as a paint pattern image on a VGPaint object, or is set as a glyph an a
 VGFont object, its definition remains available to those consumers as long as they
 remain valid, but the handle may no longer be used. When those uses cease, the
 image’s resources will automatically be deallocated.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if image is not a valid image handle, or is not shared with the current
	 context
 */
EXPORT_C void vgDestroyImage(VGImage image)
	{
	OPENVG_TRACE("vgDestroyImage image=0x%x -->", image);

	TGuestOpenVg::vgDestroyImage(image);
	OPENVG_TRACE("vgDestroyImage <--");
	}

/*
 Fills a given rectangle of an image with the color specified by the VG_CLEAR_COLOR parameter.
 The rectangle to be cleared is given by x, y, width, and height, which must define a positive
 region. The rectangle is clipped to the bounds of the image.

 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
   VG_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
 */
EXPORT_C void
	vgClearImage(VGImage image,
		VGint x, VGint y,
		VGint width, VGint height)
	{
	OPENVG_TRACE("vgClearImage image=0x%x, x=%d, y=%d, width=%d, height=%d",
			image, x, y, width, height);

	TGuestOpenVg::vgClearImage(image, x, y, width, height);
	}

/*
 Read pixel values from memory, perform format conversion if necessary, and store
 the resulting pixels into a rectangular portion of an image.

 Pixel values are read starting at the address given by the pointer data; adjacent
 scanlines are separated by dataStride bytes. Negative or zero values of
 dataStride are allowed. The region to be written is given by x, y, width, and
 height, which must define a positive region. Pixels that fall outside the bounds
 of the image are ignored.

 Pixel values in memory are formatted according to the dataFormat parameter, which
 must contain a value from the VGImageFormat enumeration. The data pointer must
 be aligned according to the number of bytes of the pixel format specified by
 dataFormat, unless dataFormat is equal to VG_BW_1, VG_A_1, or VG_A_4, in
 which case 1 byte alignment is sufficient. Each pixel is converted into the format of
 the destination image as it is written.

 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
   VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
   – if dataFormat is not a valid value from the VGImageFormat enumeration
   VG_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
   – if data is NULL
   – if data is not properly aligned
 */
EXPORT_C void
	vgImageSubData(VGImage image,
		const void * data,
		VGint dataStride,
		VGImageFormat dataFormat,
		VGint x, VGint y,
		VGint width, VGint height)
	{
	OPENVG_TRACE("vgImageSubData image=0x%x, data=0x%x, dataStride=%d, dataFormat=0x%x, x=%d, y=%d, width=%d, height=%d",
			image, data, dataStride, dataFormat, x, y, width, height);

	TGuestOpenVg::vgImageSubData(image, data, dataStride, dataFormat, x, y, width, height);
	}

/*
 Copies pixels between images. The source image pixel (sx + i, sy + j) is copied
 to the destination image pixel (dx + i, dy + j), for 0 <= i < width and
 0 <= j < height. Pixels whose source or destination lie outside of the bounds
 of the respective image are ignored. Pixel format conversion is applied as needed.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if either dst or src is not a valid image handle, or is not shared with the
     current context
   VG_IMAGE_IN_USE_ERROR
   – if either dst or src is currently a rendering target
   VG_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
 */
EXPORT_C void
	vgCopyImage(VGImage dst, VGint dx, VGint dy,
		VGImage src, VGint sx, VGint sy,
		VGint width, VGint height,
		VGboolean dither)
	{
	OPENVG_TRACE("vgCopyImage dst=0x%x, dx=%d, dy=%d, src=0x%x, sx=%d, sy=%d, width=%d, height=%d, dither=%d",
			dst, dx, dy, src, sx, sy, width, height, dither);

	TGuestOpenVg::vgCopyImage(dst, dx, dy, src, sx, sy, width, height, dither);
	}

/*
 Draw an image to the current drawing surface. The current image-user-to-surface
 transformation Ti is applied to the image, so that the image pixel centered at
 (px + 0.5, py + 0.5) is mapped to the point (Ti)(px + 0.5, py + 0.5). In practice,
 backwards mapping may be used. That is, a sample located at (x, y) in the surface
 coordinate system is colored according to an interpolated image pixel value at the
 point (Ti)-1(x, y) in the image coordinate system. If Ti is non-invertible (or nearly
 so, within the limits of numerical accuracy), no drawing occurs.

 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 void
	vgDrawImage(VGImage image)
	{
	OPENVG_TRACE("vgDrawImage image=0x%x", image);

	TGuestOpenVg::vgDrawImage(image);
	}

/*
 Copies pixel data from the image src onto the drawing surface. The image pixel
 (sx + i, sy + j) is copied to the drawing surface pixel (dx + i, dy + j), for
 0 <= i < width and 0 <= j < height. Pixels whose source lies outside of the
 bounds of src or whose destination lies outside the bounds of the drawing surface
 are ignored. Pixel format conversion is applied as needed. Scissoring takes place
 normally. Transformations, masking, and blending are not applied.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if src is not a valid image handle, or is not shared with the current context
   VG_IMAGE_IN_USE_ERROR
   – if src is currently a rendering target
   VG_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
 */
EXPORT_C void
	vgSetPixels(VGint dx, VGint dy,
		VGImage src, VGint sx, VGint sy,
		VGint width, VGint height)
	{
	OPENVG_TRACE("vgSetPixels dx=%d, dy=%d, src==0x%x, sx=%d, sy=%d, width=%d, height=%d",
			dx, dy, src, sx, sy, width, height);

	TGuestOpenVg::vgSetPixels(dx, dy, src, sx, sy, width, height);
	}

/*
 Copy pixel data to the drawing surface without the creation of a VGImage object. The pixel
 values to be drawn are taken from the data pointer at the time of the vgWritePixels call,
 so future changes to the data have no effect. The effects of changes to the data by another
 thread at the time of the call to vgWritePixels are undefined.

 ERRORS
   VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
   – if dataFormat is not a valid value from the VGImageFormat enumeration
   VG_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
   – if data is NULL
   – if data is not properly aligned
 */
EXPORT_C void
	vgWritePixels(const void * data, VGint dataStride,
		VGImageFormat dataFormat,
		VGint dx, VGint dy,
		VGint width, VGint height)
	{
	OPENVG_TRACE("vgWritePixels data=0x%x, dataStride=%d, dataFormat=0x%x, dx=%d, dy=%d, width=%d, height=%d",
			data, dataStride, dataFormat, dx, dy, width, height);

	TGuestOpenVg::vgWritePixels(data, dataStride, dataFormat, dx, dy, width, height);
	}

/*
 Retrieves pixel data from the drawing surface into the image dst. The drawing surface
 pixel (sx + i, sy + j) is copied to pixel (dx + i, dy + j) of the image dst, for
 0 <= i < width and 0 <= j < height. Pixels whose source lies outside of the bounds of
 the drawing surface or whose destination lies outside the bounds of dst are ignored.
 Pixel format conversion is applied as needed. The scissoring region does not affect
 the reading of pixels.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if dst is not a valid image handle, or is not shared with the current context
   VG_IMAGE_IN_USE_ERROR
   – if dst is currently a rendering target
   VG_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
 */
EXPORT_C void
	vgGetPixels(VGImage dst, VGint dx, VGint dy,
		VGint sx, VGint sy,
		VGint width, VGint height)
	{
	OPENVG_TRACE("vgGetPixels dst=0x%x, dx=%d, dy=%d, sx=%d, sy=%d, width=%d, height=%d",
			dst, dx, dy, sx, sy, width, height);

	TGuestOpenVg::vgGetPixels(dst, dx, dy, sx, sy, width, height);
	}

/*
 Copy pixels from one region of the drawing surface to another. Copies between
 overlapping regions are allowed and always produce consistent results identical to
 copying the entire source region to a scratch buffer followed by copying the scratch
 buffer into the destination region. The drawing surface pixel (sx + i, sy + j) is
 copied to pixel (dx + i, dy + j) for 0 <= i < width and 0 <= j < height. Pixels whose
 source or destination lies outside of the bounds of the drawing surface are ignored.
 Transformations, masking, and blending are not applied. Scissoring is applied to the
 destination, but does not affect the reading of pixels.

 ERRORS
   VG_ILLEGAL_ARGUMENT_ERROR
   – if width or height is less than or equal to 0
 */
EXPORT_C void
	vgCopyPixels(VGint dx, VGint dy,
		VGint sx, VGint sy,
		VGint width, VGint height)
	{
	OPENVG_TRACE("vgCopyPixels dx=%d, dy=%d, sx=%d, sy=%d, width=%d, height=%d",
			dx, dy, sx, sy, width, height);

	TGuestOpenVg::vgCopyPixels(dx, dy, sx, sy, width, height);
	}

/*
 Destroys the VGFont object pointed to by the font argument.
 Note that vgDestroyFont will not destroy underlying objects that were used to
 define glyphs in the font. It is the responsibility of an application to destroy all
 VGPath or VGImage objects that were used in a VGFont, if they are no longer in
 use.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if font is not a valid font handle, or is not shared with the current context
 */
EXPORT_C void
	vgDestroyFont(VGFont font)
	{
	OPENVG_TRACE("vgDestroyFont font=0x%x", font);

	TGuestOpenVg::vgDestroyFont(font);
	}

/*
 Creates a new glyph and assigns the given path to a glyph associated with the
 glyphIndex in a font object. The glyphOrigin argument defines the coordinates of
 the glyph origin within the path, and the escapement parameter determines the
 advance width for this glyph. Both glyphOrigin and escapement coordinates are
 defined in the same coordinate system as the path. For glyphs that have no
 visual representation (e.g., the <space> character), a value of VG_INVALID_HANDLE
 is used for path. The reference count for the path is incremented.

 The path object may define either an original glyph outline, or an outline that
 has been scaled and hinted to a particular size (in surface coordinate units); this
 is defined by the isHinted parameter, which can be used by implementation
 for text-specific optimizations (e.g., heuristic auto-hinting of unhinted outlines).
 When isHinted is equal to VG_TRUE, the implementation will never apply
 auto-hinting; otherwise, auto hinting will be applied at the implementation's
 discretion.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if font is not a valid font handle, or is not shared with the current context
   – if path is not a valid font handle or VG_INVALID_HANDLE, or is not shared
     with the current context
   VG_ILLEGAL_ARGUMENT_ERROR
   – if the pointer to glyphOrigin or escapement is NULL or is not properly
     aligned
 */
EXPORT_C void
	vgSetGlyphToPath(VGFont font,
		VGuint glyphIndex,
		VGPath path,
		VGboolean isHinted,
		const VGfloat glyphOrigin [2],
		const VGfloat escapement[2])
	{
	OPENVG_TRACE("vgSetGlyphToPath font=0x%x, glyphIndex=%u, path=0x%x, isHinted=%d, glyphOrigin=0x%x, escapement=0x%x",
			font, glyphIndex, path, isHinted, glyphOrigin, escapement);

	TGuestOpenVg::vgSetGlyphToPath(font, glyphIndex, path, isHinted, glyphOrigin, escapement);
	}

/*
 Creates a new glyph and assigns the given image into a glyph associated with
 the glyphIndex in a font object. The glyphOrigin argument defines the
 coordinates of the glyph origin within the image, and the escapement parameter
 determines the advance width for this glyph. Both glyphOrigin and escapement
 coordinates are defined in the image coordinate system. Applying transformations
 to an image (other than translations mapped to pixel grid in surface coordinate
 system) should be avoided as much as possible. For glyphs that have no visual
 representation (e.g., the <space> character), a value of VG_INVALID_HANDLE is
 used for image. The reference count for the image is incremented.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if font is not a valid font handle, or is not shared with the current context
   – if image is not a valid image handle or VG_INVALID_HANDLE, or is not
     shared with the current context
   VG_ILLEGAL_ARGUMENT_ERROR
   – if the pointer to glyphOrigin or escapement is NULL or is not properly
     aligned
   VG_IMAGE_IN_USE_ERROR
   – if image is currently a rendering target
 */
EXPORT_C void
	vgSetGlyphToImage(VGFont font,
		VGuint glyphIndex,
		VGImage image,
		const VGfloat glyphOrigin [2],
		const VGfloat escapement[2])
	{
	OPENVG_TRACE("vgSetGlyphToImage font=0x%x, glyphIndex=%d, image=0x%x, glyphOrigin=0x%x, escapement=0x%x",
			font, glyphIndex, image, (void*)glyphOrigin, (void*)escapement);

	TGuestOpenVg::vgSetGlyphToImage(font, glyphIndex, image, glyphOrigin, escapement);
	}

/*
 Deletes the glyph defined by a glyphIndex parameter from a font. The reference count
 for the VGPath or VGImage object to which the glyph was previously set is decremented,
 and the object's resources are released if the count has fallen to 0.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if font is not a valid font handle, or is not shared with the current context
   VG_ILLEGAL_ARGUMENT_ERROR
   – if glyphIndex is not defined for the font
 */
EXPORT_C void
	vgClearGlyph(VGFont font,
		VGuint glyphIndex)
	{
	OPENVG_TRACE("vgClearGlyph font=0x%x, glyphIndex=%u", font, glyphIndex);

	TGuestOpenVg::vgClearGlyph(font, glyphIndex);
	}

/*
 Renders a glyph defined by the glyphIndex using the given font object. The
 user space position of the glyph (the point where the glyph origin will be
 placed) is determined by value of VG_GLYPH_ORIGIN. vgDrawGlyph calculates the
 new text origin by translating the glyph origin by the escapement vector of
 the glyph defined by glyphIndex. Following the call, the VG_GLYPH_ORIGIN
 parameter will be updated with the new origin.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if font is not a valid font handle, or is not shared with the current context
   VG_ILLEGAL_ARGUMENT_ERROR
   – if glyphIndex has not been defined for a given font object
   – if paintModes is not a valid bitwise OR of values from the VGPaintMode
     enumeration, or 0
 */
EXPORT_C void
	vgDrawGlyph(VGFont font,
		VGuint glyphIndex,
		VGbitfield paintModes,
		VGboolean allowAutoHinting)
	{
	OPENVG_TRACE("vgDrawGlyph font=0x%x, glyphIndex=%u, paintModes=0x%x, allowAutoHinting=%d",
			font, glyphIndex, paintModes, allowAutoHinting);

	TGuestOpenVg::vgDrawGlyph(font, glyphIndex, paintModes, allowAutoHinting);
	}

/*
 Renders a sequence of glyphs defined by the array pointed to by glyphIndices
 using the given font object. The values in the adjustments_x and adjustments_y
 arrays define positional adjustment values for each pair of glyphs defined by
 the glyphIndices array. The glyphCount parameter defines the number of elements
 in the glyphIndices and adjustments_x and adjustments_y arrays. The adjustment
 values defined in these arrays may represent kerning or other positional adjustments
 required for each pair of glyphs. If no adjustments for glyph positioning in a
 particular axis are required (all horizontal and/or vertical adjustments are zero),
 NULL pointers may be passed for either or both of adjustment_x and
 adjustment_y. The adjustments values should be defined in the same
 coordinate system as the font glyphs; if the glyphs are defined by path objects
 with path data scaled (e.g., by a factor of 1/units-per-EM), the values in the
 adjustment_x and adjustment_y arrays are scaled using the same scale factor.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if font is not a valid font handle, or is not shared with the current context
   VG_ILLEGAL_ARGUMENT_ERROR
   – if glyphCount is zero or a negative value
   – if the pointer to the glyphIndices array is NULL or is not properly
     aligned
   – if a pointer to either of the adjustments_x or adjustments_y arrays are
     non-NULL and are not properly aligned
   – if any of the glyphIndices has not been defined in a given font object
   – if paintModes is not a valid bitwise OR of values from the VGPaintMode
     enumeration, or 0
 */
EXPORT_C void
	vgDrawGlyphs(VGFont font,
		VGint glyphCount,
		const VGuint * glyphIndices,
		const VGfloat * adjustments_x,
		const VGfloat * adjustments_y,
		VGbitfield paintModes,
		VGboolean allowAutoHinting)
	{
	OPENVG_TRACE("vgDrawGlyphs font=0x%x, glyphCount=%d, glyphIndices=0x%x, adjustments_y=0x%x, "
			"adjustments_x=0x%x, paintModes=0x%x, allowAutoHinting=%d",
			font, glyphCount, (void*)glyphIndices, (void*)adjustments_x, (void*)adjustments_y, paintModes, allowAutoHinting);

	TGuestOpenVg::vgDrawGlyphs(font, glyphCount, glyphIndices, adjustments_x, adjustments_y, paintModes, allowAutoHinting);
	}

/* Image Filters */

/*
 Computes a linear combination of color and alpha values (Rsrc, Gsrc, Bsrc,
 ALPHAsrc) from the normalized source image src at each pixel.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if either dst or src is not a valid image handle, or is not shared with the
     current context
   VG_IMAGE_IN_USE_ERROR
   – if either dst or src is currently a rendering target
   VG_ILLEGAL_ARGUMENT_ERROR
   – if src and dst overlap
   – if matrix is NULL
   – if matrix is not properly aligned
 */
EXPORT_C void
	vgColorMatrix(VGImage dst, VGImage src,
		const VGfloat * matrix)
	{
	OPENVG_TRACE("vgColorMatrix dst=0x%x, src=0x%x, matrix=0x%x", dst, src, matrix);

	TGuestOpenVg::vgColorMatrix(dst, src, matrix);
	}

/*
 Applies a user-supplied convolution kernel to a normalized source image src. The
 dimensions of the kernel are given by kernelWidth and kernelHeight; the kernel values
 are specified as kernelWidth*kernelHeight VGshorts in column-major order. That is,
 the kernel entry (i, j) is located at position i*kernelHeight + j in the input sequence.
 The shiftX and shiftY parameters specify a translation between the source and
 destination images. The result of the convolution is multiplied by a scale factor, and
 a bias is added.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if either dst or src is not a valid image handle, or is not shared with the
     current context
   VG_IMAGE_IN_USE_ERROR
   – if either dst or src is currently a rendering target
   VG_ILLEGAL_ARGUMENT_ERROR
   – if src and dst overlap
   – if kernelWidth or kernelHeight is less than or equal to 0 or greater than
     VG_MAX_KERNEL_SIZE
   – if kernel is NULL
   – if kernel is not properly aligned
   – if tilingMode is not one of the values from the VGTilingMode enumeration
 */
EXPORT_C void
	vgConvolve(VGImage dst, VGImage src,
		VGint kernelWidth, VGint kernelHeight,
		VGint shiftX, VGint shiftY,
		const VGshort * kernel,
		VGfloat scale,
		VGfloat bias,
		VGTilingMode tilingMode)
	{
	OPENVG_TRACE("vgConvolve dst=0x%x, src=0x%x, kW=%d, kH=%d, shX=%d, shY=%d, kernel=0x%x, scale=%f, bias=%f, tiling=0x%x",
			dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernel, scale, bias, tilingMode);

	TGuestOpenVg::vgConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernel, scale, bias, tilingMode);
	}

/*
 Applies a user-supplied separable convolution kernel to a normalized source image src.
 A separable kernel is a two-dimensional kernel in which each entry kij is equal to a
 product kxi * kyj of elements from two one dimensional kernels, one horizontal and one
 vertical.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if either dst or src is not a valid image handle, or is not shared with the
     current context
   VG_IMAGE_IN_USE_ERROR
   – if either dst or src is currently a rendering target
   VG_ILLEGAL_ARGUMENT_ERROR
   – if src and dst overlap
   – if kernelWidth or kernelHeight is less than or equal to 0 or greater than
     VG_MAX_SEPARABLE_KERNEL_SIZE
   – if kernelX or kernelY is NULL
   – if kernelX or kernelY is not properly aligned
   – if tilingMode is not one of the values from the VGTilingMode
     enumeration
 */
EXPORT_C void
	vgSeparableConvolve(VGImage dst, VGImage src,
		VGint kernelWidth,
		VGint kernelHeight,
		VGint shiftX, VGint shiftY,
		const VGshort * kernelX,
		const VGshort * kernelY,
		VGfloat scale,
		VGfloat bias,
		VGTilingMode tilingMode)
	{
	OPENVG_TRACE("vgSeparableConvolve dst=0x%x, src=0x%x, kW=%d, kH=%d, shX=%d, shY=%d, kX=0x%x, kY=0x%x, scale=%f, bias=%f, tiling=0x%x",
			dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernelX, kernelY, scale, bias, tilingMode);

	TGuestOpenVg::vgSeparableConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernelX, kernelY, scale, bias, tilingMode);
	}

/*
 Computes the convolution of a normalized source image src with a separable kernel
 defined in each dimension by the Gaussian function G(x, s).

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if either dst or src is not a valid image handle, or is not shared with the
     current context
   VG_IMAGE_IN_USE_ERROR
   – if either dst or src is currently a rendering target
   VG_ILLEGAL_ARGUMENT_ERROR
   – if src and dst overlap
   – if stdDeviationX or stdDeviationY is less than or equal to 0 or greater
     than VG_MAX_GAUSSIAN_STD_DEVIATION
   – if tilingMode is not one of the values from the VGTilingMode
     enumeration
 */
EXPORT_C void
	vgGaussianBlur(VGImage dst, VGImage src,
		VGfloat stdDeviationX,
		VGfloat stdDeviationY,
		VGTilingMode tilingMode)
	{
	OPENVG_TRACE("vgGaussianBlur dst=0x%x, src=0x%x, stdDeviationX=%f, stdDeviationY=%f, tilingMode=%d",
			dst, src, stdDeviationX, stdDeviationY, tilingMode);

	TGuestOpenVg::vgGaussianBlur(dst, src, stdDeviationX, stdDeviationY, tilingMode);
	}

/*
 Passes each image channel of the normalized source image src through a separate lookup
 table.

 Each channel of the normalized source pixel is used as an index into the lookup table for
 that channel by multiplying the normalized value by 255 and rounding to obtain an 8-bit
 integral value. Each LUT parameter should contain 256 VGubyte entries. The
 outputs of the lookup tables are concatenated to form an RGBA_8888 pixel
 value, which is interpreted as lRGBA_8888, lRGBA_8888_PRE, sRGBA_8888,
 or sRGBA_8888_PRE, depending on the values of outputLinear and  outputPremultiplied.

 The resulting pixels are converted into the destination format using the normal
 pixel format conversion rules.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if either dst or src is not a valid image handle, or is not shared with the
     current context
   VG_IMAGE_IN_USE_ERROR
   – if either dst or src is currently a rendering target
   VG_ILLEGAL_ARGUMENT_ERROR
   – if src and dst overlap
   – if any pointer parameter is NULL
 */
EXPORT_C void
	vgLookup(VGImage dst, VGImage src,
		const VGubyte * redLUT,
		const VGubyte * greenLUT,
		const VGubyte * blueLUT,
		const VGubyte * alphaLUT,
		VGboolean outputLinear,
		VGboolean outputPremultiplied)
	{
	OPENVG_TRACE("vgLookup dst=0x%x, src=0x%x, redLUT=0x%x, greenLUT=0x%x, blueLUT=0x%x, alphaLUT=0x%x, opLin=%d, opPremul=%d",
			dst, src, redLUT, greenLUT, blueLUT, alphaLUT, outputLinear, outputPremultiplied);

	TGuestOpenVg::vgLookup(dst, src, redLUT, greenLUT, blueLUT, alphaLUT,  outputLinear, outputPremultiplied);
	}

/*
 Passes a single image channel of the normalized source image src, selected by the
 sourceChannel parameter, through a combined lookup table that produces whole pixel
 values. Each normalized source channel value is multiplied by 255 and rounded to
 obtain an 8 bit integral value.

 ERRORS
   VG_BAD_HANDLE_ERROR
   – if either dst or src is not a valid image handle, or is not shared with the
     current context
   VG_IMAGE_IN_USE_ERROR
   – if either dst or src is currently a rendering target
   VG_ILLEGAL_ARGUMENT_ERROR
   – if src and dst overlap
   – if src is in an RGB pixel format and sourceChannel is not one of VG_RED,
     VG_GREEN, VG_BLUE or VG_ALPHA from the VGImageChannel enumeration
   – if lookupTable is NULL
   – if lookupTable is not properly aligned
 */
EXPORT_C void
	vgLookupSingle(VGImage dst, VGImage src,
		const VGuint * lookupTable,
		VGImageChannel sourceChannel,
		VGboolean outputLinear,
		VGboolean outputPremultiplied)
	{
	OPENVG_TRACE("vgLookupSingle dst=0x%x, src=0x%x, lookupTable=0x%x, sourceChannel=0x%x, opLin=%d, opPremul=%d",
			dst, src, lookupTable, sourceChannel, outputLinear, outputPremultiplied);

	TGuestOpenVg::vgLookupSingle(dst, src, lookupTable, sourceChannel, outputLinear, outputPremultiplied);
	}

// guest support for OpenVG extension #4, KHR_EGL_image - vgCreateEGLImageTargetKHR(VGeglImageKHR image)
/*
 Creates an EGLImage target VGImage object from the provided EGLImage
 <image>.  <image> should be of type EGLImageKHR, cast into the type
 VGeglImageKHR.  Assuming no errors are generated in this function,
 the resulting VGImage will be an EGLImage target of the specified
 EGLImage <image>.  As a side-effect of the referencing operation,
 all of the pixel data in the <buffer> used as the EGLImage source
 resource (i.e., the <buffer> parameter passed to the CreateImageKHR
 command that returned <image>) will become undefined.

 ERRORS
      VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
      - if the OpenVG implementation is not able to create a VGImage
        compatible with the provided VGeglImageKHR for an implementation-
        dependent reason (this could be caused by, but not limited to,
        reasons such as unsupported pixel formats, anti-aliasing quality,
        etc.).

      VG_ILLEGAL_ARGUMENT_ERROR
      - if <image> is not a valid VGeglImageKHR.
 */
VGImage	vgCreateEGLImageTargetKHR(VGeglImageKHR image)
	{
	OPENVG_TRACE("vgCreateEGLImageTargetKHR image=0x%x -->", image);

	VGImage imageHandle = TGuestOpenVg::vgCreateEGLImageTargetKHR(image);
	OPENVG_TRACE("vgCreateEGLImageTargetKHR imageHandle=0x%x <--", imageHandle);
	return imageHandle;
	}


} /* extern "C" */

// end of file openvg.cpp