/**************************************************************************
 *
 * 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 "paint.h"
#include "path.h"
#include "handle.h"
#include "image.h"
#include "text.h"
#include "matrix.h"
#include "api_consts.h"
#include "api.h"

#include "pipe/p_compiler.h"
#include "util/u_pointer.h"
#include "util/u_math.h"

#include <math.h>

static INLINE struct vg_state *current_state()
{
   struct vg_context *ctx = vg_current_context();
   if (!ctx)
      return 0;
   else
      return &ctx->state.vg;
}

static INLINE VGboolean count_in_bounds(VGParamType type, VGint count)
{
   if (count < 0)
      return VG_FALSE;

   if (type == VG_SCISSOR_RECTS)
      return (!(count % 4) && (count >= 0 || count <= VEGA_MAX_SCISSOR_RECTS * 4));
   else if (type == VG_STROKE_DASH_PATTERN) {
      return count <= VEGA_MAX_DASH_COUNT;
   } else {
      VGint real_count = vegaGetVectorSize(type);
      return count == real_count;
   }
}

void vegaSetf (VGParamType type, VGfloat value)
{
   struct vg_context *ctx = vg_current_context();
   struct vg_state *state = current_state();
   VGErrorCode error = VG_NO_ERROR;

   switch(type) {
   case VG_MATRIX_MODE:
   case VG_FILL_RULE:
   case VG_IMAGE_QUALITY:
   case VG_RENDERING_QUALITY:
   case VG_BLEND_MODE:
   case VG_IMAGE_MODE:
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM:
#endif
   case VG_STROKE_CAP_STYLE:
   case VG_STROKE_JOIN_STYLE:
   case VG_STROKE_DASH_PHASE_RESET:
   case VG_MASKING:
   case VG_SCISSORING:
   case VG_PIXEL_LAYOUT:
   case VG_SCREEN_LAYOUT:
   case VG_FILTER_FORMAT_LINEAR:
   case VG_FILTER_FORMAT_PREMULTIPLIED:
   case VG_FILTER_CHANNEL_MASK:

   case VG_MAX_SCISSOR_RECTS:
   case VG_MAX_DASH_COUNT:
   case VG_MAX_KERNEL_SIZE:
   case VG_MAX_SEPARABLE_KERNEL_SIZE:
   case VG_MAX_COLOR_RAMP_STOPS:
   case VG_MAX_IMAGE_WIDTH:
   case VG_MAX_IMAGE_HEIGHT:
   case VG_MAX_IMAGE_PIXELS:
   case VG_MAX_IMAGE_BYTES:
   case VG_MAX_GAUSSIAN_STD_DEVIATION:
   case VG_MAX_FLOAT:
      vegaSeti(type, floor(value));
      return;
      break;
   case VG_STROKE_LINE_WIDTH:
      state->stroke.line_width.f = value;
      state->stroke.line_width.i = float_to_int_floor(*((VGuint*)(&value)));
      break;
   case VG_STROKE_MITER_LIMIT:
      state->stroke.miter_limit.f = value;
      state->stroke.miter_limit.i = float_to_int_floor(*((VGuint*)(&value)));
      break;
   case VG_STROKE_DASH_PHASE:
      state->stroke.dash_phase.f = value;
      state->stroke.dash_phase.i = float_to_int_floor(*((VGuint*)(&value)));
      break;
   default:
      error = VG_ILLEGAL_ARGUMENT_ERROR;
      break;
   }
   vg_set_error(ctx, error);
}

void vegaSeti (VGParamType type, VGint value)
{
   struct vg_context *ctx = vg_current_context();
   struct vg_state *state = current_state();
   VGErrorCode error = VG_NO_ERROR;

   switch(type) {
   case VG_MATRIX_MODE:
      if (value < VG_MATRIX_PATH_USER_TO_SURFACE ||
#ifdef OPENVG_VERSION_1_1
          value > VG_MATRIX_GLYPH_USER_TO_SURFACE)
#else
          value > VG_MATRIX_STROKE_PAINT_TO_USER)
#endif
         error = VG_ILLEGAL_ARGUMENT_ERROR;
      else
         state->matrix_mode = value;
      break;
   case VG_FILL_RULE:
      if (value < VG_EVEN_ODD ||
          value > VG_NON_ZERO)
         error = VG_ILLEGAL_ARGUMENT_ERROR;
      else
         state->fill_rule = value;
      break;
   case VG_IMAGE_QUALITY:
      state->image_quality = value;
      break;
   case VG_RENDERING_QUALITY:
      if (value < VG_RENDERING_QUALITY_NONANTIALIASED ||
          value > VG_RENDERING_QUALITY_BETTER)
         error = VG_ILLEGAL_ARGUMENT_ERROR;
      else
         state->rendering_quality = value;
      break;
   case VG_BLEND_MODE:
      if (value < VG_BLEND_SRC ||
          value > VG_BLEND_ADDITIVE)
         error = VG_ILLEGAL_ARGUMENT_ERROR;
      else {
         ctx->state.dirty |= BLEND_DIRTY;
         state->blend_mode = value;
      }
      break;
   case VG_IMAGE_MODE:
      if (value < VG_DRAW_IMAGE_NORMAL ||
          value > VG_DRAW_IMAGE_STENCIL)
         error = VG_ILLEGAL_ARGUMENT_ERROR;
      else
         state->image_mode = value;
      break;
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM:
      state->color_transform = value;
#endif
      break;
   case VG_STROKE_LINE_WIDTH:
      state->stroke.line_width.f = value;
      state->stroke.line_width.i = value;
      break;
   case VG_STROKE_CAP_STYLE:
      if (value < VG_CAP_BUTT ||
          value > VG_CAP_SQUARE)
         error = VG_ILLEGAL_ARGUMENT_ERROR;
      else
         state->stroke.cap_style = value;
      break;
   case VG_STROKE_JOIN_STYLE:
      if (value < VG_JOIN_MITER ||
          value > VG_JOIN_BEVEL)
         error = VG_ILLEGAL_ARGUMENT_ERROR;
      else
         state->stroke.join_style = value;
      break;
   case VG_STROKE_MITER_LIMIT:
      state->stroke.miter_limit.f = value;
      state->stroke.miter_limit.i = value;
      break;
   case VG_STROKE_DASH_PHASE:
      state->stroke.dash_phase.f = value;
      state->stroke.dash_phase.i = value;
      break;
   case VG_STROKE_DASH_PHASE_RESET:
      state->stroke.dash_phase_reset = value;
      break;
   case VG_MASKING:
      state->masking = value;
      break;
   case VG_SCISSORING:
      state->scissoring = value;
      ctx->state.dirty |= DEPTH_STENCIL_DIRTY;
      break;
   case VG_PIXEL_LAYOUT:
      if (value < VG_PIXEL_LAYOUT_UNKNOWN ||
          value > VG_PIXEL_LAYOUT_BGR_HORIZONTAL)
         error = VG_ILLEGAL_ARGUMENT_ERROR;
      else
         state->pixel_layout = value;
      break;
   case VG_SCREEN_LAYOUT:
      /* read only ignore */
      break;
   case VG_FILTER_FORMAT_LINEAR:
      state->filter_format_linear = value;
      break;
   case VG_FILTER_FORMAT_PREMULTIPLIED:
      state->filter_format_premultiplied = value;
      break;
   case VG_FILTER_CHANNEL_MASK:
      state->filter_channel_mask = value;
      break;

   case VG_MAX_SCISSOR_RECTS:
   case VG_MAX_DASH_COUNT:
   case VG_MAX_KERNEL_SIZE:
   case VG_MAX_SEPARABLE_KERNEL_SIZE:
   case VG_MAX_COLOR_RAMP_STOPS:
   case VG_MAX_IMAGE_WIDTH:
   case VG_MAX_IMAGE_HEIGHT:
   case VG_MAX_IMAGE_PIXELS:
   case VG_MAX_IMAGE_BYTES:
   case VG_MAX_GAUSSIAN_STD_DEVIATION:
   case VG_MAX_FLOAT:
      /* read only ignore */
      break;
   default:
      error = VG_ILLEGAL_ARGUMENT_ERROR;
      break;
   }
   vg_set_error(ctx, error);
}

