1 /*

     2 * Copyright (c) 2009 Symbian Foundation Ltd

     3 * This component and the accompanying materials are made available

     4 * under the terms of the License "Eclipse Public License v1.0"

     5 * which accompanies this distribution, and is available

     6 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 *

     8 * Initial Contributors:

     9 * Symbian Foundation Ltd - initial contribution.

    10 * 

    11 * Contributors:

    12 *

    13 * Description:

    14 * Implementation of OpenVG interface

    15 */

    16 #include <openvg.h>

    17 #include "openvginternal.h"

    18 

    19 extern "C" {

    20 

    21 EXPORT_C VGErrorCode   vgGetError(void)

    22    {

    23    return do_vgGetError();

    24    }

    25 

    26 EXPORT_C void   vgFlush(void)

    27    {

    28    return do_vgFlush();

    29    }

    30 

    31 EXPORT_C void   vgFinish(void)

    32    {

    33    return do_vgFinish();

    34    }

    35 

    36 EXPORT_C void  vgSetf (VGParamType type, VGfloat value)

    37    {

    38    return do_vgSetf(type,value);

    39    }

    40 

    41 EXPORT_C void   vgSeti (VGParamType type, VGint value)

    42    {

    43    return do_vgSeti(type,value);

    44    }

    45 

    46 EXPORT_C void   vgSetfv(VGParamType type, VGint count ,const VGfloat* values)

    47    {

    48    return do_vgSetfv(type,count,values);

    49    }

    50 

    51 EXPORT_C void   vgSetiv(VGParamType type, VGint count ,const VGint* values)

    52    {

    53    return do_vgSetiv(type,count,values);

    54    }

    55 

    56 EXPORT_C VGfloat   vgGetf(VGParamType type)

    57    {

    58    return do_vgGetf(type);

    59    }

    60 

    61 EXPORT_C VGint     vgGeti(VGParamType type)

    62    {

    63    return do_vgGeti(type);

    64    }

    65 

    66 EXPORT_C VGint     vgGetVectorSize(VGParamType type)

    67    {

    68    return do_vgGetVectorSize(type);

    69    }

    70 

    71 EXPORT_C void      vgGetfv(VGParamType type, VGint count ,VGfloat* values)

    72    {

    73    return do_vgGetfv(type,count,values);

    74    }

    75 

    76 EXPORT_C void      vgGetiv(VGParamType type, VGint count ,VGint* values)

    77    {

    78    return do_vgGetiv(type,count,values);

    79    }

    80 

    81 EXPORT_C void   vgSetParameterf(VGHandle object ,VGint paramType ,VGfloat value)

    82    {

    83    return do_vgSetParameterf(object,paramType,value);

    84    }

    85 

    86 EXPORT_C void   vgSetParameteri(VGHandle object ,VGint paramType ,VGint value)

    87    {

    88    return do_vgSetParameteri(object,paramType,value);

    89    }

    90 

    91 EXPORT_C void   vgSetParameterfv(VGHandle object ,VGint paramType ,VGint count ,const VGfloat* values)

    92    {

    93    return do_vgSetParameterfv(object,paramType,count,values);

    94    }

    95 

    96 EXPORT_C void   vgSetParameteriv(VGHandle object ,VGint paramType ,VGint count ,const VGint* values)

    97    {

    98    return do_vgSetParameteriv(object,paramType,count,values);

    99    }

   100 

   101 EXPORT_C VGfloat   vgGetParameterf(VGHandle object ,VGint paramType)

   102    {

   103    return do_vgGetParameterf(object,paramType);

   104    }

   105 

   106 EXPORT_C VGint   vgGetParameteri(VGHandle object ,VGint paramType)

   107    {

   108    return do_vgGetParameteri(object,paramType);

   109    }

   110 

   111 EXPORT_C VGint   vgGetParameterVectorSize(VGHandle object ,VGint paramType)

   112    {

   113    return do_vgGetParameterVectorSize(object,paramType);

   114    }

   115 

   116 EXPORT_C void   vgGetParameterfv(VGHandle object ,VGint paramType ,VGint count ,VGfloat* values)

   117    {

   118    return do_vgGetParameterfv(object,paramType,count,values);

   119    }

   120 

   121 EXPORT_C void   vgGetParameteriv(VGHandle object ,VGint paramType ,VGint count ,VGint* values)

   122    {

   123    return do_vgGetParameteriv(object,paramType,count,values);

   124    }

   125 

   126 EXPORT_C void   vgLoadIdentity(void)

   127    {

   128    return do_vgLoadIdentity();

   129    }

   130 

   131 EXPORT_C void   vgLoadMatrix(const VGfloat* m)

   132    {

   133    return do_vgLoadMatrix(m);

   134    }

   135 

   136 EXPORT_C void   vgGetMatrix(VGfloat* m)

   137    {

   138    return do_vgGetMatrix(m);

   139    }

   140 

   141 EXPORT_C void   vgMultMatrix(const  VGfloat* m)

   142    {

   143    return do_vgMultMatrix(m);

   144    }

   145 

   146 EXPORT_C void   vgTranslate(VGfloat tx, VGfloat ty)

   147    {

   148    return do_vgTranslate(tx,ty);

   149    }

   150 

   151 EXPORT_C void   vgScale(VGfloat sx, VGfloat sy)

   152    {

   153    return do_vgScale(sx,sy);

   154    }

   155 

   156 EXPORT_C void   vgShear(VGfloat shx, VGfloat shy)

   157    {

   158    return do_vgShear(shx,shy);

   159    }

   160 

   161 EXPORT_C void   vgRotate(VGfloat angle)

   162    {

   163    return do_vgRotate(angle);

   164    }

   165 

   166 EXPORT_C void   vgMask(VGHandle mask, VGMaskOperation operation ,VGint x, VGint y ,VGint width, VGint height)

   167    {

   168    return do_vgMask(mask,operation,x,y,width,height);

   169    }

   170 

   171 EXPORT_C void   vgRenderToMask(VGPath path ,VGbitfield paintModes ,VGMaskOperation operation)

   172    {

   173    return do_vgRenderToMask(path,paintModes,operation);

   174    }

   175 

   176 EXPORT_C VGMaskLayer   vgCreateMaskLayer(VGint width, VGint height)

   177    {

   178    return do_vgCreateMaskLayer(width,height);

   179    }

   180 

   181 EXPORT_C void   vgDestroyMaskLayer(VGMaskLayer maskLayer)

   182    {

   183    return do_vgDestroyMaskLayer(maskLayer);

   184    }

   185 

   186 EXPORT_C void   vgFillMaskLayer(VGMaskLayer maskLayer ,VGint x, VGint y ,VGint width, VGint height ,VGfloat value)

   187    {

   188    return do_vgFillMaskLayer(maskLayer,x,y,width,height,value);

   189    }

   190 

   191 EXPORT_C void   vgCopyMask(VGMaskLayer maskLayer ,VGint sx, VGint sy ,VGint dx, VGint dy ,VGint width, VGint height)

   192    {

   193    return do_vgCopyMask(maskLayer,sx,sy,dx,dy,width,height);

   194    }

   195 

   196 EXPORT_C void   vgClear(VGint x, VGint y ,VGint width, VGint height)

   197    {

   198    return do_vgClear(x,y,width,height);

   199    }

   200 

   201 EXPORT_C VGPath   vgCreatePath(VGint pathFormat ,VGPathDatatype datatype ,VGfloat scale, VGfloat bias ,VGint segmentCapacityHint ,VGint coordCapacityHint ,VGbitfield capabilities)

   202    {

   203    return do_vgCreatePath(pathFormat,datatype,scale,bias,segmentCapacityHint,coordCapacityHint,capabilities);

   204    }

   205 

   206 EXPORT_C void   vgClearPath(VGPath path, VGbitfield capabilities)

   207    {

   208    return do_vgClearPath(path,capabilities);

   209    }

   210 

   211 EXPORT_C void   vgDestroyPath(VGPath path)

   212    {

   213    return do_vgDestroyPath(path);

   214    }

   215 

   216 EXPORT_C void   vgRemovePathCapabilities(VGPath path ,VGbitfield capabilities)

   217    {

   218    return do_vgRemovePathCapabilities(path,capabilities);

   219    }

   220 

   221 EXPORT_C VGbitfield   vgGetPathCapabilities(VGPath path)

   222    {

   223    return do_vgGetPathCapabilities(path);

   224    }

   225 

   226 EXPORT_C void   vgAppendPath(VGPath dstPath, VGPath srcPath)

   227    {

   228    return do_vgAppendPath(dstPath,srcPath);

   229    }

   230 

   231 EXPORT_C void   vgAppendPathData(VGPath dstPath ,VGint numSegments ,const  VGubyte* pathSegments ,const  void* pathData)

   232    {

   233    return do_vgAppendPathData(dstPath,numSegments,pathSegments,pathData);

   234    }

   235 

   236 EXPORT_C void   vgModifyPathCoords(VGPath dstPath ,VGint startIndex ,VGint numSegments ,const void* pathData)

   237    {

   238    return do_vgModifyPathCoords(dstPath,startIndex,numSegments,pathData);

   239    }

   240 

   241 EXPORT_C void   vgTransformPath(VGPath dstPath, VGPath srcPath)

   242    {

   243    return do_vgTransformPath(dstPath,srcPath);

   244    }

   245 

   246 EXPORT_C VGboolean   vgInterpolatePath(VGPath dstPath ,VGPath startPath ,VGPath endPath ,VGfloat amount)

   247    {

   248    return do_vgInterpolatePath(dstPath,startPath,endPath,amount);

   249    }

   250 

   251 EXPORT_C VGfloat   vgPathLength(VGPath path ,VGint startSegment ,VGint numSegments)

   252    {

   253    return do_vgPathLength(path,startSegment,numSegments);

   254    }

   255 

   256 EXPORT_C void   vgPointAlongPath(VGPath path ,VGint startSegment ,VGint numSegments ,VGfloat distance ,VGfloat* x, VGfloat* y ,VGfloat* tangentX ,VGfloat* tangentY)

   257    {

   258    return do_vgPointAlongPath(path,startSegment,numSegments,distance,x,y,tangentX,tangentY);

   259    }

   260 

   261 EXPORT_C void   vgPathBounds(VGPath path ,VGfloat* minX ,VGfloat* minY ,VGfloat* width ,VGfloat* height)

   262    {

   263    return do_vgPathBounds(path,minX,minY,width,height);

   264    }

   265 

   266 EXPORT_C void   vgPathTransformedBounds(VGPath path ,VGfloat* minX ,VGfloat* minY ,VGfloat* width ,VGfloat* height)

   267    {

   268    return do_vgPathTransformedBounds(path,minX,minY,width,height);

   269    }

   270 

   271 EXPORT_C void   vgDrawPath(VGPath path, VGbitfield paintModes)

   272    {

   273    return do_vgDrawPath(path,paintModes);

   274    }

   275 

   276 EXPORT_C VGPaint   vgCreatePaint(void)

   277    {

   278    return do_vgCreatePaint();

   279    }

   280 

   281 EXPORT_C void   vgDestroyPaint(VGPaint paint)

   282    {

   283    return do_vgDestroyPaint(paint);

   284    }

   285 

   286 EXPORT_C void   vgSetPaint(VGPaint paint, VGbitfield paintModes)

   287    {

   288    return do_vgSetPaint(paint,paintModes);

   289    }

   290 

   291 EXPORT_C VGPaint   vgGetPaint(VGPaintMode paintMode)

   292    {

   293    return do_vgGetPaint(paintMode);

   294    }

   295 

   296 EXPORT_C void   vgSetColor(VGPaint paint, VGuint rgba)

   297    {

   298    return do_vgSetColor(paint,rgba);

   299    }

   300 

   301 EXPORT_C VGuint   vgGetColor(VGPaint paint)

   302    {

   303    return do_vgGetColor(paint);

   304    }

   305 

   306 EXPORT_C void   vgPaintPattern(VGPaint paint, VGImage pattern)

   307    {

   308    return do_vgPaintPattern(paint,pattern);

   309    }

   310 

   311 EXPORT_C VGImage   vgCreateImage(VGImageFormat format ,VGint width, VGint height ,VGbitfield allowedQuality)

   312    {

   313    return do_vgCreateImage(format,width,height,allowedQuality);

   314    }

   315 

   316 EXPORT_C void   vgDestroyImage(VGImage image)

   317    {

   318    return do_vgDestroyImage(image);

   319    }

   320 

   321 EXPORT_C void   vgClearImage(VGImage image ,VGint x, VGint y ,VGint width, VGint height)

   322    {

   323    return do_vgClearImage(image,x,y,width,height);

   324    }

   325 

   326 EXPORT_C void   vgImageSubData(VGImage image ,const void* data ,VGint dataStride ,VGImageFormat dataFormat ,VGint x, VGint y ,VGint width, VGint height)

   327    {

   328    return do_vgImageSubData(image,data,dataStride,dataFormat,x,y,width,height);

   329    }

   330 

   331 EXPORT_C void   vgGetImageSubData(VGImage image ,void* data ,VGint dataStride ,VGImageFormat dataFormat ,VGint x, VGint y ,VGint width, VGint height)

   332    {

   333    return do_vgGetImageSubData(image,data,dataStride,dataFormat,x,y,width,height);

   334    }

   335 

   336 EXPORT_C VGImage   vgChildImage(VGImage parent ,VGint x, VGint y ,VGint width, VGint height)

   337    {

   338    return do_vgChildImage(parent,x,y,width,height);

   339    }

   340 

   341 EXPORT_C VGImage   vgGetParent(VGImage image)

   342    {

   343    return do_vgGetParent(image);

   344    }

   345 

   346 EXPORT_C void   vgCopyImage(VGImage dst, VGint dx, VGint dy ,VGImage src, VGint sx, VGint sy ,VGint width, VGint height ,VGboolean dither)

   347    {

   348    return do_vgCopyImage(dst,dx,dy,src,sx,sy,width,height,dither);

   349    }

   350 

   351 EXPORT_C void   vgDrawImage(VGImage image)

   352    {

   353    return do_vgDrawImage(image);

   354    }

   355 

   356 EXPORT_C void   vgSetPixels(VGint dx, VGint dy ,VGImage src, VGint sx, VGint sy ,VGint width, VGint height)

   357    {

   358    return do_vgSetPixels(dx,dy,src,sx,sy,width,height);

   359    }

   360 

   361 EXPORT_C void   vgWritePixels(const void* data, VGint dataStride ,VGImageFormat dataFormat ,VGint dx, VGint dy ,VGint width, VGint height)

   362    {

   363    return do_vgWritePixels(data,dataStride,dataFormat,dx,dy,width,height);

   364    }

   365 

   366 EXPORT_C void   vgGetPixels(VGImage dst, VGint dx, VGint dy ,VGint sx, VGint sy ,VGint width, VGint height)

   367    {

   368    return do_vgGetPixels(dst,dx,dy,sx,sy,width,height);

   369    }

   370 

   371 EXPORT_C void   vgReadPixels(void* data, VGint dataStride ,VGImageFormat dataFormat ,VGint sx, VGint sy ,VGint width, VGint height)

   372    {

   373    return do_vgReadPixels(data,dataStride,dataFormat,sx,sy,width,height);

   374    }

   375 

   376 EXPORT_C void   vgCopyPixels(VGint dx, VGint dy ,VGint sx, VGint sy ,VGint width, VGint height)

   377    {

   378    return do_vgCopyPixels(dx,dy,sx,sy,width,height);

   379    }

   380 

   381 EXPORT_C VGFont   vgCreateFont(VGint glyphCapacityHint)

   382    {

   383    return do_vgCreateFont(glyphCapacityHint);

   384    }

   385 

   386 EXPORT_C void   vgDestroyFont(VGFont font)

   387    {

   388    return do_vgDestroyFont(font);

   389    }

   390 

   391 EXPORT_C void   vgSetGlyphToPath(VGFont font ,VGuint glyphIndex ,VGPath path ,VGboolean isHinted ,const VGfloat glyphOrigin [2] ,const VGfloat escapement[2])

   392    {

   393    return do_vgSetGlyphToPath(font,glyphIndex,path,isHinted,glyphOrigin,escapement);

   394    }

   395 

   396 EXPORT_C void   vgSetGlyphToImage(VGFont font ,VGuint glyphIndex ,VGImage image ,const VGfloat glyphOrigin [2] ,const VGfloat escapement[2])

   397    {

   398    return do_vgSetGlyphToImage(font,glyphIndex,image,glyphOrigin,escapement);

   399    }

   400 

   401 EXPORT_C void   vgClearGlyph(VGFont font ,VGuint glyphIndex)

   402    {

   403    return do_vgClearGlyph(font,glyphIndex);

   404    }

   405 

   406 EXPORT_C void   vgDrawGlyph(VGFont font ,VGuint glyphIndex ,VGbitfield paintModes ,VGboolean allowAutoHinting)

   407    {

   408    return do_vgDrawGlyph(font,glyphIndex,paintModes,allowAutoHinting);

   409    }

   410 

   411 EXPORT_C void   vgDrawGlyphs(VGFont font ,VGint glyphCount ,const VGuint* glyphIndices ,const VGfloat* adjustments_x ,const VGfloat* adjustments_y ,VGbitfield paintModes ,VGboolean allowAutoHinting)

   412    {

   413    return do_vgDrawGlyphs(font,glyphCount,glyphIndices,adjustments_x,adjustments_y,paintModes,allowAutoHinting);

   414    }

   415 

   416 EXPORT_C void   vgColorMatrix(VGImage dst, VGImage src ,const VGfloat* matrix)

   417    {

   418    return do_vgColorMatrix(dst,src,matrix);

   419    }

   420 

   421 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)

   422    {

   423    return do_vgConvolve(dst,src,kernelWidth,kernelHeight,shiftX,shiftY,kernel,scale,bias,tilingMode);

   424    }

   425 

   426 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)

   427    {

   428    return do_vgSeparableConvolve(dst,src,kernelWidth,kernelHeight,shiftX,shiftY,kernelX,kernelY,scale,bias,tilingMode);

   429    }

   430 

   431 EXPORT_C void   vgGaussianBlur(VGImage dst, VGImage src ,VGfloat stdDeviationX ,VGfloat stdDeviationY ,VGTilingMode tilingMode)

   432    {

   433    return do_vgGaussianBlur(dst,src,stdDeviationX,stdDeviationY,tilingMode);

   434    }

   435 

   436 EXPORT_C void   vgLookup(VGImage dst, VGImage src ,const VGubyte* redLUT ,const VGubyte* greenLUT ,const VGubyte* blueLUT ,const VGubyte* alphaLUT ,VGboolean outputLinear ,VGboolean outputPremultiplied)

   437    {

   438    return do_vgLookup(dst,src,redLUT,greenLUT,blueLUT,alphaLUT,outputLinear,outputPremultiplied);

   439    }

   440 

   441 EXPORT_C void   vgLookupSingle(VGImage dst, VGImage src ,const VGuint* lookupTable ,VGImageChannel sourceChannel ,VGboolean outputLinear ,VGboolean outputPremultiplied)

   442    {

   443    return do_vgLookupSingle(dst,src,lookupTable,sourceChannel,outputLinear,outputPremultiplied);

   444    }

   445 

   446 EXPORT_C VGHardwareQueryResult   vgHardwareQuery        (VGHardwareQueryType key ,VGint setting)

   447    {

   448    return do_vgHardwareQuery(key,setting);

   449    }

   450 

   451 EXPORT_C const VGubyte *   vgGetString(VGStringID name)

   452    {

   453    return do_vgGetString(name);

   454    }

   455 }

   456