/*
* Copyright (c) 2009 Symbian Foundation Ltd
* This component and the accompanying materials are made available
* under the terms of the License "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:
* Symbian Foundation Ltd - initial contribution.
* 
* Contributors:
*
* Description:
* Implementation of OpenVG interface
*/
#include <openvg.h>
#include "openvginternal.h"

extern "C" {

EXPORT_C VGErrorCode   vgGetError(void) __SOFTFP
   {
   return do_vgGetError();
   }

EXPORT_C void   vgFlush(void) __SOFTFP
   {
   return do_vgFlush();
   }

EXPORT_C void   vgFinish(void) __SOFTFP
   {
   return do_vgFinish();
   }

EXPORT_C  void  vgSetf (VGParamType type, VGfloat value) __SOFTFP
   {
   return do_vgSetf(type,value);
   }

EXPORT_C void   vgSeti (VGParamType type, VGint value) __SOFTFP
   {
   return do_vgSeti(type,value);
   }

EXPORT_C  void  vgSetfv(VGParamType type, VGint count ,const VGfloat* values) __SOFTFP
   {
   return do_vgSetfv(type,count,values);
   }

EXPORT_C void   vgSetiv(VGParamType type, VGint count ,const VGint* values) __SOFTFP
   {
   return do_vgSetiv(type,count,values);
   }

EXPORT_C  VGfloat   vgGetf(VGParamType type) __SOFTFP
   {
   return do_vgGetf(type);
   }

EXPORT_C VGint     vgGeti(VGParamType type) __SOFTFP
   {
   return do_vgGeti(type);
   }

EXPORT_C VGint     vgGetVectorSize(VGParamType type) __SOFTFP
   {
   return do_vgGetVectorSize(type);
   }

EXPORT_C  void      vgGetfv(VGParamType type, VGint count ,VGfloat* values) __SOFTFP
   {
   return do_vgGetfv(type,count,values);
   }

EXPORT_C void      vgGetiv(VGParamType type, VGint count ,VGint* values) __SOFTFP
   {
   return do_vgGetiv(type,count,values);
   }

EXPORT_C  void   vgSetParameterf(VGHandle object ,VGint paramType ,VGfloat value) __SOFTFP
   {
   return do_vgSetParameterf(object,paramType,value);
   }

EXPORT_C void   vgSetParameteri(VGHandle object ,VGint paramType ,VGint value) __SOFTFP
   {
   return do_vgSetParameteri(object,paramType,value);
   }

EXPORT_C  void   vgSetParameterfv(VGHandle object ,VGint paramType ,VGint count ,const VGfloat* values) __SOFTFP
   {
   return do_vgSetParameterfv(object,paramType,count,values);
   }

EXPORT_C void   vgSetParameteriv(VGHandle object ,VGint paramType ,VGint count ,const VGint* values) __SOFTFP
   {
   return do_vgSetParameteriv(object,paramType,count,values);
   }

EXPORT_C  VGfloat   vgGetParameterf(VGHandle object ,VGint paramType) __SOFTFP
   {
   return do_vgGetParameterf(object,paramType);
   }

EXPORT_C VGint   vgGetParameteri(VGHandle object ,VGint paramType) __SOFTFP
   {
   return do_vgGetParameteri(object,paramType);
   }

EXPORT_C VGint   vgGetParameterVectorSize(VGHandle object ,VGint paramType) __SOFTFP
   {
   return do_vgGetParameterVectorSize(object,paramType);
   }

EXPORT_C  void   vgGetParameterfv(VGHandle object ,VGint paramType ,VGint count ,VGfloat* values) __SOFTFP
   {
   return do_vgGetParameterfv(object,paramType,count,values);
   }

EXPORT_C void   vgGetParameteriv(VGHandle object ,VGint paramType ,VGint count ,VGint* values) __SOFTFP
   {
   return do_vgGetParameteriv(object,paramType,count,values);
   }

EXPORT_C void   vgLoadIdentity(void) __SOFTFP
   {
   return do_vgLoadIdentity();
   }

EXPORT_C  void   vgLoadMatrix(const VGfloat* m) __SOFTFP
   {
   return do_vgLoadMatrix(m);
   }

EXPORT_C  void   vgGetMatrix(VGfloat* m) __SOFTFP
   {
   return do_vgGetMatrix(m);
   }

EXPORT_C  void   vgMultMatrix(const  VGfloat* m) __SOFTFP
   {
   return do_vgMultMatrix(m);
   }

EXPORT_C  void   vgTranslate(VGfloat tx, VGfloat ty) __SOFTFP
   {
   return do_vgTranslate(tx,ty);
   }

EXPORT_C  void   vgScale(VGfloat sx, VGfloat sy) __SOFTFP
   {
   return do_vgScale(sx,sy);
   }

EXPORT_C  void   vgShear(VGfloat shx, VGfloat shy) __SOFTFP
   {
   return do_vgShear(shx,shy);
   }

EXPORT_C  void   vgRotate(VGfloat angle) __SOFTFP
   {
   return do_vgRotate(angle);
   }

EXPORT_C void   vgMask(VGHandle mask, VGMaskOperation operation ,VGint x, VGint y ,VGint width, VGint height) __SOFTFP
   {
   return do_vgMask(mask,operation,x,y,width,height);
   }

EXPORT_C void   vgRenderToMask(VGPath path ,VGbitfield paintModes ,VGMaskOperation operation) __SOFTFP
   {
   return do_vgRenderToMask(path,paintModes,operation);
   }

EXPORT_C VGMaskLayer   vgCreateMaskLayer(VGint width, VGint height) __SOFTFP
   {
   return do_vgCreateMaskLayer(width,height);
   }

EXPORT_C void   vgDestroyMaskLayer(VGMaskLayer maskLayer) __SOFTFP
   {
   return do_vgDestroyMaskLayer(maskLayer);
   }

EXPORT_C  void   vgFillMaskLayer(VGMaskLayer maskLayer ,VGint x, VGint y ,VGint width, VGint height ,VGfloat value) __SOFTFP
   {
   return do_vgFillMaskLayer(maskLayer,x,y,width,height,value);
   }

EXPORT_C void   vgCopyMask(VGMaskLayer maskLayer ,VGint sx, VGint sy ,VGint dx, VGint dy ,VGint width, VGint height) __SOFTFP
   {
   return do_vgCopyMask(maskLayer,sx,sy,dx,dy,width,height);
   }

EXPORT_C void   vgClear(VGint x, VGint y ,VGint width, VGint height) __SOFTFP
   {
   return do_vgClear(x,y,width,height);
   }

EXPORT_C  VGPath   vgCreatePath(VGint pathFormat ,VGPathDatatype datatype ,VGfloat scale, VGfloat bias ,VGint segmentCapacityHint ,VGint coordCapacityHint ,VGbitfield capabilities) __SOFTFP
   {
   return do_vgCreatePath(pathFormat,datatype,scale,bias,segmentCapacityHint,coordCapacityHint,capabilities);
   }

EXPORT_C void   vgClearPath(VGPath path, VGbitfield capabilities) __SOFTFP
   {
   return do_vgClearPath(path,capabilities);
   }

EXPORT_C void   vgDestroyPath(VGPath path) __SOFTFP
   {
   return do_vgDestroyPath(path);
   }

EXPORT_C void   vgRemovePathCapabilities(VGPath path ,VGbitfield capabilities) __SOFTFP
   {
   return do_vgRemovePathCapabilities(path,capabilities);
   }

EXPORT_C VGbitfield   vgGetPathCapabilities(VGPath path) __SOFTFP
   {
   return do_vgGetPathCapabilities(path);
   }

EXPORT_C void   vgAppendPath(VGPath dstPath, VGPath srcPath) __SOFTFP
   {
   return do_vgAppendPath(dstPath,srcPath);
   }

EXPORT_C void   vgAppendPathData(VGPath dstPath ,VGint numSegments ,const  VGubyte* pathSegments ,const  void* pathData) __SOFTFP
   {
   return do_vgAppendPathData(dstPath,numSegments,pathSegments,pathData);
   }

EXPORT_C void   vgModifyPathCoords(VGPath dstPath ,VGint startIndex ,VGint numSegments ,const void* pathData) __SOFTFP
   {
   return do_vgModifyPathCoords(dstPath,startIndex,numSegments,pathData);
   }

EXPORT_C void   vgTransformPath(VGPath dstPath, VGPath srcPath) __SOFTFP
   {
   return do_vgTransformPath(dstPath,srcPath);
   }

EXPORT_C  VGboolean   vgInterpolatePath(VGPath dstPath ,VGPath startPath ,VGPath endPath ,VGfloat amount) __SOFTFP
   {
   return do_vgInterpolatePath(dstPath,startPath,endPath,amount);
   }

EXPORT_C  VGfloat   vgPathLength(VGPath path ,VGint startSegment ,VGint numSegments) __SOFTFP
   {
   return do_vgPathLength(path,startSegment,numSegments);
   }

EXPORT_C  void   vgPointAlongPath(VGPath path ,VGint startSegment ,VGint numSegments ,VGfloat distance ,VGfloat* x, VGfloat* y ,VGfloat* tangentX ,VGfloat* tangentY) __SOFTFP
   {
   return do_vgPointAlongPath(path,startSegment,numSegments,distance,x,y,tangentX,tangentY);
   }

EXPORT_C  void   vgPathBounds(VGPath path ,VGfloat* minX ,VGfloat* minY ,VGfloat* width ,VGfloat* height) __SOFTFP
   {
   return do_vgPathBounds(path,minX,minY,width,height);
   }

EXPORT_C  void   vgPathTransformedBounds(VGPath path ,VGfloat* minX ,VGfloat* minY ,VGfloat* width ,VGfloat* height) __SOFTFP
   {
   return do_vgPathTransformedBounds(path,minX,minY,width,height);
   }

EXPORT_C void   vgDrawPath(VGPath path, VGbitfield paintModes) __SOFTFP
   {
   return do_vgDrawPath(path,paintModes);
   }

EXPORT_C VGPaint   vgCreatePaint(void) __SOFTFP
   {
   return do_vgCreatePaint();
   }

EXPORT_C void   vgDestroyPaint(VGPaint paint) __SOFTFP
   {
   return do_vgDestroyPaint(paint);
   }

EXPORT_C void   vgSetPaint(VGPaint paint, VGbitfield paintModes) __SOFTFP
   {
   return do_vgSetPaint(paint,paintModes);
   }

EXPORT_C VGPaint   vgGetPaint(VGPaintMode paintMode) __SOFTFP
   {
   return do_vgGetPaint(paintMode);
   }

EXPORT_C void   vgSetColor(VGPaint paint, VGuint rgba) __SOFTFP
   {
   return do_vgSetColor(paint,rgba);
   }

EXPORT_C VGuint   vgGetColor(VGPaint paint) __SOFTFP
   {
   return do_vgGetColor(paint);
   }

EXPORT_C void   vgPaintPattern(VGPaint paint, VGImage pattern) __SOFTFP
   {
   return do_vgPaintPattern(paint,pattern);
   }

EXPORT_C VGImage   vgCreateImage(VGImageFormat format ,VGint width, VGint height ,VGbitfield allowedQuality) __SOFTFP
   {
   return do_vgCreateImage(format,width,height,allowedQuality);
   }

EXPORT_C void   vgDestroyImage(VGImage image) __SOFTFP
   {
   return do_vgDestroyImage(image);
   }

EXPORT_C void   vgClearImage(VGImage image ,VGint x, VGint y ,VGint width, VGint height) __SOFTFP
   {
   return do_vgClearImage(image,x,y,width,height);
   }

EXPORT_C void   vgImageSubData(VGImage image ,const void* data ,VGint dataStride ,VGImageFormat dataFormat ,VGint x, VGint y ,VGint width, VGint height) __SOFTFP
   {
   return do_vgImageSubData(image,data,dataStride,dataFormat,x,y,width,height);
   }

EXPORT_C void   vgGetImageSubData(VGImage image ,void* data ,VGint dataStride ,VGImageFormat dataFormat ,VGint x, VGint y ,VGint width, VGint height) __SOFTFP
   {
   return do_vgGetImageSubData(image,data,dataStride,dataFormat,x,y,width,height);
   }

EXPORT_C VGImage   vgChildImage(VGImage parent ,VGint x, VGint y ,VGint width, VGint height) __SOFTFP
   {
   return do_vgChildImage(parent,x,y,width,height);
   }

EXPORT_C VGImage   vgGetParent(VGImage image) __SOFTFP
   {
   return do_vgGetParent(image);
   }

EXPORT_C void   vgCopyImage(VGImage dst, VGint dx, VGint dy ,VGImage src, VGint sx, VGint sy ,VGint width, VGint height ,VGboolean dither) __SOFTFP
   {
   return do_vgCopyImage(dst,dx,dy,src,sx,sy,width,height,dither);
   }

EXPORT_C void   vgDrawImage(VGImage image) __SOFTFP
   {
   return do_vgDrawImage(image);
   }

EXPORT_C void   vgSetPixels(VGint dx, VGint dy ,VGImage src, VGint sx, VGint sy ,VGint width, VGint height) __SOFTFP
   {
   return do_vgSetPixels(dx,dy,src,sx,sy,width,height);
   }

EXPORT_C void   vgWritePixels(const void* data, VGint dataStride ,VGImageFormat dataFormat ,VGint dx, VGint dy ,VGint width, VGint height) __SOFTFP
   {
   return do_vgWritePixels(data,dataStride,dataFormat,dx,dy,width,height);
   }

EXPORT_C void   vgGetPixels(VGImage dst, VGint dx, VGint dy ,VGint sx, VGint sy ,VGint width, VGint height) __SOFTFP
   {
   return do_vgGetPixels(dst,dx,dy,sx,sy,width,height);
   }

EXPORT_C void   vgReadPixels(void* data, VGint dataStride ,VGImageFormat dataFormat ,VGint sx, VGint sy ,VGint width, VGint height) __SOFTFP
   {
   return do_vgReadPixels(data,dataStride,dataFormat,sx,sy,width,height);
   }

EXPORT_C void   vgCopyPixels(VGint dx, VGint dy ,VGint sx, VGint sy ,VGint width, VGint height) __SOFTFP
   {
   return do_vgCopyPixels(dx,dy,sx,sy,width,height);
   }

EXPORT_C VGFont   vgCreateFont(VGint glyphCapacityHint) __SOFTFP
   {
   return do_vgCreateFont(glyphCapacityHint);
   }

EXPORT_C void   vgDestroyFont(VGFont font) __SOFTFP
   {
   return do_vgDestroyFont(font);
   }

EXPORT_C  void   vgSetGlyphToPath(VGFont font ,VGuint glyphIndex ,VGPath path ,VGboolean isHinted ,const VGfloat glyphOrigin [2] ,const VGfloat escapement[2]) __SOFTFP
   {
   return do_vgSetGlyphToPath(font,glyphIndex,path,isHinted,glyphOrigin,escapement);
   }

EXPORT_C  void   vgSetGlyphToImage(VGFont font ,VGuint glyphIndex ,VGImage image ,const VGfloat glyphOrigin [2] ,const VGfloat escapement[2]) __SOFTFP
   {
   return do_vgSetGlyphToImage(font,glyphIndex,image,glyphOrigin,escapement);
   }

EXPORT_C void   vgClearGlyph(VGFont font ,VGuint glyphIndex) __SOFTFP
   {
   return do_vgClearGlyph(font,glyphIndex);
   }

EXPORT_C void   vgDrawGlyph(VGFont font ,VGuint glyphIndex ,VGbitfield paintModes ,VGboolean allowAutoHinting) __SOFTFP
   {
   return do_vgDrawGlyph(font,glyphIndex,paintModes,allowAutoHinting);
   }

EXPORT_C  void   vgDrawGlyphs(VGFont font ,VGint glyphCount ,const VGuint* glyphIndices ,const VGfloat* adjustments_x ,const VGfloat* adjustments_y ,VGbitfield paintModes ,VGboolean allowAutoHinting) __SOFTFP
   {
   return do_vgDrawGlyphs(font,glyphCount,glyphIndices,adjustments_x,adjustments_y,paintModes,allowAutoHinting);
   }

EXPORT_C  void   vgColorMatrix(VGImage dst, VGImage src ,const VGfloat* matrix) __SOFTFP
   {
   return do_vgColorMatrix(dst,src,matrix);
   }

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) __SOFTFP
   {
   return do_vgConvolve(dst,src,kernelWidth,kernelHeight,shiftX,shiftY,kernel,scale,bias,tilingMode);
   }

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) __SOFTFP
   {
   return do_vgSeparableConvolve(dst,src,kernelWidth,kernelHeight,shiftX,shiftY,kernelX,kernelY,scale,bias,tilingMode);
   }