void vegaSetfv(VGParamType type, VGint count,
               const VGfloat * values)
{
   struct vg_context *ctx = vg_current_context();
   struct vg_state *state = current_state();
   VGErrorCode error = VG_NO_ERROR;

   if ((count && !values) || !count_in_bounds(type, count) || !is_aligned(values)) {
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      return;
   }

   switch(type) {
   case VG_MATRIX_MODE:
   case VG_FILL_RULE:
   case VG_IMAGE_QUALITY:
   case VG_RENDERING_QUALITY:
   case VG_BLEND_MODE:
   case VG_IMAGE_MODE:
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM:
#endif
   case VG_STROKE_CAP_STYLE:
   case VG_STROKE_JOIN_STYLE:
   case VG_STROKE_DASH_PHASE_RESET:
   case VG_MASKING:
   case VG_SCISSORING:
   case VG_PIXEL_LAYOUT:
   case VG_SCREEN_LAYOUT:
   case VG_FILTER_FORMAT_LINEAR:
   case VG_FILTER_FORMAT_PREMULTIPLIED:
   case VG_FILTER_CHANNEL_MASK:
      vegaSeti(type, floor(values[0]));
      return;
      break;
   case VG_SCISSOR_RECTS: {
      VGint i;
      VGuint *x = (VGuint*)values;
      for (i = 0; i < count; ++i) {
         state->scissor_rects[i].f =  values[i];
         state->scissor_rects[i].i =  float_to_int_floor(x[i]);
      }
      state->scissor_rects_num = count / 4;
      ctx->state.dirty |= DEPTH_STENCIL_DIRTY;
   }
      break;
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM_VALUES: {
      VGint i;
      for (i = 0; i < count; ++i) {
         state->color_transform_values[i] =  values[i];
      }
   }
      break;
#endif
   case VG_STROKE_LINE_WIDTH:
      state->stroke.line_width.f = values[0];
      state->stroke.line_width.i = float_to_int_floor(*((VGuint*)(values)));
      break;
   case VG_STROKE_MITER_LIMIT:
      state->stroke.miter_limit.f = values[0];
      state->stroke.miter_limit.i = float_to_int_floor(*((VGuint*)(values)));
      break;
   case VG_STROKE_DASH_PATTERN: {
      int i;
      for (i = 0; i < count; ++i) {
         state->stroke.dash_pattern[i].f = values[i];
         state->stroke.dash_pattern[i].i =
            float_to_int_floor(*((VGuint*)(values + i)));
      }
      state->stroke.dash_pattern_num = count;
   }
      break;
   case VG_STROKE_DASH_PHASE:
      state->stroke.dash_phase.f = values[0];
      state->stroke.dash_phase.i = float_to_int_floor(*((VGuint*)(values)));
      break;
   case VG_TILE_FILL_COLOR:
      state->tile_fill_color[0] = values[0];
      state->tile_fill_color[1] = values[1];
      state->tile_fill_color[2] = values[2];
      state->tile_fill_color[3] = values[3];

      state->tile_fill_colori[0] = float_to_int_floor(*((VGuint*)(values + 0)));
      state->tile_fill_colori[1] = float_to_int_floor(*((VGuint*)(values + 1)));
      state->tile_fill_colori[2] = float_to_int_floor(*((VGuint*)(values + 2)));
      state->tile_fill_colori[3] = float_to_int_floor(*((VGuint*)(values + 3)));
      break;
   case VG_CLEAR_COLOR:
      state->clear_color[0] = values[0];
      state->clear_color[1] = values[1];
      state->clear_color[2] = values[2];
      state->clear_color[3] = values[3];

      state->clear_colori[0] = float_to_int_floor(*((VGuint*)(values + 0)));
      state->clear_colori[1] = float_to_int_floor(*((VGuint*)(values + 1)));
      state->clear_colori[2] = float_to_int_floor(*((VGuint*)(values + 2)));
      state->clear_colori[3] = float_to_int_floor(*((VGuint*)(values + 3)));
      break;
#ifdef OPENVG_VERSION_1_1
   case VG_GLYPH_ORIGIN:
      state->glyph_origin[0].f = values[0];
      state->glyph_origin[1].f = values[1];

      state->glyph_origin[0].i = float_to_int_floor(*((VGuint*)(values + 0)));
      state->glyph_origin[1].i = float_to_int_floor(*((VGuint*)(values + 1)));
      break;
#endif

   case VG_MAX_SCISSOR_RECTS:
   case VG_MAX_DASH_COUNT:
   case VG_MAX_KERNEL_SIZE:
   case VG_MAX_SEPARABLE_KERNEL_SIZE:
   case VG_MAX_COLOR_RAMP_STOPS:
   case VG_MAX_IMAGE_WIDTH:
   case VG_MAX_IMAGE_HEIGHT:
   case VG_MAX_IMAGE_PIXELS:
   case VG_MAX_IMAGE_BYTES:
   case VG_MAX_GAUSSIAN_STD_DEVIATION:
   case VG_MAX_FLOAT:
      break;
   default:
      error = VG_ILLEGAL_ARGUMENT_ERROR;
      break;
   }
   vg_set_error(ctx, error);
}

