static VALUE
cr_font_extents (VALUE self)
{
cairo_font_extents_t extents;
cairo_font_extents (_SELF, &extents);
cr_check_status (_SELF);
return CRFONTEXTENTS2RVAL (&extents);
}
static VALUE
cr_rectangle (VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
{
cairo_rectangle (_SELF, NUM2DBL (x), NUM2DBL (y),
NUM2DBL (width), NUM2DBL (height));
cr_check_status (_SELF);
return self;
}
static VALUE
cr_mask_surface (VALUE self, VALUE surface, VALUE x, VALUE y)
{
cairo_mask_surface (_SELF, RVAL2CRSURFACE (surface),
NUM2DBL (x), NUM2DBL (y));
cr_check_status (_SELF);
return self;
}
static VALUE
cr_set_source (VALUE self, VALUE pattern)
{
cairo_set_source (_SELF, RVAL2CRPATTERN (pattern));
cr_check_status (_SELF);
rb_ivar_set (self, cr_id_source, pattern);
return self;
}
static VALUE
cr_get_matrix (VALUE self)
{
cairo_matrix_t matrix;
cairo_get_matrix (_SELF, &matrix);
cr_check_status (_SELF);
return CRMATRIX2RVAL (&matrix);
}
static VALUE
cr_text_extents (VALUE self, VALUE utf8)
{
cairo_text_extents_t extents;
cairo_text_extents (_SELF, StringValuePtr (utf8), &extents);
cr_check_status (_SELF);
return CRTEXTEXTENTS2RVAL (&extents);
}
static VALUE
cr_curve_to (VALUE self, VALUE x1, VALUE y1,
VALUE x2, VALUE y2, VALUE x3, VALUE y3)
{
cairo_curve_to (_SELF, NUM2DBL (x1), NUM2DBL (y1),
NUM2DBL (x2), NUM2DBL (y2), NUM2DBL (x3), NUM2DBL (y3));
cr_check_status (_SELF);
return self;
}
static VALUE
cr_arc_negative (VALUE self, VALUE xc, VALUE yc, VALUE radius,
VALUE angle1, VALUE angle2)
{
cairo_arc_negative (_SELF, NUM2DBL (xc), NUM2DBL (yc), NUM2DBL (radius),
NUM2DBL (angle1), NUM2DBL (angle2));
cr_check_status (_SELF);
return self;
}
static VALUE
cr_device_to_user_distance (VALUE self, VALUE dx, VALUE dy)
{
double pair[2];
pair[0] = NUM2DBL (dx);
pair[1] = NUM2DBL (dy);
cairo_device_to_user_distance (_SELF, pair, pair + 1);
cr_check_status (_SELF);
return rb_cairo__float_array (pair, 2);
}
static VALUE
cr_rel_curve_to (VALUE self, VALUE dx1, VALUE dy1,
VALUE dx2, VALUE dy2, VALUE dx3, VALUE dy3)
{
cairo_rel_curve_to (_SELF, NUM2DBL (dx1), NUM2DBL (dy1),
NUM2DBL (dx2), NUM2DBL (dy2),
NUM2DBL (dx3), NUM2DBL (dy3));
cr_check_status (_SELF);
return self;
}
static VALUE
cr_path_extents (VALUE self)
{
double x1, y1, x2, y2;
cairo_path_extents (_SELF, &x1, &y1, &x2, &y2);
cr_check_status (_SELF);
return rb_ary_new3 (4,
rb_float_new(x1), rb_float_new(y1),
rb_float_new(x2), rb_float_new(y2));
}
static VALUE
cr_show_glyphs (VALUE self, VALUE rb_glyphs)
{
int count;
cairo_glyph_t *glyphs;
RB_CAIRO__GLYPHS_TO_ARRAY (rb_glyphs, glyphs, count);
cairo_show_glyphs (_SELF, glyphs, count);
cr_check_status (_SELF);
return self;
}
static VALUE
cr_set_source_surface (VALUE self, VALUE surface, VALUE width, VALUE height)
{
cairo_set_source_surface (_SELF,
RVAL2CRSURFACE (surface),
NUM2DBL (width),
NUM2DBL (height));
cr_check_status (_SELF);
rb_ivar_set (self, cr_id_source, Qnil);
return self;
}
static VALUE
cr_pop_group (VALUE self)
{
VALUE rb_pattern;
cairo_pattern_t *pattern;
pattern = cairo_pop_group (_SELF);
cr_check_status (_SELF);
rb_pattern = CRPATTERN2RVAL (pattern);
cairo_pattern_destroy (pattern);
return rb_pattern;
}
static VALUE
cr_glyph_extents (VALUE self, VALUE rb_glyphs)
{
cairo_text_extents_t extents;
cairo_glyph_t *glyphs;
int length;
RB_CAIRO__GLYPHS_TO_ARRAY (rb_glyphs, glyphs, length);
cairo_glyph_extents (_SELF, glyphs, length, &extents);
cr_check_status (_SELF);
return CRTEXTEXTENTS2RVAL (&extents);
}
static VALUE
cr_save (VALUE self)
{
VALUE result = Qnil;
cairo_save (_SELF);
cr_check_status (_SELF);
if (rb_block_given_p ())
{
result = rb_ensure (rb_yield, self, cr_restore, self);
}
return result;
}
static VALUE
cr_set_dash (int argc, VALUE *argv, VALUE self)
{
VALUE dash_array, rb_offset;
double offset;
cairo_bool_t is_num;
rb_scan_args(argc, argv, "11", &dash_array, &rb_offset);
is_num = rb_cairo__is_kind_of (dash_array, rb_cNumeric);
if (!(NIL_P (dash_array) || is_num))
{
Check_Type (dash_array, T_ARRAY);
}
if (NIL_P (rb_offset))
offset = 0.0;
else
offset = NUM2DBL (rb_offset);
if (is_num)
{
double values[1];
values[0] = NUM2DBL (dash_array);
cairo_set_dash (_SELF, values, 1, offset);
}
else if (NIL_P (dash_array) || RARRAY_LEN (dash_array) == 0)
{
cairo_set_dash (_SELF, NULL, 0, offset);
}
else
{
int i, length;
double *values;
length = RARRAY_LEN (dash_array);
values = ALLOCA_N (double, length);
if (!values)
{
rb_cairo_check_status (CAIRO_STATUS_NO_MEMORY);
}
for (i = 0; i < length; i++)
{
values[i] = NUM2DBL (RARRAY_PTR (dash_array)[i]);
}
cairo_set_dash (_SELF, values, length, offset);
}
cr_check_status (_SELF);
return self;
}
static VALUE
cr_set_source_rgba (int argc, VALUE *argv, VALUE self)
{
VALUE red, green, blue, alpha;
int n;
n = rb_scan_args (argc, argv, "13", &red, &green, &blue, &alpha);
if (n == 1 && rb_cairo__is_kind_of (red, rb_cArray))
{
VALUE ary = red;
n = RARRAY_LEN (ary);
red = rb_ary_entry (ary, 0);
green = rb_ary_entry (ary, 1);
blue = rb_ary_entry (ary, 2);
alpha = rb_ary_entry (ary, 3);
}
if (n == 3)
{
cairo_set_source_rgb (_SELF,
NUM2DBL (red),
NUM2DBL (green),
NUM2DBL (blue));
}
else if (n == 4)
{
cairo_set_source_rgba (_SELF,
NUM2DBL (red),
NUM2DBL (green),
NUM2DBL (blue),
NUM2DBL (alpha));
}
else
{
VALUE inspected_arg = rb_inspect (rb_ary_new4 (argc, argv));
rb_raise (rb_eArgError,
"invalid RGB%s: %s (expect "
"(red, green, blue), (red, green, blue, alpha), "
"([red, green, blue]) or ([red, green, blue, alpha]))",
n == 4 ? "A" : "",
StringValuePtr (inspected_arg));
}
cr_check_status (_SELF);
rb_ivar_set (self, cr_id_source, Qnil);
return self;
}
static VALUE
cr_initialize (VALUE self, VALUE target)
{
cairo_t *cr;
VALUE result = Qnil;
cr = cairo_create (RVAL2CRSURFACE (target));
cr_check_status (cr);
rb_ivar_set (self, cr_id_surface, target);
cr_set_user_data (cr,
&cr_object_holder_key,
cr_object_holder_new(self),
cr_object_holder_free);
DATA_PTR (self) = cr;
if (rb_block_given_p ())
result = rb_ensure (rb_yield, self, cr_destroy_with_destroy_check, self);
return result;
}
static VALUE
cr_s_wrap (VALUE self, VALUE pointer)
{
VALUE result;
VALUE rb_cr;
cairo_t *cr;
if (NIL_P (rb_cairo__cFFIPointer))
{
rb_raise (rb_eNotImpError,
"%s: FFI::Pointer is required",
rb_id2name (rb_frame_this_func ()));
}
if (!RTEST (rb_obj_is_kind_of (pointer, rb_cairo__cFFIPointer)))
{
rb_raise (rb_eArgError,
"must be FFI::Pointer: %s",
rb_cairo__inspect (pointer));
}
{
VALUE rb_cr_address;
rb_cr_address = rb_funcall (pointer, rb_intern ("address"), 0);
cr = NUM2PTR (rb_cr_address);
cr_check_status (cr);
}
rb_cr = rb_obj_alloc (self);
cairo_reference (cr);
DATA_PTR (rb_cr) = cr;
rb_ivar_set (rb_cr, cr_id_surface, Qnil);
if (rb_block_given_p ())
{
result = rb_ensure (rb_yield, rb_cr, cr_destroy_with_destroy_check, rb_cr);
}
else
{
result = rb_cr;
}
return result;
}
/* Font/Text functions */
static VALUE
cr_select_font_face (int argc, VALUE *argv, VALUE self)
{
VALUE rb_family, rb_slant, rb_weight;
const char *family;
cairo_font_slant_t slant;
cairo_font_weight_t weight;
rb_scan_args(argc, argv, "03", &rb_family, &rb_slant, &rb_weight);
if (NIL_P (rb_family))
{
family = "";
}
else if (rb_cairo__is_kind_of (rb_family, rb_cString))
{
family = RSTRING_PTR (rb_family);
}
else if (rb_cairo__is_kind_of (rb_family, rb_cSymbol))
{
family = rb_id2name (SYM2ID (rb_family));
}
else
{
rb_raise (rb_eArgError,
"family name should be nil, String or Symbol: %s",
rb_cairo__inspect (rb_family));
}
if (NIL_P (rb_slant))
slant = CAIRO_FONT_SLANT_NORMAL;
else
slant = RVAL2CRFONTSLANT (rb_slant);
if (NIL_P (rb_weight))
weight = CAIRO_FONT_WEIGHT_NORMAL;
else
weight = RVAL2CRFONTWEIGHT (rb_weight);
cairo_select_font_face (_SELF, family, slant, weight);
cr_check_status (_SELF);
return self;
}
static VALUE
cr_fill (int argc, VALUE *argv, VALUE self)
{
VALUE preserve;
rb_scan_args (argc, argv, "01", &preserve);
if (rb_block_given_p ())
{
cr_new_path (self);
rb_yield (self);
}
if (RVAL2CBOOL (preserve))
cairo_fill_preserve (_SELF);
else
cairo_fill (_SELF);
cr_check_status (_SELF);
return self;
}
