Subversion Repositories Kolibri OS

/**************************************************************************

 *

 * Copyright 2009 VMware, Inc.  All Rights Reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sub license, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice (including the

 * next paragraph) shall be included in all copies or substantial portions

 * of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.

 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR

 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 *

 **************************************************************************/

#include "VG/openvg.h"

#include "vg_context.h"

#include "handle.h"

#include "path.h"

#include "api.h"

#include "pipe/p_context.h"

VGPath vegaCreatePath(VGint pathFormat,

                      VGPathDatatype datatype,

                      VGfloat scale, VGfloat bias,

                      VGint segmentCapacityHint,

                      VGint coordCapacityHint,

                      VGbitfield capabilities)

{

   struct vg_context *ctx = vg_current_context();

   if (pathFormat != VG_PATH_FORMAT_STANDARD) {

      vg_set_error(ctx, VG_UNSUPPORTED_PATH_FORMAT_ERROR);

      return VG_INVALID_HANDLE;

   }

   if (datatype < VG_PATH_DATATYPE_S_8 ||

       datatype > VG_PATH_DATATYPE_F) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return VG_INVALID_HANDLE;

   }

   if (!scale) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return VG_INVALID_HANDLE;

   }

   return path_to_handle(path_create(datatype, scale, bias,

                                     segmentCapacityHint, coordCapacityHint,

                                     capabilities));

}

void vegaClearPath(VGPath path, VGbitfield capabilities)

{

   struct vg_context *ctx = vg_current_context();

   struct path *p = 0;

   if (path == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return;

   }

   p = handle_to_path(path);

   path_clear(p, capabilities);

}

void vegaDestroyPath(VGPath p)

{

   struct path *path = 0;

   struct vg_context *ctx = vg_current_context();

   if (p == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return;

   }

   path = handle_to_path(p);

   path_destroy(path);

}

void vegaRemovePathCapabilities(VGPath path,

                                VGbitfield capabilities)

{

   struct vg_context *ctx = vg_current_context();

   VGbitfield current;

   struct path *p;

   if (path == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return;

   }

   p = handle_to_path(path);

   current = path_capabilities(p);

   path_set_capabilities(p, (current &

                             (~(capabilities & VG_PATH_CAPABILITY_ALL))));

}

VGbitfield vegaGetPathCapabilities(VGPath path)

{

   struct vg_context *ctx = vg_current_context();

   struct path *p = 0;

   if (path == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return 0;

   }

   p = handle_to_path(path);

   return path_capabilities(p);

}

void vegaAppendPath(VGPath dstPath, VGPath srcPath)

{

   struct vg_context *ctx = vg_current_context();

   struct path *src, *dst;

   if (dstPath == VG_INVALID_HANDLE || srcPath == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return;

   }

   src = handle_to_path(srcPath);

   dst = handle_to_path(dstPath);

   if (!(path_capabilities(src) & VG_PATH_CAPABILITY_APPEND_FROM) ||

       !(path_capabilities(dst) & VG_PATH_CAPABILITY_APPEND_TO)) {

      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);

      return;

   }

   path_append_path(dst, src);

}

void vegaAppendPathData(VGPath dstPath,

                        VGint numSegments,

                        const VGubyte * pathSegments,

                        const void * pathData)

{

   struct vg_context *ctx = vg_current_context();

   struct path *p = 0;

   VGint i;

   if (dstPath == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return;

   }

   if (!pathSegments) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   if (numSegments <= 0) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   for (i = 0; i < numSegments; ++i) {

      if (pathSegments[i] > VG_LCWARC_TO_REL) {

         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

         return;

      }

   }

   p = handle_to_path(dstPath);

   if (!p || !is_aligned_to(p, path_datatype_size(p))) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   if (!(path_capabilities(p)&VG_PATH_CAPABILITY_APPEND_TO)) {

      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);

      return;

   }

   path_append_data(p, numSegments, pathSegments, pathData);

}