void vegaSetiv(VGParamType type, VGint count,
               const VGint * values)
{
   struct vg_context *ctx = vg_current_context();
   struct vg_state *state = current_state();

   if ((count && !values) || !count_in_bounds(type, count) || !is_aligned(values)) {
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      return;
   }

   switch(type) {
   case VG_MATRIX_MODE:
   case VG_FILL_RULE:
   case VG_IMAGE_QUALITY:
   case VG_RENDERING_QUALITY:
   case VG_BLEND_MODE:
   case VG_IMAGE_MODE:
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM:
#endif
   case VG_STROKE_CAP_STYLE:
   case VG_STROKE_JOIN_STYLE:
   case VG_STROKE_DASH_PHASE_RESET:
   case VG_MASKING:
   case VG_SCISSORING:
   case VG_PIXEL_LAYOUT:
   case VG_SCREEN_LAYOUT:
   case VG_FILTER_FORMAT_LINEAR:
   case VG_FILTER_FORMAT_PREMULTIPLIED:
   case VG_FILTER_CHANNEL_MASK:
      vegaSeti(type, values[0]);
      return;
      break;
   case VG_SCISSOR_RECTS: {
      VGint i;
      for (i = 0; i < count; ++i) {
         state->scissor_rects[i].i =  values[i];
         state->scissor_rects[i].f =  values[i];
      }
      state->scissor_rects_num = count / 4;
      ctx->state.dirty |= DEPTH_STENCIL_DIRTY;
   }
      break;
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM_VALUES: {
      VGint i;
      for (i = 0; i < count; ++i) {
         state->color_transform_values[i] =  values[i];
      }
   }
      break;
#endif
   case VG_STROKE_LINE_WIDTH:
      state->stroke.line_width.f = values[0];
      state->stroke.line_width.i = values[0];
      break;
   case VG_STROKE_MITER_LIMIT:
      state->stroke.miter_limit.f = values[0];
      state->stroke.miter_limit.i = values[0];
      break;
   case VG_STROKE_DASH_PATTERN: {
      int i;
      for (i = 0; i < count; ++i) {
         state->stroke.dash_pattern[i].f = values[i];
         state->stroke.dash_pattern[i].i = values[i];
      }
      state->stroke.dash_pattern_num = count;
   }
      break;
   case VG_STROKE_DASH_PHASE:
      state->stroke.dash_phase.f = values[0];
      state->stroke.dash_phase.i = values[0];
      break;
   case VG_TILE_FILL_COLOR:
      state->tile_fill_color[0] = values[0];
      state->tile_fill_color[1] = values[1];
      state->tile_fill_color[2] = values[2];
      state->tile_fill_color[3] = values[3];

      state->tile_fill_colori[0] = values[0];
      state->tile_fill_colori[1] = values[1];
      state->tile_fill_colori[2] = values[2];
      state->tile_fill_colori[3] = values[3];
      break;
   case VG_CLEAR_COLOR:
      state->clear_color[0] = values[0];
      state->clear_color[1] = values[1];
      state->clear_color[2] = values[2];
      state->clear_color[3] = values[3];

      state->clear_colori[0] = values[0];
      state->clear_colori[1] = values[1];
      state->clear_colori[2] = values[2];
      state->clear_colori[3] = values[3];
      break;
#ifdef OPENVG_VERSION_1_1
   case VG_GLYPH_ORIGIN:
      state->glyph_origin[0].f = values[0];
      state->glyph_origin[1].f = values[1];
      state->glyph_origin[0].i = values[0];
      state->glyph_origin[1].i = values[1];
      break;
#endif

   case VG_MAX_SCISSOR_RECTS:
   case VG_MAX_DASH_COUNT:
   case VG_MAX_KERNEL_SIZE:
   case VG_MAX_SEPARABLE_KERNEL_SIZE:
   case VG_MAX_COLOR_RAMP_STOPS:
   case VG_MAX_IMAGE_WIDTH:
   case VG_MAX_IMAGE_HEIGHT:
   case VG_MAX_IMAGE_PIXELS:
   case VG_MAX_IMAGE_BYTES:
   case VG_MAX_GAUSSIAN_STD_DEVIATION:
   case VG_MAX_FLOAT:
      break;

   default:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;
   }
}

VGfloat vegaGetf(VGParamType type)
{
   struct vg_context *ctx = vg_current_context();
   const struct vg_state *state = current_state();
   VGErrorCode error = VG_NO_ERROR;
   VGfloat value = 0.0f;

   switch(type) {
   case VG_MATRIX_MODE:
   case VG_FILL_RULE:
   case VG_IMAGE_QUALITY:
   case VG_RENDERING_QUALITY:
   case VG_BLEND_MODE:
   case VG_IMAGE_MODE:
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM:
#endif
   case VG_STROKE_CAP_STYLE:
   case VG_STROKE_JOIN_STYLE:
   case VG_STROKE_DASH_PHASE_RESET:
   case VG_MASKING:
   case VG_SCISSORING:
   case VG_PIXEL_LAYOUT:
   case VG_SCREEN_LAYOUT:
   case VG_FILTER_FORMAT_LINEAR:
   case VG_FILTER_FORMAT_PREMULTIPLIED:
   case VG_FILTER_CHANNEL_MASK:
      return vegaGeti(type);
      break;
   case VG_STROKE_LINE_WIDTH:
      value = state->stroke.line_width.f;
      break;
   case VG_STROKE_MITER_LIMIT:
      value = state->stroke.miter_limit.f;
      break;
   case VG_STROKE_DASH_PHASE:
      value = state->stroke.dash_phase.f;
      break;

   case VG_MAX_SCISSOR_RECTS:
   case VG_MAX_DASH_COUNT:
   case VG_MAX_KERNEL_SIZE:
   case VG_MAX_SEPARABLE_KERNEL_SIZE:
   case VG_MAX_COLOR_RAMP_STOPS:
   case VG_MAX_IMAGE_WIDTH:
   case VG_MAX_IMAGE_HEIGHT:
   case VG_MAX_IMAGE_PIXELS:
   case VG_MAX_IMAGE_BYTES:
   case VG_MAX_GAUSSIAN_STD_DEVIATION:
      return vegaGeti(type);
      break;
   case VG_MAX_FLOAT:
      value = 1e+10;/*must be at least 1e+10*/
      break;
   default:
      error = VG_ILLEGAL_ARGUMENT_ERROR;
      break;
   }
   vg_set_error(ctx, error);
   return value;
}

