class Cairo::Surface - cairo-1.14.1 Documentation

# class Cairo::Surface

### Public Class Methods

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 72
    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(p1, p2) click to toggle source

    static VALUE
    cr_surface_copy_page (VALUE self)
    {
      cairo_surface_copy_page (_SELF);
      cr_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);
      cr_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);
      cr_surface_check_status (similar_image);
      return CRSURFACE2RVAL_WITH_DESTROY (similar_image);
    }

destroy() click to toggle source

Surface manipulation

    static VALUE
    cr_surface_destroy (VALUE self)
    {
      cairo_surface_t *surface;

      surface = _SELF;
      cairo_surface_destroy (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);
      cr_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 69
    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);
      cr_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);
      cr_surface_check_status (surface);

      return self;
    }

flush() click to toggle source

    static VALUE
    cr_surface_flush (VALUE self)
    {
      cairo_surface_flush (_SELF);
      cr_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 = 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);
    }

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);
      cr_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));
        }

      cr_surface_check_status (_SELF);
      return self;
    }

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));
      cr_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));
      cr_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));
      cr_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(p1, p2) click to toggle source

    static VALUE
    cr_surface_show_page (VALUE self)
    {
      cairo_surface_show_page (_SELF);
      cr_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));
      cr_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);
    }