EXPORT_C  void   vgGaussianBlur(VGImage dst, VGImage src ,VGfloat stdDeviationX ,VGfloat stdDeviationY ,VGTilingMode tilingMode) __SOFTFP
   {
   return do_vgGaussianBlur(dst,src,stdDeviationX,stdDeviationY,tilingMode);
   }

EXPORT_C void   vgLookup(VGImage dst, VGImage src ,const VGubyte* redLUT ,const VGubyte* greenLUT ,const VGubyte* blueLUT ,const VGubyte* alphaLUT ,VGboolean outputLinear ,VGboolean outputPremultiplied) __SOFTFP
   {
   return do_vgLookup(dst,src,redLUT,greenLUT,blueLUT,alphaLUT,outputLinear,outputPremultiplied);
   }

EXPORT_C void   vgLookupSingle(VGImage dst, VGImage src ,const VGuint* lookupTable ,VGImageChannel sourceChannel ,VGboolean outputLinear ,VGboolean outputPremultiplied) __SOFTFP
   {
   return do_vgLookupSingle(dst,src,lookupTable,sourceChannel,outputLinear,outputPremultiplied);
   }

EXPORT_C VGHardwareQueryResult   vgHardwareQuery        (VGHardwareQueryType key ,VGint setting) __SOFTFP
   {
   return do_vgHardwareQuery(key,setting);
   }

EXPORT_C const VGubyte *   vgGetString(VGStringID name) __SOFTFP
   {
   return do_vgGetString(name);
   }
}