VGint vegaGeti(VGParamType type)
{
   const struct vg_state *state = current_state();
   struct vg_context *ctx = vg_current_context();
   VGErrorCode error = VG_NO_ERROR;
   VGint value = 0;

   switch(type) {
   case VG_MATRIX_MODE:
      value = state->matrix_mode;
      break;
   case VG_FILL_RULE:
      value = state->fill_rule;
      break;
   case VG_IMAGE_QUALITY:
      value = state->image_quality;
      break;
   case VG_RENDERING_QUALITY:
      value = state->rendering_quality;
      break;
   case VG_BLEND_MODE:
      value = state->blend_mode;
      break;
   case VG_IMAGE_MODE:
      value = state->image_mode;
      break;
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM:
      value = state->color_transform;
      break;
#endif
   case VG_STROKE_LINE_WIDTH:
      value = state->stroke.line_width.i;
      break;
   case VG_STROKE_CAP_STYLE:
      value = state->stroke.cap_style;
      break;
   case VG_STROKE_JOIN_STYLE:
      value = state->stroke.join_style;
      break;
   case VG_STROKE_MITER_LIMIT:
      value = state->stroke.miter_limit.i;
      break;
   case VG_STROKE_DASH_PHASE:
      value = state->stroke.dash_phase.i;
      break;
   case VG_STROKE_DASH_PHASE_RESET:
      value = state->stroke.dash_phase_reset;
      break;
   case VG_MASKING:
      value = state->masking;
      break;
   case VG_SCISSORING:
      value = state->scissoring;
      break;
   case VG_PIXEL_LAYOUT:
      value = state->pixel_layout;
      break;
   case VG_SCREEN_LAYOUT:
      value = state->screen_layout;
      break;
   case VG_FILTER_FORMAT_LINEAR:
      value = state->filter_format_linear;
      break;
   case VG_FILTER_FORMAT_PREMULTIPLIED:
      value = state->filter_format_premultiplied;
      break;
   case VG_FILTER_CHANNEL_MASK:
      value = state->filter_channel_mask;
      break;

   case VG_MAX_SCISSOR_RECTS:
      value = 32; /*must be at least 32*/
      break;
   case VG_MAX_DASH_COUNT:
      value = 16; /*must be at least 16*/
      break;
   case VG_MAX_KERNEL_SIZE:
      value = 7; /*must be at least 7*/
      break;
   case VG_MAX_SEPARABLE_KERNEL_SIZE:
      value = 15; /*must be at least 15*/
      break;
   case VG_MAX_COLOR_RAMP_STOPS:
      value = 256; /*must be at least 32*/
      break;
   case VG_MAX_IMAGE_WIDTH:
      value = 2048;
      break;
   case VG_MAX_IMAGE_HEIGHT:
      value = 2048;
      break;
   case VG_MAX_IMAGE_PIXELS:
      value = 2048*2048;
      break;
   case VG_MAX_IMAGE_BYTES:
      value = 2048*2048 * 4;
      break;
   case VG_MAX_GAUSSIAN_STD_DEVIATION:
      value = 128; /*must be at least 128*/
      break;

   case VG_MAX_FLOAT: {
      VGfloat val = vegaGetf(type);
      value = float_to_int_floor(*((VGuint*)&val));
   }
      break;
   default:
      error = VG_ILLEGAL_ARGUMENT_ERROR;
      break;
   }
   vg_set_error(ctx, error);
   return value;
}

VGint vegaGetVectorSize(VGParamType type)
{
   struct vg_context *ctx = vg_current_context();
   const struct vg_state *state = current_state();
   switch(type) {
   case VG_MATRIX_MODE:
   case VG_FILL_RULE:
   case VG_IMAGE_QUALITY:
   case VG_RENDERING_QUALITY:
   case VG_BLEND_MODE:
   case VG_IMAGE_MODE:
      return 1;
   case VG_SCISSOR_RECTS:
      return state->scissor_rects_num * 4;
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM:
      return 1;
   case VG_COLOR_TRANSFORM_VALUES:
      return 8;
#endif
   case VG_STROKE_LINE_WIDTH:
   case VG_STROKE_CAP_STYLE:
   case VG_STROKE_JOIN_STYLE:
   case VG_STROKE_MITER_LIMIT:
      return 1;
   case VG_STROKE_DASH_PATTERN:
      return state->stroke.dash_pattern_num;
   case VG_STROKE_DASH_PHASE:
      return 1;
   case VG_STROKE_DASH_PHASE_RESET:
      return 1;
   case VG_TILE_FILL_COLOR:
      return 4;
   case VG_CLEAR_COLOR:
      return 4;
#ifdef OPENVG_VERSION_1_1
   case VG_GLYPH_ORIGIN:
      return 2;
#endif
   case VG_MASKING:
      return 1;
   case VG_SCISSORING:
      return 1;
   case VG_PIXEL_LAYOUT:
      return 1;
   case VG_SCREEN_LAYOUT:
      return 1;
   case VG_FILTER_FORMAT_LINEAR:
      return 1;
   case VG_FILTER_FORMAT_PREMULTIPLIED:
      return 1;
   case VG_FILTER_CHANNEL_MASK:
      return 1;

   case VG_MAX_COLOR_RAMP_STOPS:
      return 1;
   case VG_MAX_SCISSOR_RECTS:
   case VG_MAX_DASH_COUNT:
   case VG_MAX_KERNEL_SIZE:
   case VG_MAX_SEPARABLE_KERNEL_SIZE:
   case VG_MAX_IMAGE_WIDTH:
   case VG_MAX_IMAGE_HEIGHT:
   case VG_MAX_IMAGE_PIXELS:
   case VG_MAX_IMAGE_BYTES:
   case VG_MAX_FLOAT:
   case VG_MAX_GAUSSIAN_STD_DEVIATION:
      return 1;
   default:
      if (ctx)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      return 0;
   }
}

