Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 4357 → Rev 4358

/contrib/sdk/sources/Mesa/src/gallium/state_trackers/vega/api_params.c
0,0 → 1,1679
/**************************************************************************
*
* 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;
}
}