class Cairo::Surface

Public Class Methods

create(*args) click to toggle source
static VALUE
cr_surface_create (int argc, VALUE *argv, VALUE klass)
{
  VALUE rb_surface;
  rb_surface = rb_funcallv (klass, cr_id_new, argc, argv);
  if (rb_block_given_p ())
    {
      return rb_ensure (rb_cairo__surface_yield_and_finish, rb_surface,
                        cr_surface_destroy_with_destroy_check, rb_surface);
    }
  else
    {
      return rb_surface;
    }
}
gl_supported?() click to toggle source
static VALUE
cr_surface_gl_supported_p (VALUE klass)
{
#ifdef RB_CAIRO_HAS_GL_SURFACE
  return Qtrue;
#else
  return Qfalse;
#endif
}
gl_texture_supported?() click to toggle source
static VALUE
cr_surface_gl_texture_supported_p (VALUE klass)
{
  return cr_surface_gl_supported_p(klass);
}
image_supported?() click to toggle source
static VALUE
cr_surface_image_supported_p (VALUE klass)
{
  return Qtrue;
}
new(*args) click to toggle source
static VALUE
cr_surface_initialize (int argc, VALUE *argv, VALUE self)
{
  rb_raise(rb_eNotImpError,
           "%s class creation isn't supported on this cairo installation",
           rb_obj_classname(self));

  return Qnil;
}
pdf_supported?() click to toggle source
static VALUE
cr_surface_pdf_supported_p (VALUE klass)
{
#ifdef CAIRO_HAS_PDF_SURFACE
  return Qtrue;
#else
  return Qfalse;
#endif
}
ps_supported?() click to toggle source
static VALUE
cr_surface_ps_supported_p (VALUE klass)
{
#ifdef CAIRO_HAS_PS_SURFACE
  return Qtrue;
#else
  return Qfalse;
#endif
}
quartz_image_supported?() click to toggle source
static VALUE
cr_surface_quartz_image_supported_p (VALUE klass)
{
#ifdef RB_CAIRO_HAS_QUARTZ_IMAGE_SURFACE
  return Qtrue;
#else
  return Qfalse;
#endif
}
quartz_supported?() click to toggle source
static VALUE
cr_surface_quartz_supported_p (VALUE klass)
{
#ifdef RB_CAIRO_HAS_QUARTZ_SURFACE
  return Qtrue;
#else
  return Qfalse;
#endif
}
recording_supported?() click to toggle source
static VALUE
cr_surface_recording_supported_p (VALUE klass)
{
#ifdef CAIRO_HAS_RECORDING_SURFACE
  return Qtrue;
#else
  return Qfalse;
#endif
}
script_supported?() click to toggle source
static VALUE
cr_surface_script_supported_p (VALUE klass)
{
#ifdef CAIRO_HAS_SCRIPT_SURFACE
  return Qtrue;
#else
  return Qfalse;
#endif
}
supported?(type) click to toggle source
# File lib/cairo/surface.rb, line 4
def supported?(type)
  type_components = type.to_s.split(/([A-Z][a-z\d]+)/).reject(&:empty?)
  snake_case_type_name = type_components.join("_").downcase
  supported_predicate = "#{snake_case_type_name}_supported?"
  return false unless respond_to?(supported_predicate)
  send(supported_predicate)
end
svg_supported?() click to toggle source
static VALUE
cr_surface_svg_supported_p (VALUE klass)
{
#ifdef CAIRO_HAS_SVG_SURFACE
  return Qtrue;
#else
  return Qfalse;
#endif
}
tee_supported?() click to toggle source
static VALUE
cr_surface_tee_supported_p (VALUE klass)
{
#ifdef CAIRO_HAS_TEE_SURFACE
  return Qtrue;
#else
  return Qfalse;
#endif
}
win32_printing_supported?() click to toggle source
static VALUE
cr_surface_win32_printing_supported_p (VALUE klass)
{
#ifdef RB_CAIRO_HAS_WIN32_PRINTING_SURFACE
  return Qtrue;
#else
  return Qfalse;
#endif
}
win32_supported?() click to toggle source
static VALUE
cr_surface_win32_supported_p (VALUE klass)
{
#ifdef CAIRO_HAS_WIN32_SURFACE
  return Qtrue;
#else
  return Qfalse;
#endif
}
xml_supported?() click to toggle source
static VALUE
cr_surface_xml_supported_p (VALUE klass)
{
#ifdef CAIRO_HAS_XML_SURFACE
  return Qtrue;
#else
  return Qfalse;
#endif
}