void vegaGetfv(VGParamType type, VGint count,
               VGfloat * values)
{
   const struct vg_state *state = current_state();
   struct vg_context *ctx = vg_current_context();
   VGint real_count = vegaGetVectorSize(type);

   if (!values || count <= 0 || count > real_count || !is_aligned(values)) {
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      return;
   }

   switch(type) {
   case VG_MATRIX_MODE:
   case VG_FILL_RULE:
   case VG_IMAGE_QUALITY:
   case VG_RENDERING_QUALITY:
   case VG_BLEND_MODE:
   case VG_IMAGE_MODE:
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM:
#endif
   case VG_STROKE_CAP_STYLE:
   case VG_STROKE_JOIN_STYLE:
   case VG_STROKE_DASH_PHASE_RESET:
   case VG_MASKING:
   case VG_SCISSORING:
   case VG_PIXEL_LAYOUT:
   case VG_SCREEN_LAYOUT:
   case VG_FILTER_FORMAT_LINEAR:
   case VG_FILTER_FORMAT_PREMULTIPLIED:
   case VG_FILTER_CHANNEL_MASK:
   case VG_MAX_SCISSOR_RECTS:
   case VG_MAX_DASH_COUNT:
   case VG_MAX_KERNEL_SIZE:
   case VG_MAX_SEPARABLE_KERNEL_SIZE:
   case VG_MAX_COLOR_RAMP_STOPS:
   case VG_MAX_IMAGE_WIDTH:
   case VG_MAX_IMAGE_HEIGHT:
   case VG_MAX_IMAGE_PIXELS:
   case VG_MAX_IMAGE_BYTES:
   case VG_MAX_GAUSSIAN_STD_DEVIATION:
      values[0] = vegaGeti(type);
      break;
   case VG_MAX_FLOAT:
      values[0] = vegaGetf(type);
      break;
   case VG_SCISSOR_RECTS: {
      VGint i;
      for (i = 0; i < count; ++i) {
         values[i] = state->scissor_rects[i].f;
      }
   }
      break;
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM_VALUES: {
      memcpy(values, state->color_transform_values,
             sizeof(VGfloat) * count);
   }
      break;
#endif
   case VG_STROKE_LINE_WIDTH:
      values[0] = state->stroke.line_width.f;
      break;
   case VG_STROKE_MITER_LIMIT:
      values[0] = state->stroke.miter_limit.f;
      break;
   case VG_STROKE_DASH_PATTERN: {
      VGint i;
      for (i = 0; i < count; ++i) {
         values[i] = state->stroke.dash_pattern[i].f;
      }
   }
      break;
   case VG_STROKE_DASH_PHASE:
      values[0] = state->stroke.dash_phase.f;
      break;
   case VG_TILE_FILL_COLOR:
      values[0] = state->tile_fill_color[0];
      values[1] = state->tile_fill_color[1];
      values[2] = state->tile_fill_color[2];
      values[3] = state->tile_fill_color[3];
      break;
   case VG_CLEAR_COLOR:
      values[0] = state->clear_color[0];
      values[1] = state->clear_color[1];
      values[2] = state->clear_color[2];
      values[3] = state->clear_color[3];
      break;
#ifdef OPENVG_VERSION_1_1
   case VG_GLYPH_ORIGIN:
      values[0] = state->glyph_origin[0].f;
      values[1] = state->glyph_origin[1].f;
      break;
#endif
   default:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;
   }
}

void vegaGetiv(VGParamType type, VGint count,
               VGint * values)
{
   const struct vg_state *state = current_state();
   struct vg_context *ctx = vg_current_context();
   VGint real_count = vegaGetVectorSize(type);

   if (!values || count <= 0 || count > real_count || !is_aligned(values)) {
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      return;
   }

   switch(type) {
   case VG_MATRIX_MODE:
   case VG_FILL_RULE:
   case VG_IMAGE_QUALITY:
   case VG_RENDERING_QUALITY:
   case VG_BLEND_MODE:
   case VG_IMAGE_MODE:
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM:
#endif
   case VG_STROKE_CAP_STYLE:
   case VG_STROKE_JOIN_STYLE:
   case VG_STROKE_DASH_PHASE_RESET:
   case VG_MASKING:
   case VG_SCISSORING:
   case VG_PIXEL_LAYOUT:
   case VG_SCREEN_LAYOUT:
   case VG_FILTER_FORMAT_LINEAR:
   case VG_FILTER_FORMAT_PREMULTIPLIED:
   case VG_FILTER_CHANNEL_MASK:
   case VG_MAX_SCISSOR_RECTS:
   case VG_MAX_DASH_COUNT:
   case VG_MAX_KERNEL_SIZE:
   case VG_MAX_SEPARABLE_KERNEL_SIZE:
   case VG_MAX_COLOR_RAMP_STOPS:
   case VG_MAX_IMAGE_WIDTH:
   case VG_MAX_IMAGE_HEIGHT:
   case VG_MAX_IMAGE_PIXELS:
   case VG_MAX_IMAGE_BYTES:
   case VG_MAX_GAUSSIAN_STD_DEVIATION:
      values[0] = vegaGeti(type);
      break;
   case VG_MAX_FLOAT: {
      VGfloat val = vegaGetf(type);
      values[0] = float_to_int_floor(*((VGuint*)&val));
   }
      break;
   case VG_SCISSOR_RECTS: {
      VGint i;
      for (i = 0; i < count; ++i) {
         values[i] = state->scissor_rects[i].i;
      }
   }
      break;
#ifdef OPENVG_VERSION_1_1
   case VG_COLOR_TRANSFORM_VALUES: {
      VGint i;
      VGuint *x = (VGuint*)state->color_transform_values;
      for (i = 0; i < count; ++i) {
         values[i] = float_to_int_floor(x[i]);
      }
   }
      break;
#endif
   case VG_STROKE_LINE_WIDTH:
      values[0] = state->stroke.line_width.i;
      break;
   case VG_STROKE_MITER_LIMIT:
      values[0] = state->stroke.miter_limit.i;
      break;
   case VG_STROKE_DASH_PATTERN: {
      VGint i;
      for (i = 0; i < count; ++i) {
         values[i] = state->stroke.dash_pattern[i].i;
      }
   }
      break;
   case VG_STROKE_DASH_PHASE:
      values[0] = state->stroke.dash_phase.i;
      break;
   case VG_TILE_FILL_COLOR:
      values[0] = state->tile_fill_colori[0];
      values[1] = state->tile_fill_colori[1];
      values[2] = state->tile_fill_colori[2];
      values[3] = state->tile_fill_colori[3];
      break;
   case VG_CLEAR_COLOR:
      values[0] = state->clear_colori[0];
      values[1] = state->clear_colori[1];
      values[2] = state->clear_colori[2];
      values[3] = state->clear_colori[3];
      break;
#ifdef OPENVG_VERSION_1_1
   case VG_GLYPH_ORIGIN:
      values[0] = state->glyph_origin[0].i;
      values[1] = state->glyph_origin[1].i;
      break;
#endif
   default:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;
   }
}