void vegaModifyPathCoords(VGPath dstPath,

                          VGint startIndex,

                          VGint numSegments,

                          const void * pathData)

{

   struct vg_context *ctx = vg_current_context();

   struct path *p = 0;

   if (dstPath == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return;

   }

   if (startIndex < 0 || numSegments <= 0) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   p = handle_to_path(dstPath);

   if (!pathData || !is_aligned_to(pathData, path_datatype_size(p))) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   if (startIndex + numSegments > path_num_segments(p)) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   if (!(path_capabilities(p)&VG_PATH_CAPABILITY_MODIFY)) {

      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);

      return;

   }

   path_modify_coords(p, startIndex, numSegments, pathData);

}

void vegaTransformPath(VGPath dstPath, VGPath srcPath)

{

   struct vg_context *ctx = vg_current_context();

   struct path *src = 0, *dst = 0;

   if (dstPath == VG_INVALID_HANDLE || srcPath == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return;

   }

   src = handle_to_path(srcPath);

   dst = handle_to_path(dstPath);

   if (!(path_capabilities(src) & VG_PATH_CAPABILITY_TRANSFORM_FROM) ||

       !(path_capabilities(dst) & VG_PATH_CAPABILITY_TRANSFORM_TO)) {

      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);

      return;

   }

   path_transform(dst, src);

}

VGboolean vegaInterpolatePath(VGPath dstPath,

                              VGPath startPath,

                              VGPath endPath,

                              VGfloat amount)

{

   struct vg_context *ctx = vg_current_context();

   struct path *start = 0, *dst = 0, *end = 0;

   if (dstPath == VG_INVALID_HANDLE ||

       startPath == VG_INVALID_HANDLE ||

       endPath == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return VG_FALSE;

   }

   dst = handle_to_path(dstPath);

   start = handle_to_path(startPath);

   end = handle_to_path(endPath);

   if (!(path_capabilities(dst) & VG_PATH_CAPABILITY_INTERPOLATE_TO) ||

       !(path_capabilities(start) & VG_PATH_CAPABILITY_INTERPOLATE_FROM) ||

       !(path_capabilities(end) & VG_PATH_CAPABILITY_INTERPOLATE_FROM)) {

      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);

      return VG_FALSE;

   }

   return path_interpolate(dst,

                           start, end, amount);

}

VGfloat vegaPathLength(VGPath path,

                       VGint startSegment,

                       VGint numSegments)

{

   struct vg_context *ctx = vg_current_context();

   struct path *p = 0;

   if (path == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return -1;

   }

   if (startSegment < 0) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return -1;

   }

   if (numSegments <= 0) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return -1;

   }

   p = handle_to_path(path);

   if (!(path_capabilities(p) & VG_PATH_CAPABILITY_PATH_LENGTH)) {

      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);

      return -1;

   }

   if (startSegment + numSegments > path_num_segments(p)) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return -1;

   }

   return path_length(p, startSegment, numSegments);

}

void vegaPointAlongPath(VGPath path,

                        VGint startSegment,

                        VGint numSegments,

                        VGfloat distance,

                        VGfloat * x, VGfloat * y,

                        VGfloat * tangentX,

                        VGfloat * tangentY)

{

   struct vg_context *ctx = vg_current_context();

   struct path *p = 0;

   VGbitfield caps;

   if (path == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return;

   }

   if (startSegment < 0) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   if (numSegments <= 0) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   if (!is_aligned(x) || !is_aligned(y) ||

       !is_aligned(tangentX) || !is_aligned(tangentY)) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   p = handle_to_path(path);

   caps = path_capabilities(p);

   if (!(caps & VG_PATH_CAPABILITY_POINT_ALONG_PATH) ||

       !(caps & VG_PATH_CAPABILITY_TANGENT_ALONG_PATH)) {

      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);

      return;

   }

   if (startSegment + numSegments > path_num_segments(p)) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   {

      VGfloat point[2], normal[2];

      path_point(p, startSegment, numSegments, distance,

                 point, normal);

      if (x)

         *x = point[0];

      if (y)

         *y = point[1];

      if (tangentX)

         *tangentX = -normal[1];

      if (tangentY)

         *tangentY = normal[0];

   }

}