Public Instance Methods

clone() click to toggle source
# File lib/cairo.rb, line 80
def clone
  raise NotImplementedError
end
content() click to toggle source
static VALUE
cr_surface_get_content (VALUE self)
{
  return INT2NUM (cairo_surface_get_content (_SELF));
}
copy_page() click to toggle source
static VALUE
cr_surface_copy_page (VALUE self)
{
  cairo_surface_copy_page (_SELF);
  rb_cairo_surface_check_status (_SELF);
  return self;
}
create_similar(*args) click to toggle source
static VALUE
cr_surface_create_similar (int argc, VALUE *argv, VALUE self)
{
  cairo_surface_t *surface, *similar_surface;
  cairo_content_t content;
  int width, height;
  VALUE arg1, arg2, arg3;

  rb_scan_args (argc, argv, "21", &arg1, &arg2, &arg3);

  surface = _SELF;
  if (argc == 2)
    {
      content = cairo_surface_get_content (surface);
      width = NUM2INT (arg1);
      height = NUM2INT (arg2);
    }
  else
    {
      content = RVAL2CRCONTENT (arg1);
      width = NUM2INT (arg2);
      height = NUM2INT (arg3);
    }

  similar_surface = cairo_surface_create_similar (surface, content,
                                                  width, height);
  rb_cairo_surface_check_status (similar_surface);
  return CRSURFACE2RVAL_WITH_DESTROY (similar_surface);
}
create_similar_image(*args) click to toggle source
static VALUE
cr_surface_create_similar_image (int argc, VALUE *argv, VALUE self)
{
  cairo_surface_t *surface, *similar_image;
  cairo_format_t format;
  int width, height;
  VALUE arg1, arg2, arg3;

  rb_scan_args (argc, argv, "21", &arg1, &arg2, &arg3);

  surface = _SELF;
  if (argc == 2)
    {
      if (cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_IMAGE)
        {
          format = cairo_image_surface_get_format (surface);
        }
      else
        {
          format = CAIRO_FORMAT_ARGB32;
        }
      width = NUM2INT (arg1);
      height = NUM2INT (arg2);
    }
  else
    {
      format = RVAL2CRFORMAT (arg1);
      width = NUM2INT (arg2);
      height = NUM2INT (arg3);
    }

  similar_image = cairo_surface_create_similar_image (surface, format,
                                                      width, height);
  rb_cairo_surface_check_status (similar_image);
  return CRSURFACE2RVAL_WITH_DESTROY (similar_image);
}
destroy() click to toggle source
static VALUE
cr_surface_destroy (VALUE self)
{
  cairo_surface_t *surface;

  surface = _SELF;
  cr_surface_destroy_raw (surface);
  DATA_PTR (self) = NULL;

  return self;
}
device() click to toggle source
static VALUE
cr_surface_get_device (VALUE self)
{
  return CRDEVICE2RVAL (cairo_surface_get_device (_SELF));
}
device_offset() click to toggle source
static VALUE
cr_surface_get_device_offset (VALUE self)
{
  double x_offset, y_offset;

  cairo_surface_get_device_offset (_SELF, &x_offset, &y_offset);
  rb_cairo_surface_check_status (_SELF);
  return rb_ary_new3 (2, rb_float_new (x_offset), rb_float_new (y_offset));
}
device_scale() click to toggle source
static VALUE
cr_surface_get_device_scale (VALUE self)
{
  double x_scale, y_scale;

  cairo_surface_get_device_scale (_SELF, &x_scale, &y_scale);
  return rb_ary_new3 (2, rb_float_new (x_scale), rb_float_new (y_scale));
}
dup() click to toggle source
# File lib/cairo.rb, line 77
def dup
  raise NotImplementedError