void vegaSetParameterf(VGHandle object,
                       VGint paramType,
                       VGfloat value)
{
   struct vg_context *ctx = vg_current_context();
   void *ptr = handle_to_pointer(object);

   if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
      return;
   }

   switch(paramType) {
   case VG_PAINT_TYPE:
   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
   case VG_PAINT_PATTERN_TILING_MODE:
      vegaSetParameteri(object, paramType, floor(value));
      return;
      break;
   case VG_PAINT_COLOR:
   case VG_PAINT_COLOR_RAMP_STOPS:
   case VG_PAINT_LINEAR_GRADIENT:
   case VG_PAINT_RADIAL_GRADIENT:
      /* it's an error if paramType refers to a vector parameter */
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;
   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
      struct vg_paint *p = handle_to_paint(object);
      paint_set_color_ramp_premultiplied(p, value);
   }
      break;

   case VG_PATH_DATATYPE:
   case VG_PATH_FORMAT:
   case VG_PATH_SCALE:
   case VG_PATH_BIAS:
   case VG_PATH_NUM_SEGMENTS:
   case VG_PATH_NUM_COORDS:

   case VG_IMAGE_FORMAT:
   case VG_IMAGE_WIDTH:
   case VG_IMAGE_HEIGHT:

#ifdef OPENVG_VERSION_1_1
   case VG_FONT_NUM_GLYPHS:
      /* read only don't produce an error */
      break;
#endif
   default:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;
   }
}

void vegaSetParameteri(VGHandle object,
                       VGint paramType,
                       VGint value)
{
   struct vg_context *ctx = vg_current_context();
   void *ptr = handle_to_pointer(object);

   if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
      return;
   }

   switch(paramType) {
   case VG_PAINT_TYPE:
      if (value < VG_PAINT_TYPE_COLOR ||
          value > VG_PAINT_TYPE_PATTERN)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else {
         struct vg_paint *paint = handle_to_paint(object);
         paint_set_type(paint, value);
      }
      break;
   case VG_PAINT_COLOR:
   case VG_PAINT_COLOR_RAMP_STOPS:
   case VG_PAINT_LINEAR_GRADIENT:
   case VG_PAINT_RADIAL_GRADIENT:
      /* it's an error if paramType refers to a vector parameter */
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;
   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
      if (value < VG_COLOR_RAMP_SPREAD_PAD ||
          value > VG_COLOR_RAMP_SPREAD_REFLECT)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else {
         struct vg_paint *paint = handle_to_paint(object);
         paint_set_spread_mode(paint, value);
      }
      break;
   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
      struct vg_paint *p = handle_to_paint(object);
      paint_set_color_ramp_premultiplied(p, value);
   }
      break;
   case VG_PAINT_PATTERN_TILING_MODE:
      if (value < VG_TILE_FILL ||
          value > VG_TILE_REFLECT)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else {
         struct vg_paint *paint = handle_to_paint(object);
         paint_set_pattern_tiling(paint, value);
      }
      break;

   case VG_PATH_DATATYPE:
   case VG_PATH_FORMAT:
   case VG_PATH_SCALE:
   case VG_PATH_BIAS:
   case VG_PATH_NUM_SEGMENTS:
   case VG_PATH_NUM_COORDS:

   case VG_IMAGE_FORMAT:
   case VG_IMAGE_WIDTH:
   case VG_IMAGE_HEIGHT:

#ifdef OPENVG_VERSION_1_1
   case VG_FONT_NUM_GLYPHS:
      /* read only don't produce an error */
      break;
#endif
   default:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      return;
   }
}

void vegaSetParameterfv(VGHandle object,
                        VGint paramType,
                        VGint count,
                        const VGfloat * values)
{
   struct vg_context *ctx = vg_current_context();
   void *ptr = handle_to_pointer(object);
   VGint real_count = vegaGetParameterVectorSize(object, paramType);

   if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
      return;
   }

   if (count < 0 || count < real_count ||
       (values == NULL && count != 0) ||
       !is_aligned(values)) {
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      return;
   }

   switch(paramType) {
   case VG_PAINT_TYPE:
   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
   case VG_PAINT_PATTERN_TILING_MODE:
      if (count != 1)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else
         vegaSetParameterf(object, paramType, values[0]);
      return;
      break;
   case VG_PAINT_COLOR: {
      if (count != 4)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else {
         struct vg_paint *paint = handle_to_paint(object);
         paint_set_color(paint, values);
         if (ctx->state.vg.fill_paint == paint ||
             ctx->state.vg.stroke_paint == paint)
            ctx->state.dirty |= PAINT_DIRTY;
      }
   }
      break;
   case VG_PAINT_COLOR_RAMP_STOPS: {
      if (count && count < 4)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else {
         struct vg_paint *paint = handle_to_paint(object);
         count = MIN2(count, VEGA_MAX_COLOR_RAMP_STOPS);
         paint_set_ramp_stops(paint, values, count);
         {
            VGint stopsi[VEGA_MAX_COLOR_RAMP_STOPS];
            int i = 0;
            for (i = 0; i < count; ++i) {
               stopsi[i] = float_to_int_floor(*((VGuint*)(values + i)));
            }
            paint_set_ramp_stopsi(paint, stopsi, count);
         }
      }
   }
      break;
   case VG_PAINT_LINEAR_GRADIENT: {
      if (count != 4)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else {
         struct vg_paint *paint = handle_to_paint(object);
         paint_set_linear_gradient(paint, values);
         {
            VGint vals[4];
            vals[0] = FLT_TO_INT(values[0]);
            vals[1] = FLT_TO_INT(values[1]);
            vals[2] = FLT_TO_INT(values[2]);
            vals[3] = FLT_TO_INT(values[3]);
            paint_set_linear_gradienti(paint, vals);
         }
      }
   }
      break;
   case VG_PAINT_RADIAL_GRADIENT: {
      if (count != 5)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else {
         struct vg_paint *paint = handle_to_paint(object);
         paint_set_radial_gradient(paint, values);
         {
            VGint vals[5];
            vals[0] = FLT_TO_INT(values[0]);
            vals[1] = FLT_TO_INT(values[1]);
            vals[2] = FLT_TO_INT(values[2]);
            vals[3] = FLT_TO_INT(values[3]);
            vals[4] = FLT_TO_INT(values[4]);
            paint_set_radial_gradienti(paint, vals);
         }
      }
   }
      break;

   case VG_PATH_DATATYPE:
   case VG_PATH_FORMAT:
   case VG_PATH_SCALE:
   case VG_PATH_BIAS:
   case VG_PATH_NUM_SEGMENTS:
   case VG_PATH_NUM_COORDS:

#ifdef OPENVG_VERSION_1_1
   case VG_FONT_NUM_GLYPHS:
      /* read only don't produce an error */
      break;
#endif
   default:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      return;
   }
}