void vegaPathBounds(VGPath path,

                    VGfloat * minX,

                    VGfloat * minY,

                    VGfloat * width,

                    VGfloat * height)

{

   struct vg_context *ctx = vg_current_context();

   struct path *p = 0;

   VGbitfield caps;

   if (path == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return;

   }

   if (!minX || !minY || !width || !height) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   if (!is_aligned(minX) || !is_aligned(minY) ||

       !is_aligned(width) || !is_aligned(height)) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   p = handle_to_path(path);

   caps = path_capabilities(p);

   if (!(caps & VG_PATH_CAPABILITY_PATH_BOUNDS)) {

      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);

      return;

   }

   path_bounding_rect(p, minX, minY, width, height);

}

void vegaPathTransformedBounds(VGPath path,

                               VGfloat * minX,

                               VGfloat * minY,

                               VGfloat * width,

                               VGfloat * height)

{

   struct vg_context *ctx = vg_current_context();

   struct path *p = 0;

   VGbitfield caps;

   if (path == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return;

   }

   if (!minX || !minY || !width || !height) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   if (!is_aligned(minX) || !is_aligned(minY) ||

       !is_aligned(width) || !is_aligned(height)) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   p = handle_to_path(path);

   caps = path_capabilities(p);

   if (!(caps & VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS)) {

      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);

      return;

   }

#if 0

   /* faster, but seems to have precision problems... */

   path_bounding_rect(p, minX, minY, width, height);

   if (*width > 0 && *height > 0) {

      VGfloat pts[] = {*minX,          *minY,

                       *minX + *width, *minY,

                       *minX + *width, *minY + *height,

                       *minX,          *minY + *height};

      struct matrix *matrix = &ctx->state.vg.path_user_to_surface_matrix;

      VGfloat maxX, maxY;

      matrix_map_point(matrix, pts[0], pts[1], pts + 0, pts + 1);

      matrix_map_point(matrix, pts[2], pts[3], pts + 2, pts + 3);

      matrix_map_point(matrix, pts[4], pts[5], pts + 4, pts + 5);

      matrix_map_point(matrix, pts[6], pts[7], pts + 6, pts + 7);

      *minX = MIN2(pts[0], MIN2(pts[2], MIN2(pts[4], pts[6])));

      *minY = MIN2(pts[1], MIN2(pts[3], MIN2(pts[5], pts[7])));

      maxX = MAX2(pts[0], MAX2(pts[2], MAX2(pts[4], pts[6])));

      maxY = MAX2(pts[1], MAX2(pts[3], MAX2(pts[5], pts[7])));

      *width  = maxX - *minX;

      *height = maxY - *minY;

   }

#else

   {

      struct path *dst = path_create(VG_PATH_DATATYPE_F, 1.0, 0,

                                     0, 0, VG_PATH_CAPABILITY_ALL);

      path_transform(dst, p);

      path_bounding_rect(dst, minX, minY, width, height);

      path_destroy(dst);

   }

#endif

}

void vegaDrawPath(VGPath path, VGbitfield paintModes)

{

   struct vg_context *ctx = vg_current_context();

   struct path *p = handle_to_path(path);

   if (path == VG_INVALID_HANDLE) {

      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);

      return;

   }

   if (!(paintModes & (VG_STROKE_PATH | VG_FILL_PATH))) {

      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);

      return;

   }

   if (path_is_empty(p))

      return;

   path_render(p, paintModes,

         &ctx->state.vg.path_user_to_surface_matrix);

}