end
fallback_resolution() click to toggle source
static VALUE
cr_surface_get_fallback_resolution (VALUE self)
{
  double x_pixels_per_inch, y_pixels_per_inch;

  cairo_surface_get_fallback_resolution (_SELF,
                                         &x_pixels_per_inch,
                                         &y_pixels_per_inch);
  rb_cairo_surface_check_status (_SELF);
  return rb_ary_new3 (2,
                      rb_float_new (x_pixels_per_inch),
                      rb_float_new (y_pixels_per_inch));
}
finish() click to toggle source
static VALUE
cr_surface_finish (VALUE self)
{
  cairo_surface_t *surface;
  rb_cairo__io_callback_closure_t *closure;

  surface = _SELF;
  closure = cairo_surface_get_user_data (surface, &cr_closure_key);

  cairo_surface_finish (surface);
  cairo_surface_set_user_data (surface, &cr_finished_key, (void *)CR_TRUE, NULL);
  cairo_surface_set_user_data (surface, &cr_object_holder_key, NULL, NULL);

  if (closure && !NIL_P (closure->error))
    rb_exc_raise (closure->error);
  rb_cairo_surface_check_status (surface);

  return self;
}
flush() click to toggle source
static VALUE
cr_surface_flush (VALUE self)
{
  cairo_surface_flush (_SELF);
  rb_cairo_surface_check_status (_SELF);
  return self;
}
font_options() click to toggle source
static VALUE
cr_surface_get_font_options (VALUE self)
{
  cairo_font_options_t *options;
  VALUE rb_options;

  options = cairo_font_options_create ();
  rb_cairo_check_status (cairo_font_options_status (options));

  /* TODO: Use rb_ensure() */
  rb_options = CRFONTOPTIONS2RVAL (options);
  cairo_font_options_destroy (options);

  options = RVAL2CRFONTOPTIONS (rb_options);
  cairo_surface_get_font_options (_SELF, options);
  rb_cairo_surface_check_status (_SELF);
  rb_cairo_check_status (cairo_font_options_status (options));

  return rb_options;
}
get_mime_data(p1) click to toggle source
static VALUE
cr_surface_get_mime_data (VALUE self, VALUE mime_type)
{
  cairo_surface_t *surface;
  const unsigned char *data;
  unsigned long length;

  surface = _SELF;
  cairo_surface_get_mime_data (surface, StringValueCStr (mime_type),
                               &data, &length);
  if (data)
    return rb_str_new ((const char *)data, length);
  else
    return Qnil;
}
map_to_image(*args) click to toggle source
static VALUE
cr_surface_map_to_image (int argc, VALUE *argv, VALUE self)
{
  cairo_surface_t *surface, *mapped_image;
  cairo_rectangle_int_t extents_value;
  cairo_rectangle_int_t *extents = NULL;
  VALUE rb_extents;

  rb_scan_args (argc, argv, "01", &rb_extents);

  surface = _SELF;
  if (!NIL_P (rb_extents))
    {
      extents = &extents_value;
      if (rb_cairo__is_kind_of (rb_extents, rb_cCairo_Rectangle))
        {
          extents->x = NUM2INT (rb_funcall (rb_extents, cr_id_x, 0));
          extents->y = NUM2INT (rb_funcall (rb_extents, cr_id_y, 0));
          extents->width = NUM2INT (rb_funcall (rb_extents, cr_id_width, 0));
          extents->height = NUM2INT (rb_funcall (rb_extents, cr_id_height, 0));
        }
      else
        {
          VALUE *values;
          rb_extents = rb_convert_type (rb_extents, T_ARRAY, "Array", "to_ary");
          values = RARRAY_PTR (rb_extents);
          extents->x = NUM2INT (values[0]);
          extents->y = NUM2INT (values[1]);
          extents->height = NUM2INT (values[2]);
          extents->width = NUM2INT (values[3]);
        }
    }

  mapped_image = cairo_surface_map_to_image (surface, extents);
  rb_cairo_surface_check_status (mapped_image);
  return CRSURFACE2RVAL_WITH_DESTROY (mapped_image);
}
mark_dirty(*args) click to toggle source
static VALUE
cr_surface_mark_dirty (int argc, VALUE *argv, VALUE self)
{
  VALUE x, y, width, height;
  int n;

  n = rb_scan_args (argc, argv, "04", &x, &y, &width, &height);

  if (n == 0)
    {
      cairo_surface_mark_dirty (_SELF);
    }
  else if (n == 4)
    {
      cairo_surface_mark_dirty_rectangle (_SELF,
                                          NUM2INT (x), NUM2INT (y),
                                          NUM2INT (width), NUM2INT (height));
    }
  else
    {
      int i;
      VALUE args;

      args = rb_ary_new2 (n);
      for (i = 0; i < n; i++)
        {
          rb_ary_push (args, argv[i]);
        }

      rb_raise (rb_eArgError,
                "invalid argument (expect () or (x, y, width, height)): %s",
                rb_cairo__inspect (args));
    }

  rb_cairo_surface_check_status (_SELF);
  return self;
}
reference_count() click to toggle source

Surface manipulation