void vegaSetParameteriv(VGHandle object,
                        VGint paramType,
                        VGint count,
                        const VGint * values)
{
   struct vg_context *ctx = vg_current_context();
   void *ptr = handle_to_pointer(object);
   VGint real_count = vegaGetParameterVectorSize(object, paramType);

   if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
      return;
   }

   if (count < 0 || count < real_count ||
       (values == NULL && count != 0) ||
       !is_aligned(values)) {
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      return;
   }

   switch(paramType) {
   case VG_PAINT_TYPE:
   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
   case VG_PAINT_PATTERN_TILING_MODE:
      if (count != 1)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else
         vegaSetParameteri(object, paramType, values[0]);
      return;
      break;
   case VG_PAINT_COLOR: {
      if (count != 4)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else {
         struct vg_paint *paint = handle_to_paint(object);
         paint_set_coloriv(paint, values);
         if (ctx->state.vg.fill_paint == paint ||
             ctx->state.vg.stroke_paint == paint)
            ctx->state.dirty |= PAINT_DIRTY;
      }
   }
      break;
   case VG_PAINT_COLOR_RAMP_STOPS: {
      if ((count % 5))
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else {
         VGfloat *vals = 0;
         int i;
         struct vg_paint *paint = handle_to_paint(object);
         if (count) {
            vals = malloc(sizeof(VGfloat)*count);
            for (i = 0; i < count; ++i)
               vals[i] = values[i];
         }

         paint_set_ramp_stopsi(paint, values, count);
         paint_set_ramp_stops(paint, vals, count);
         free(vals);
      }
   }
      break;
   case VG_PAINT_LINEAR_GRADIENT: {
      if (count != 4)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else {
         VGfloat vals[4];
         struct vg_paint *paint = handle_to_paint(object);
         vals[0] = values[0];
         vals[1] = values[1];
         vals[2] = values[2];
         vals[3] = values[3];
         paint_set_linear_gradient(paint, vals);
         paint_set_linear_gradienti(paint, values);
      }
   }
      break;
   case VG_PAINT_RADIAL_GRADIENT: {
      if (count != 5)
         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      else {
         VGfloat vals[5];
         struct vg_paint *paint = handle_to_paint(object);
         vals[0] = values[0];
         vals[1] = values[1];
         vals[2] = values[2];
         vals[3] = values[3];
         vals[4] = values[4];
         paint_set_radial_gradient(paint, vals);
         paint_set_radial_gradienti(paint, values);
      }
   }
      break;
   case VG_PATH_DATATYPE:
   case VG_PATH_FORMAT:
   case VG_PATH_SCALE:
   case VG_PATH_BIAS:
   case VG_PATH_NUM_SEGMENTS:
   case VG_PATH_NUM_COORDS:
      /* read only don't produce an error */
      break;
   default:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      return;
   }
}

VGint vegaGetParameterVectorSize(VGHandle object,
                                 VGint paramType)
{
   struct vg_context *ctx = vg_current_context();

   if (object == VG_INVALID_HANDLE) {
      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
      return 0;
   }

   switch(paramType) {
   case VG_PAINT_TYPE:
   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
   case VG_PAINT_PATTERN_TILING_MODE:
      return 1;
   case VG_PAINT_COLOR:
      return 4;
   case VG_PAINT_COLOR_RAMP_STOPS: {
      struct vg_paint *p = handle_to_paint(object);
      return paint_num_ramp_stops(p);
   }
      break;
   case VG_PAINT_LINEAR_GRADIENT:
      return 4;
   case VG_PAINT_RADIAL_GRADIENT:
      return 5;


   case VG_PATH_FORMAT:
   case VG_PATH_DATATYPE:
   case VG_PATH_SCALE:
   case VG_PATH_BIAS:
   case VG_PATH_NUM_SEGMENTS:
   case VG_PATH_NUM_COORDS:
      return 1;

   case VG_IMAGE_FORMAT:
   case VG_IMAGE_WIDTH:
   case VG_IMAGE_HEIGHT:
      return 1;

#ifdef OPENVG_VERSION_1_1
   case VG_FONT_NUM_GLYPHS:
      return 1;
#endif

   default:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;
   }
   return 0;
}


VGfloat vegaGetParameterf(VGHandle object,
                          VGint paramType)
{
   struct vg_context *ctx = vg_current_context();

   if (object == VG_INVALID_HANDLE) {
      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
      return 0;
   }

   switch(paramType) {
   case VG_PAINT_TYPE:
   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
   case VG_PAINT_PATTERN_TILING_MODE:
      return vegaGetParameteri(object, paramType);
      break;
   case VG_PAINT_COLOR:
   case VG_PAINT_COLOR_RAMP_STOPS:
   case VG_PAINT_LINEAR_GRADIENT:
   case VG_PAINT_RADIAL_GRADIENT:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;

   case VG_PATH_FORMAT:
      return VG_PATH_FORMAT_STANDARD;
   case VG_PATH_SCALE: {
      struct path *p = handle_to_path(object);
      return path_scale(p);
   }
   case VG_PATH_BIAS: {
      struct path *p = handle_to_path(object);
      return path_bias(p);
   }
   case VG_PATH_DATATYPE:
   case VG_PATH_NUM_SEGMENTS:
   case VG_PATH_NUM_COORDS:
      return vegaGetParameteri(object, paramType);
      break;

   case VG_IMAGE_FORMAT:
   case VG_IMAGE_WIDTH:
   case VG_IMAGE_HEIGHT:
#ifdef OPENVG_VERSION_1_1
   case VG_FONT_NUM_GLYPHS: 
      return vegaGetParameteri(object, paramType);
      break;
#endif

   default:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;
   }
   return 0;
}

