static VALUE
cr_freetype_font_face_initialize (VALUE self, VALUE path)
{
FT_Face freetype_face;
FT_Error error;
cairo_font_face_t *face;
cairo_status_t status;
error = FT_New_Face (cr_freetype_library,
StringValueCStr(path),
0,
&freetype_face);
cr_freetype_error_check (error, "failed to open FreeType font", path);
cr_freetype_n_faces++;
face = cairo_ft_font_face_create_for_ft_face (freetype_face, 0);
cr_font_face_check_status (face);
status =
cairo_font_face_set_user_data (face,
&cr_freetype_face_key,
freetype_face,
(cairo_destroy_func_t) cr_freetype_done_face);
if (status != CAIRO_STATUS_SUCCESS) {
cairo_font_face_destroy (face);
FT_Done_Face (freetype_face);
rb_cairo_check_status (status);
}
DATA_PTR (self) = face;
return Qnil;
}
static VALUE
cr_clip_rectangle_list (VALUE self)
{
VALUE rb_rectangles;
cairo_rectangle_list_t *rectangles;
int i;
rectangles = cairo_copy_clip_rectangle_list (_SELF);
rb_cairo_check_status (rectangles->status);
rb_rectangles = rb_ary_new2 (rectangles->num_rectangles);
for (i = 0; i < rectangles->num_rectangles; i++) {
VALUE argv[4];
cairo_rectangle_t rectangle = rectangles->rectangles[i];
argv[0] = rb_float_new (rectangle.x);
argv[1] = rb_float_new (rectangle.y);
argv[2] = rb_float_new (rectangle.width);
argv[3] = rb_float_new (rectangle.height);
rb_ary_push (rb_rectangles,
rb_class_new_instance (4, argv, rb_cCairo_Rectangle));
}
cairo_rectangle_list_destroy (rectangles);
return rb_rectangles;
}
static VALUE
cr_get_source (VALUE self)
{
VALUE rb_source = Qnil;
cairo_pattern_t *source;
source = cairo_get_source (_SELF);
if (source)
{
rb_cairo_check_status (cairo_pattern_status (source));
rb_source = rb_ivar_get (self, cr_id_source);
if (NIL_P (rb_source) || RVAL2CRPATTERN (rb_source) != source)
{
rb_source = CRPATTERN2RVAL (source);
rb_ivar_set (self, cr_id_source, rb_source);
}
}
else
{
rb_source = Qnil;
rb_ivar_set (self, cr_id_source, rb_source);
}
return rb_source;
}
static VALUE
cr_surface_write_to_png (VALUE self, VALUE filename)
{
cairo_status_t status;
status = cairo_surface_write_to_png (_SELF, StringValueCStr (filename));
rb_cairo_check_status (status);
return self;
}
static VALUE
cr_surface_pattern_get_surface (VALUE self)
{
cairo_surface_t *surface;
rb_cairo_check_status (cairo_pattern_get_surface (_SELF (self), &surface));
return CRSURFACE2RVAL (surface);
}
static VALUE
cr_get_font_face (VALUE self)
{
cairo_font_face_t *face;
face = cairo_get_font_face (_SELF);
rb_cairo_check_status (cairo_font_face_status (face));
return CRFONTFACE2RVAL (face);
}
static VALUE
cr_copy_path_flat (VALUE self)
{
cairo_path_t *path;
path = cairo_copy_path_flat (_SELF);
rb_cairo_check_status (path->status);
return CRPATH2RVAL (path);
}
static VALUE
cr_surface_get_font_options (VALUE self)
{
cairo_font_options_t *options = cairo_font_options_create();
cairo_surface_get_font_options (_SELF, options);
cr_surface_check_status (_SELF);
rb_cairo_check_status (cairo_font_options_status (options));
return CRFONTOPTIONS2RVAL (options);
}
static VALUE
cr_gradient_pattern_get_color_stop_count (VALUE self)
{
cairo_status_t status;
int count;
status = cairo_pattern_get_color_stop_count (_SELF (self), &count);
rb_cairo_check_status (status);
return INT2NUM (count);
}
static VALUE
rg_create_cairo_context(VALUE self)
{
VALUE rb_cr;
cairo_t *cr;
cr = gdk_cairo_create(_SELF(self));
rb_cairo_check_status(cairo_status(cr));
rb_cr = CRCONTEXT2RVAL(cr);
cairo_destroy (cr);
return rb_cr;
}
static VALUE
cr_mesh_pattern_get_path (VALUE self, VALUE nth_patch)
{
cairo_pattern_t *pattern;
cairo_path_t *path;
pattern = _SELF (self);
path = cairo_mesh_pattern_get_path (pattern, NUM2UINT (nth_patch));
rb_cairo_check_status (path->status);
return CRPATH2RVAL (path);
}
static VALUE
cr_solid_pattern_get_rgba (VALUE self)
{
double red, green, blue, alpha;
rb_cairo_check_status (cairo_pattern_get_rgba (_SELF (self),
&red, &green, &blue, &alpha));
return rb_ary_new3 (4,
rb_float_new (red), rb_float_new (green),
rb_float_new (blue), rb_float_new (alpha));
}
static VALUE
cr_get_group_target (VALUE self)
{
cairo_surface_t *surface;
surface = cairo_get_group_target (_SELF);
if (!surface)
return Qnil;
rb_cairo_check_status (cairo_surface_status (surface));
return CRSURFACE2RVAL (surface);
}
static VALUE
cr_linear_pattern_get_linear_points (VALUE self)
{
cairo_status_t status;
double x0, y0, x1, y1;
status = cairo_pattern_get_linear_points (_SELF (self), &x0, &y0, &x1, &y1);
rb_cairo_check_status (status);
return rb_ary_new3 (4,
rb_float_new (x0), rb_float_new (y0),
rb_float_new (x1), rb_float_new (y1));
}
static VALUE
cr_mesh_pattern_get_patch_count (VALUE self)
{
cairo_pattern_t *pattern;
unsigned int count;
cairo_status_t status;
pattern = _SELF (self);
status = cairo_mesh_pattern_get_patch_count (pattern, &count);
rb_cairo_check_status (status);
return UINT2NUM (count);
}
/* Functions for manipulating state objects */
cairo_t *
rb_cairo_context_from_ruby_object (VALUE obj)
{
cairo_t *context;
if (!rb_cairo__is_kind_of (obj, rb_cCairo_Context))
{
rb_raise (rb_eTypeError, "not a cairo graphics context");
}
Data_Get_Struct (obj, cairo_t, context);
if (!context)
rb_cairo_check_status (CAIRO_STATUS_NULL_POINTER);
return context;
}
/* constructor/de-constructor */
cairo_device_t *
rb_cairo_device_from_ruby_object (VALUE obj)
{
cairo_device_t *device;
if (!rb_cairo__is_kind_of (obj, rb_cCairo_Device))
{
rb_raise (rb_eTypeError, "not a cairo device");
}
Data_Get_Struct (obj, cairo_device_t, device);
if (!device)
rb_cairo_check_status (CAIRO_STATUS_NULL_POINTER);
return device;
}
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_gradient_pattern_get_color_stop_rgba (VALUE self, VALUE index)
{
cairo_status_t status;
double offset, red, green, blue, alpha;
status = cairo_pattern_get_color_stop_rgba (_SELF (self), NUM2INT (index),
&offset, &red, &green, &blue,
&alpha);
rb_cairo_check_status (status);
return rb_ary_new3 (5, rb_float_new (offset),
rb_float_new (red), rb_float_new (green),
rb_float_new (blue), rb_float_new (alpha));
}
static VALUE
cr_surface_write_to_png_stream (VALUE self, VALUE target)
{
cairo_status_t status;
cr_io_callback_closure_t closure;
closure.target = target;
closure.error = Qnil;
status = cairo_surface_write_to_png_stream (_SELF, cr_surface_write_func,
(void *)&closure);
if (!NIL_P (closure.error))
rb_exc_raise (closure.error);
rb_cairo_check_status (status);
return self;
}
cairo_font_face_t *
rb_cairo_font_face_from_ruby_object (VALUE obj)
{
cairo_font_face_t *face;
if (!rb_cairo__is_kind_of (obj, rb_cCairo_FontFace))
{
rb_raise (rb_eTypeError,
"not a cairo font face: %s",
rb_cairo__inspect (obj));
}
Data_Get_Struct (obj, cairo_font_face_t, face);
if (!face)
rb_cairo_check_status (CAIRO_STATUS_NULL_POINTER);
cr_font_face_check_status (face);
return face;
}
static VALUE
cr_get_target (VALUE self)
{
cairo_surface_t *surface;
VALUE rb_surface;
surface = cairo_get_target (_SELF);
rb_cairo_check_status (cairo_surface_status (surface));
rb_surface = rb_ivar_get (self, cr_id_surface);
if (NIL_P (rb_surface) || RVAL2CRSURFACE (rb_surface) != surface)
{
rb_surface = CRSURFACE2RVAL (surface);
rb_ivar_set (self, cr_id_surface, rb_surface);
}
return rb_surface;
}
static VALUE
cr_radial_pattern_get_radial_circles (VALUE self)
{
cairo_status_t status;
double x0, y0, r0, x1, y1, r1;
status = cairo_pattern_get_radial_circles (_SELF (self),
&x0, &y0, &r0,
&x1, &y1, &r1);
rb_cairo_check_status (status);
return rb_ary_new3 (2,
rb_ary_new3 (3,
rb_float_new (x0),
rb_float_new (y0),
rb_float_new (r0)),
rb_ary_new3 (3,
rb_float_new (x1),
rb_float_new (y1),
rb_float_new (r1)));
}
static inline void
cr_surface_check_status (cairo_surface_t *surface)
{
rb_cairo_check_status (cairo_surface_status (surface));
}
static VALUE
cr_win32_surface_initialize (int argc, VALUE *argv, VALUE self)
{
cairo_surface_t *surface = NULL;
VALUE arg1, arg2, arg3, arg4;
VALUE hdc, format, width, height;
rb_scan_args (argc, argv, "13", &arg1, &arg2, &arg3, &arg4);
switch (argc)
{
case 1:
hdc = arg1;
surface = cairo_win32_surface_create (NUM2PTR (hdc));
break;
case 2:
width = arg1;
height = arg2;
surface = cairo_win32_surface_create_with_dib (CAIRO_FORMAT_ARGB32,
NUM2INT (width),
NUM2INT (height));
break;
case 3:
if (NIL_P (arg1) ||
(rb_cairo__is_kind_of (arg1, rb_cNumeric) &&
NUM2INT (arg1) != CAIRO_FORMAT_RGB24))
{
# if CAIRO_CHECK_VERSION(1, 4, 0)
HDC win32_hdc;
hdc = arg1;
width = arg2;
height = arg3;
win32_hdc = NIL_P (hdc) ? NULL : NUM2PTR (hdc);
surface = cairo_win32_surface_create_with_ddb (win32_hdc,
CAIRO_FORMAT_RGB24,
NUM2INT (width),
NUM2INT (height));
# else
rb_raise (rb_eArgError,
"Cairo::Win32Surface.new(hdc, width, height) "
"is available since cairo >= 1.4.0");
# endif
}
else
{
format = arg1;
width = arg2;
height = arg3;
surface = cairo_win32_surface_create_with_dib (RVAL2CRFORMAT (format),
NUM2INT (width),
NUM2INT (height));
}
break;
case 4:
{
# if CAIRO_CHECK_VERSION(1, 4, 0)
HDC win32_hdc;
hdc = arg1;
format = arg2;
width = arg3;
height = arg4;
win32_hdc = NIL_P (hdc) ? NULL : (HDC) NUM2UINT (hdc);
surface = cairo_win32_surface_create_with_ddb (win32_hdc,
RVAL2CRFORMAT (format),
NUM2INT (width),
NUM2INT (height));
# else
rb_raise (rb_eArgError,
"Cairo::Win32Surface.new(hdc, format, width, height) "
"is available since cairo >= 1.4.0");
# endif
}
break;
}
if (!surface)
rb_cairo_check_status (CAIRO_STATUS_INVALID_FORMAT);
cr_surface_check_status (surface);
DATA_PTR (self) = surface;
if (rb_block_given_p ())
yield_and_finish (self);
return Qnil;
}
static inline void
cr_font_face_check_status (cairo_font_face_t *face)
{
rb_cairo_check_status (cairo_font_face_status (face));
}
static inline void
cr_pattern_check_status (cairo_pattern_t *pattern)
{
rb_cairo_check_status (cairo_pattern_status (pattern));
}
static inline void
cr_check_status (cairo_t *context)
{
rb_cairo_check_status (cairo_status (context));
}
static inline void
cr_device_check_status (cairo_device_t *device)
{
rb_cairo_check_status (cairo_device_status (device));
}
static inline void
cr_options_check_status (cairo_font_options_t *options)
{
rb_cairo_check_status (cairo_font_options_status (options));
}