static VALUE
cr_surface_get_reference_count (VALUE self)
{
  cairo_surface_t *surface;
  unsigned int reference_count;

  surface = _SELF;
  reference_count = cairo_surface_get_reference_count (surface);

  return UINT2NUM (reference_count);
}
set_device_offset(p1, p2) click to toggle source
static VALUE
cr_surface_set_device_offset (VALUE self, VALUE x_offset, VALUE y_offset)
{
  cairo_surface_set_device_offset (_SELF,
                                   NUM2DBL (x_offset),
                                   NUM2DBL (y_offset));
  rb_cairo_surface_check_status (_SELF);
  return self;
}
set_device_scale(p1, p2) click to toggle source
static VALUE
cr_surface_set_device_scale (VALUE self, VALUE x_scale, VALUE y_scale)
{
  cairo_surface_set_device_scale (_SELF,
                                  NUM2DBL (x_scale),
                                  NUM2DBL (y_scale));
  rb_cairo_surface_check_status (_SELF);
  return self;
}
set_fallback_resolution(p1, p2) click to toggle source
static VALUE
cr_surface_set_fallback_resolution (VALUE self,
                                    VALUE x_pixels_per_inch,
                                    VALUE y_pixels_per_inch)
{
  cairo_surface_set_fallback_resolution (_SELF,
                                         NUM2DBL (x_pixels_per_inch),
                                         NUM2DBL (y_pixels_per_inch));
  rb_cairo_surface_check_status (_SELF);
  return self;
}
set_mime_data(p1, p2) click to toggle source
static VALUE
cr_surface_set_mime_data (VALUE self, VALUE rb_mime_type, VALUE rb_data)
{
  cairo_status_t status;
  cairo_surface_t *surface;
  const char *mime_type;

  surface = _SELF;
  mime_type = StringValueCStr (rb_mime_type);
  if (NIL_P (rb_data))
    {
      status = cairo_surface_set_mime_data (surface, mime_type,
                                            NULL, 0, NULL, NULL);
    }
  else
    {
      const char *raw_data;
      unsigned char *data;
      unsigned long length;

      raw_data = StringValuePtr (rb_data);
      length = RSTRING_LEN (rb_data);
      data = xmalloc (length);
      memcpy (data, raw_data, length);
      status = cairo_surface_set_mime_data (surface, mime_type,
                                            data, length,
                                            xfree, data);
    }
  rb_cairo_check_status (status);
  return Qnil;
}
show_page() click to toggle source
static VALUE
cr_surface_show_page (VALUE self)
{
  cairo_surface_show_page (_SELF);
  rb_cairo_surface_check_status (_SELF);
  return self;
}
sub_rectangle_surface(p1, p2, p3, p4) click to toggle source
static VALUE
cr_surface_create_sub_rectangle_surface (VALUE self, VALUE x, VALUE y,
                                         VALUE width, VALUE height)
{
  VALUE rb_surface;
  cairo_surface_t *surface;

  surface = cairo_surface_create_for_rectangle (RVAL2CRSURFACE (self),
                                                NUM2DBL (x),
                                                NUM2DBL (y),
                                                NUM2DBL (width),
                                                NUM2INT (height));
  rb_cairo_surface_check_status (surface);
  rb_surface = CRSURFACE2RVAL_WITH_DESTROY (surface);
  if (rb_block_given_p ())
    return rb_ensure (rb_yield, rb_surface,
                      cr_surface_destroy_with_destroy_check, rb_surface);
  else
    return rb_surface;
}
supported_mime_type?(p1) click to toggle source
static VALUE
cr_surface_supported_mime_type_p (VALUE self, VALUE rb_mime_type)
{
  cairo_surface_t *surface;
  const char *mime_type;
  cairo_bool_t supported_p;

  surface = _SELF;
  mime_type = StringValueCStr (rb_mime_type);
  supported_p = cairo_surface_supports_mime_type (surface, mime_type);
  return CBOOL2RVAL (supported_p);
}
unmap_image(p1) click to toggle source
static VALUE
cr_surface_unmap_image (VALUE self, VALUE rb_mapped_image)
{
  cairo_surface_t *surface, *mapped_image;

  surface = _SELF;
  mapped_image = RVAL2CRSURFACE (rb_mapped_image);
  cairo_surface_unmap_image (surface, mapped_image);
  return Qnil;
}
write_to_png(p1) click to toggle source
static VALUE
cr_surface_write_to_png_generic (VALUE self, VALUE target)
{
  if (rb_respond_to (target, rb_cairo__io_id_write))
    return cr_surface_write_to_png_stream (self, target);
  else
    return cr_surface_write_to_png (self, target);
}