VGint vegaGetParameteri(VGHandle object,
                        VGint paramType)
{
   struct vg_context *ctx = vg_current_context();

   if (object == VG_INVALID_HANDLE) {
      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
      return 0;
   }

   switch(paramType) {
   case VG_PAINT_TYPE: {
         struct vg_paint *paint = handle_to_paint(object);
         return paint_type(paint);
   }
      break;
   case VG_PAINT_COLOR_RAMP_SPREAD_MODE: {
      struct vg_paint *p = handle_to_paint(object);
      return paint_spread_mode(p);
   }
   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
      struct vg_paint *p = handle_to_paint(object);
      return paint_color_ramp_premultiplied(p);
   }
      break;
   case VG_PAINT_PATTERN_TILING_MODE: {
      struct vg_paint *p = handle_to_paint(object);
      return paint_pattern_tiling(p);
   }
      break;
   case VG_PAINT_COLOR:
   case VG_PAINT_COLOR_RAMP_STOPS:
   case VG_PAINT_LINEAR_GRADIENT:
   case VG_PAINT_RADIAL_GRADIENT:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;

   case VG_PATH_FORMAT:
      return VG_PATH_FORMAT_STANDARD;
   case VG_PATH_SCALE:
   case VG_PATH_BIAS:
      return vegaGetParameterf(object, paramType);
   case VG_PATH_DATATYPE: {
      struct path *p = handle_to_path(object);
      return path_datatype(p);
   }
   case VG_PATH_NUM_SEGMENTS: {
      struct path *p = handle_to_path(object);
      return path_num_segments(p);
   }
   case VG_PATH_NUM_COORDS: {
      struct path *p = handle_to_path(object);
      return path_num_coords(p);
   }
      break;

   case VG_IMAGE_FORMAT: {
      struct vg_image *img = handle_to_image(object);
      return img->format;
   }
      break;
   case VG_IMAGE_WIDTH: {
      struct vg_image *img = handle_to_image(object);
      return img->width;
   }
      break;
   case VG_IMAGE_HEIGHT: {
      struct vg_image *img = handle_to_image(object);
      return img->height;
   }
      break;

#ifdef OPENVG_VERSION_1_1
   case VG_FONT_NUM_GLYPHS: {
      struct vg_font *font = handle_to_font(object);
      return font_num_glyphs(font);
   }
      break;
#endif

   default:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;
   }
   return 0;
}

void vegaGetParameterfv(VGHandle object,
                        VGint paramType,
                        VGint count,
                        VGfloat * values)
{
   struct vg_context *ctx = vg_current_context();
   VGint real_count = vegaGetParameterVectorSize(object, paramType);

   if (object == VG_INVALID_HANDLE) {
      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
      return;
   }

   if (!values || count <= 0 || count > real_count ||
       !is_aligned(values)) {
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      return;
   }

   switch(paramType) {
   case VG_PAINT_TYPE: {
      struct vg_paint *p = handle_to_paint(object);
      values[0] = paint_type(p);
   }
      break;
   case VG_PAINT_COLOR_RAMP_SPREAD_MODE: {
      struct vg_paint *p = handle_to_paint(object);
      values[0] = paint_spread_mode(p);
   }
      break;
   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
      struct vg_paint *p = handle_to_paint(object);
      values[0] = paint_color_ramp_premultiplied(p);
   }
      break;
   case VG_PAINT_PATTERN_TILING_MODE: {
      values[0] = vegaGetParameterf(object, paramType);
   }
      break;
   case VG_PAINT_COLOR: {
      struct vg_paint *paint = handle_to_paint(object);
      paint_get_color(paint, values);
   }
      break;
   case VG_PAINT_COLOR_RAMP_STOPS: {
      struct vg_paint *paint = handle_to_paint(object);
      paint_ramp_stops(paint, values, count);
   }
      break;
   case VG_PAINT_LINEAR_GRADIENT: {
      struct vg_paint *paint = handle_to_paint(object);
      paint_linear_gradient(paint, values);
   }
      break;
   case VG_PAINT_RADIAL_GRADIENT: {
      struct vg_paint *paint = handle_to_paint(object);
      paint_radial_gradient(paint, values);
   }
      break;

   case VG_PATH_FORMAT:
   case VG_PATH_DATATYPE:
   case VG_PATH_NUM_SEGMENTS:
   case VG_PATH_NUM_COORDS:
      values[0] = vegaGetParameteri(object, paramType);
      break;
   case VG_PATH_SCALE:
   case VG_PATH_BIAS:
      values[0] = vegaGetParameterf(object, paramType);
      break;

   case VG_IMAGE_FORMAT:
   case VG_IMAGE_WIDTH:
   case VG_IMAGE_HEIGHT:
#ifdef OPENVG_VERSION_1_1
   case VG_FONT_NUM_GLYPHS:
      values[0] = vegaGetParameteri(object, paramType);
      break;
#endif

   default:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;
   }
}

void vegaGetParameteriv(VGHandle object,
                        VGint paramType,
                        VGint count,
                        VGint * values)
{
   struct vg_context *ctx = vg_current_context();
   VGint real_count = vegaGetParameterVectorSize(object, paramType);

   if (object || object == VG_INVALID_HANDLE) {
      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
      return;
   }

   if (!values || count <= 0 || count > real_count ||
       !is_aligned(values)) {
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      return;
   }

   switch(paramType) {
   case VG_PAINT_TYPE:
   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
   case VG_PAINT_PATTERN_TILING_MODE:
#ifdef OPENVG_VERSION_1_1
   case VG_FONT_NUM_GLYPHS:
      values[0] = vegaGetParameteri(object, paramType);
      break;
#endif
   case VG_PAINT_COLOR: {
      struct vg_paint *paint = handle_to_paint(object);
      paint_get_coloriv(paint, values);
   }
      break;
   case VG_PAINT_COLOR_RAMP_STOPS: {
      struct vg_paint *paint = handle_to_paint(object);
      paint_ramp_stopsi(paint, values, count);
   }
      break;
   case VG_PAINT_LINEAR_GRADIENT: {
      struct vg_paint *paint = handle_to_paint(object);
      paint_linear_gradienti(paint, values);
   }
      break;
   case VG_PAINT_RADIAL_GRADIENT: {
      struct vg_paint *paint = handle_to_paint(object);
      paint_radial_gradienti(paint, values);
   }
      break;

   case VG_PATH_SCALE:
   case VG_PATH_BIAS:
      values[0] = vegaGetParameterf(object, paramType);
      break;
   case VG_PATH_FORMAT:
   case VG_PATH_DATATYPE:
   case VG_PATH_NUM_SEGMENTS:
   case VG_PATH_NUM_COORDS:
      values[0] = vegaGetParameteri(object, paramType);
      break;

   case VG_IMAGE_FORMAT:
   case VG_IMAGE_WIDTH:
   case VG_IMAGE_HEIGHT:
      values[0] = vegaGetParameteri(object, paramType);
      break;

   default:
      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
      break;
   }
}