Class: Cairo::Context

Inherits:

Object

Object
Cairo::Context

show all

Includes:: Color, Blur, Circle, Path, Rectangle, Triangle

Defined in:: lib/cairo/context.rb,
lib/cairo/context/blur.rb,
lib/cairo/context/path.rb,
lib/cairo/context/color.rb,
lib/cairo/context/circle.rb,
lib/cairo/context/triangle.rb,
lib/cairo/context/rectangle.rb,
ext/cairo/rb_cairo_context.c

Defined Under Namespace

Modules: Blur, Circle, Color, Path, Rectangle, Triangle

Constant Summary

Constants included from Color

Constants included from Cairo::Color::X11

Class Method Summary collapse

.create ⇒ Object
.wrap ⇒ Object

For integrate other libraries such as a FFI based library.

Instance Method Summary collapse

Constructor Details

#initialize ⇒ `Object`

Functions for manipulating state objects

# File 'ext/cairo/rb_cairo_context.c', line 212

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);
  rb_ivar_set (self, cr_id_source, Qnil);
  if (rb_ivar_defined (target, rb_cairo__io_id_output))
    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;
}

Class Method Details

.create ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 151

static VALUE
cr_s_create (int argc, VALUE *argv, VALUE klass)
{
  VALUE rb_cr;
  rb_cr = rb_funcallv (klass, cr_id_new, argc, argv);
  if (rb_block_given_p ())
    {
      return rb_ensure (rb_yield, rb_cr,
                        cr_destroy_with_destroy_check, rb_cr);
    }
  else
    {
      return rb_cr;
    }
}

.wrap ⇒ `Object`

For integrate other libraries such as a FFI based library.

# File 'ext/cairo/rb_cairo_context.c', line 167

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

Instance Method Details

#antialias ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1453

static VALUE
cr_get_antialias(VALUE self)
{
  return INT2NUM (cairo_get_antialias (_SELF));
}

#append_path ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1590

static VALUE
cr_copy_append_path (VALUE self, VALUE path)
{
  cairo_append_path (_SELF, RVAL2CRPATH (path));
  cr_check_status (_SELF);
  return self;
}

#arc ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 784

static VALUE
cr_arc (VALUE self, VALUE xc, VALUE yc, VALUE radius,
        VALUE angle1, VALUE angle2)
{
  cairo_arc (_SELF, NUM2DBL (xc), NUM2DBL (yc), NUM2DBL (radius),
             NUM2DBL (angle1), NUM2DBL (angle2));
  cr_check_status (_SELF);
  return self;
}

#arc_negative ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 794

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

#begin_tag ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1649

static VALUE
cr_begin_tag (int argc, VALUE *argv, VALUE self)
{
  VALUE rb_name;
  VALUE rb_attributes;
  const char *name;
  const char *attributes = NULL;

  rb_scan_args (argc, argv, "11", &rb_name, &rb_attributes);

  name = RVAL2CSTR (rb_name);
  if (!NIL_P (rb_attributes))
    attributes = RVAL2CSTR (rb_attributes);

  cairo_tag_begin (_SELF, name, attributes);
  cr_check_status (_SELF);

  return Qnil;
}

#clip ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1113

static VALUE
cr_clip (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_clip_preserve(_SELF);
  else
    cairo_clip (_SELF);

  cr_check_status (_SELF);
  return self;
}

#clip_extents ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1136

static VALUE
cr_clip_extents (VALUE self)
{
  double x1, y1, x2, y2;
  cairo_clip_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));
}

#clip_preserve(&block) ⇒ `Object`



25
26
27

# File 'lib/cairo/context.rb', line 25

def clip_preserve(&block)
  clip(true, &block)
end

#clip_rectangle_list ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1147

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

#close_path ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 879

static VALUE
cr_close_path (VALUE self)
{
  cairo_close_path (_SELF);
  cr_check_status (_SELF);
  return self;
}

#copy_page ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1025

static VALUE
cr_copy_page (VALUE self)
{
  cairo_copy_page (_SELF);
  cr_check_status (_SELF);
  return self;
}

#copy_path ⇒ `Object`

Paths

# File 'ext/cairo/rb_cairo_context.c', line 1570

static VALUE
cr_copy_path (VALUE self)
{
  cairo_path_t *path;

  path = cairo_copy_path (_SELF);
  rb_cairo_check_status (path->status);
  return CRPATH2RVAL (path);
}

#copy_path_flat ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1580

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

#current_point ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1467

static VALUE
cr_get_current_point (VALUE self)
{
  double point[2];
  cairo_get_current_point (_SELF, point, point + 1);
  return rb_cairo__float_array (point, 2);
}

#curve_to ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 761

static VALUE
cr_curve_to_generic (int argc, VALUE *argv, VALUE self)
{
  VALUE x1, y1, x2, y2, x3, y3;

  rb_scan_args (argc, argv, "42", &x1, &y1, &x2, &y2, &x3, &y3);

  if (!(argc == 4 || argc == 6))
    {
      VALUE inspected_arg = rb_inspect (rb_ary_new4 (argc, argv));
      rb_raise (rb_eArgError,
                "invalid argument: %s (expect "
                "(x1, y1, x2, y2) (quadratic) or "
                "(x1, y1, x2, y2, x3, y3) (cubic))",
                StringValuePtr (inspected_arg));
    }

  if (argc == 4)
    return cr_quadratic_curve_to (self, x1, y1, x2, y2);
  else
    return cr_curve_to (self, x1, y1, x2, y2, x3, y3);
}

#dash ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1512

static VALUE
cr_get_dash (VALUE self)
{
  int count;
  double *dashes, offset;

  count = cairo_get_dash_count (_SELF);
  dashes = ALLOCA_N (double, count);
  cairo_get_dash (_SELF, dashes, &offset);

  return rb_ary_new3 (2,
                      rb_cairo__float_array (dashes, count),
                      rb_float_new (offset));
}

#dash_count ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1506

static VALUE
cr_get_dash_count (VALUE self)
{
  return INT2NUM (cairo_get_dash_count (_SELF));
}

#destroy ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 112

static VALUE
cr_destroy (VALUE self)
{
  cairo_t *cr;

  cr = _SELF;
  cr_set_user_data (cr, &cr_object_holder_key, NULL, NULL);
  cairo_destroy (cr);

  DATA_PTR (self) = NULL;
  return Qnil;
}

#destroyed? ⇒ `Boolean`

Returns:

(Boolean)

# File 'ext/cairo/rb_cairo_context.c', line 125

static VALUE
cr_destroyed (VALUE self)
{
  return CBOOL2RVAL (DATA_PTR (self) == NULL);
}

#device_to_user ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 665

static VALUE
cr_device_to_user (VALUE self, VALUE x, VALUE y)
{
  double pair[2];
  pair[0] = NUM2DBL (x);
  pair[1] = NUM2DBL (y);
  cairo_device_to_user (_SELF, pair, pair + 1);
  cr_check_status (_SELF);
  return rb_cairo__float_array (pair, 2);
}

#device_to_user_distance ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 676

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

#end_tag ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1669

static VALUE
cr_end_tag (VALUE self, VALUE rb_name)
{
  const char *name;

  name = RVAL2CSTR (rb_name);
  cairo_tag_end (_SELF, name);
  cr_check_status (_SELF);

  return Qnil;
}

#fill ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1002

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

#fill_extents ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1091

static VALUE
cr_fill_extents (VALUE self)
{
  double extents[4];
  if (rb_block_given_p ())
    {
      cr_new_path (self);
      rb_yield (self);
    }
  cairo_fill_extents (_SELF, extents, extents + 1, extents + 2, extents + 3);
  return rb_cairo__float_array (extents, 4);
}

#fill_preserve(&block) ⇒ `Object`



21
22
23

# File 'lib/cairo/context.rb', line 21

def fill_preserve(&block)
  fill(true, &block)
end

#fill_rule ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1475

static VALUE
cr_get_fill_rule (VALUE self)
{
  return INT2FIX (cairo_get_fill_rule (_SELF));
}

#font_extents ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1354

static VALUE
cr_font_extents (VALUE self)
{
  cairo_font_extents_t extents;
  cairo_font_extents (_SELF, &extents);
  cr_check_status (_SELF);
  return CRFONTEXTENTS2RVAL (&extents);
}

#font_face ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1344

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

#font_matrix ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1236

static VALUE
cr_get_font_matrix (VALUE self)
{
  cairo_matrix_t matrix;
  cairo_get_font_matrix (_SELF, &matrix);
  cr_check_status (_SELF);
  return CRMATRIX2RVAL (&matrix);
}

#font_options ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1253

static VALUE
cr_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_get_font_options (_SELF, options);
  cr_check_status (_SELF);
  rb_cairo_check_status (cairo_font_options_status (options));

  return rb_options;
}

#glyph_extents ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1380

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

#glyph_path ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1401

static VALUE
cr_glyph_path (VALUE self, VALUE rb_glyphs)
{
  int count;
  cairo_glyph_t *glyphs;

  RB_CAIRO__GLYPHS_TO_ARRAY (rb_glyphs, glyphs, count);
  cairo_glyph_path (_SELF, glyphs, count);
  cr_check_status (_SELF);

  return self;
}

#group_target ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1557

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

#have_current_point? ⇒ `Boolean` Also known as: has_current_point?

Returns:

(Boolean)

# File 'ext/cairo/rb_cairo_context.c', line 1460

static VALUE
cr_has_current_point(VALUE self)
{
  return RTEST (cairo_has_current_point (_SELF));
}

#identity_matrix ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 635

static VALUE
cr_identity_matrix (VALUE self)
{
  cairo_identity_matrix (_SELF);
  cr_check_status (_SELF);
  return self;
}

#in_clip? ⇒ `Boolean`

Returns:

(Boolean)

# File 'ext/cairo/rb_cairo_context.c', line 1065

static VALUE
cr_in_clip (VALUE self, VALUE x, VALUE y)
{
  if (rb_block_given_p ())
    {
      cr_new_path (self);
      rb_yield (self);
    }
  return CBOOL2RVAL (cairo_in_clip (_SELF, NUM2DBL (x), NUM2DBL (y)));
}

#in_fill? ⇒ `Boolean`

Returns:

(Boolean)

# File 'ext/cairo/rb_cairo_context.c', line 1053

static VALUE
cr_in_fill (VALUE self, VALUE x, VALUE y)
{
  if (rb_block_given_p ())
    {
      cr_new_path (self);
      rb_yield (self);
    }
  return CBOOL2RVAL (cairo_in_fill (_SELF, NUM2DBL (x), NUM2DBL (y)));
}

#in_stroke? ⇒ `Boolean`

Insideness testing

Returns:

(Boolean)

# File 'ext/cairo/rb_cairo_context.c', line 1042

static VALUE
cr_in_stroke (VALUE self, VALUE x, VALUE y)
{
  if (rb_block_given_p ())
    {
      cr_new_path (self);
      rb_yield (self);
    }
  return CBOOL2RVAL (cairo_in_stroke (_SELF, NUM2DBL (x), NUM2DBL (y)));
}

#line_cap ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1487

static VALUE
cr_get_line_cap (VALUE self)
{
  return INT2FIX (cairo_get_line_cap (_SELF));
}

#line_join ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1493

static VALUE
cr_get_line_join (VALUE self)
{
  return INT2FIX (cairo_get_line_join (_SELF));
}

#line_to ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 713

static VALUE
cr_line_to (VALUE self, VALUE x, VALUE y)
{
  cairo_line_to (_SELF, NUM2DBL (x), NUM2DBL (y));
  cr_check_status (_SELF);
  return self;
}

#line_width ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1481

static VALUE
cr_get_line_width (VALUE self)
{
  return rb_float_new (cairo_get_line_width (_SELF));
}

#mask ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 957

static VALUE
cr_mask_generic (int argc, VALUE *argv, VALUE self)
{
  VALUE arg1, arg2, arg3;
  int n;

  n = rb_scan_args (argc, argv, "12", &arg1, &arg2, &arg3);

  if (n == 1)
    {
      return cr_mask (self, arg1);
    }
  else if (n == 3)
    {
      return cr_mask_surface (self, arg1, arg2, arg3);
    }
  else
    {
      rb_raise (rb_eArgError,
                "invalid argument (expect (pattern) or (surface, x, y))");
    }
}

#matrix ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1528

static VALUE
cr_get_matrix (VALUE self)
{
  cairo_matrix_t matrix;
  cairo_get_matrix (_SELF, &matrix);
  cr_check_status (_SELF);
  return CRMATRIX2RVAL (&matrix);
}

#miter_limit ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1499

static VALUE
cr_get_miter_limit (VALUE self)
{
  return rb_float_new (cairo_get_miter_limit (_SELF));
}

#move_to ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 697

static VALUE
cr_move_to (VALUE self, VALUE x, VALUE y)
{
  cairo_move_to (_SELF, NUM2DBL (x), NUM2DBL (y));
  cr_check_status (_SELF);
  return self;
}

#new_path ⇒ `Object`

Path creation functions

# File 'ext/cairo/rb_cairo_context.c', line 689

static VALUE
cr_new_path (VALUE self)
{
  cairo_new_path (_SELF);
  cr_check_status (_SELF);
  return self;
}

#new_sub_path ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 705

static VALUE
cr_new_sub_path (VALUE self)
{
  cairo_new_sub_path (_SELF);
  cr_check_status (_SELF);
  return self;
}

#operator ⇒ `Object`

Query functions

# File 'ext/cairo/rb_cairo_context.c', line 1415

static VALUE
cr_get_operator (VALUE self)
{
  return INT2FIX (cairo_get_operator (_SELF));
}

#paint ⇒ `Object`

Painting functions

# File 'ext/cairo/rb_cairo_context.c', line 917

static VALUE
cr_paint_generic (int argc, VALUE *argv, VALUE self)
{
  VALUE alpha;
  int n;

  n = rb_scan_args (argc, argv, "01", &alpha);

  if (n == 0 || (n == 1 && NIL_P (alpha)))
    {
      return cr_paint (self);
    }
  if (n == 1)
    {
      return cr_paint_with_alpha (self, alpha);
    }
  else
    {
      rb_raise (rb_eArgError,
                "invalid argument (expect () or (alpha))");
    }
}

#path_extents ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 888

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

#pop_group ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 286

static VALUE
cr_pop_group_generic (int argc, VALUE *argv, VALUE self)
{
  VALUE to_source;
  rb_scan_args (argc, argv, "01", &to_source);
  if (RVAL2CBOOL (to_source))
    return cr_pop_group_to_source (self);
  else
    return cr_pop_group (self);
}

#pop_group_to_source ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 278

static VALUE
cr_pop_group_to_source (VALUE self)
{
  cairo_pop_group_to_source (_SELF);
  cr_check_status (_SELF);
  return Qnil;
}

#push_group ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 297

static VALUE
cr_push_group (int argc, VALUE *argv, VALUE self)
{
  VALUE result = Qnil;
  VALUE content, pop_to_source;
  rb_scan_args (argc, argv, "02", &content, &pop_to_source);

  if (NIL_P(content))
    cairo_push_group (_SELF);
  else
    cairo_push_group_with_content (_SELF, RVAL2CRCONTENT(content));
  cr_check_status (_SELF);

  if (rb_block_given_p ())
    {
      int state = 0;

      if (NIL_P (pop_to_source))
        pop_to_source = Qtrue;

      result = rb_protect (rb_yield, self, &state);
      if (cairo_status(_SELF) == CAIRO_STATUS_SUCCESS)
        {
          if (RVAL2CBOOL (pop_to_source))
            cr_pop_group_to_source (self);
          else
            result = cr_pop_group (self);
        }

      if (state)
        rb_jump_tag (state);
    }

  return result;
}

#rectangle ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 870

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

#reference_count ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 139

static VALUE
cr_get_reference_count (VALUE self)
{
  cairo_t *cr;
  unsigned int  reference_count;

  cr = _SELF;
  reference_count = cairo_get_reference_count (cr);

  return UINT2NUM (reference_count);
}

#rel_curve_to ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 847

static VALUE
cr_rel_curve_to_generic (int argc, VALUE *argv, VALUE self)
{
  VALUE dx1, dy1, dx2, dy2, dx3, dy3;

  rb_scan_args (argc, argv, "42", &dx1, &dy1, &dx2, &dy2, &dx3, &dy3);

  if (!(argc == 4 || argc == 6))
    {
      VALUE inspected_arg = rb_inspect (rb_ary_new4 (argc, argv));
      rb_raise (rb_eArgError,
                "invalid argument: %s (expect "
                "(dx1, dy1, dx2, dy2) (quadratic) or "
                "(dx1, dy1, dx2, dy2, dx3, dy3) (cubic))",
                StringValuePtr (inspected_arg));
    }

  if (argc == 4)
    return cr_rel_quadratic_curve_to (self, dx1, dy1, dx2, dy2);
  else
    return cr_rel_curve_to (self, dx1, dy1, dx2, dy2, dx3, dy3);
}

#rel_line_to ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 812

static VALUE
cr_rel_line_to (VALUE self, VALUE x, VALUE y)
{
  cairo_rel_line_to (_SELF, NUM2DBL (x), NUM2DBL (y));
  cr_check_status (_SELF);
  return self;
}

#rel_move_to ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 804

static VALUE
cr_rel_move_to (VALUE self, VALUE x, VALUE y)
{
  cairo_rel_move_to (_SELF, NUM2DBL (x), NUM2DBL (y));
  cr_check_status (_SELF);
  return self;
}

#reset_clip ⇒ `Object`

Clipping

# File 'ext/cairo/rb_cairo_context.c', line 1105

static VALUE
cr_reset_clip (VALUE self)
{
  cairo_reset_clip (_SELF);
  cr_check_status (_SELF);
  return self;
}

#restore ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 244

static VALUE
cr_restore (VALUE self)
{
  cairo_restore (_SELF);
  cr_check_status (_SELF);
  return Qnil;
}

#rotate ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 611

static VALUE
cr_rotate (VALUE self, VALUE radians)
{
  cairo_rotate (_SELF, NUM2DBL (radians));
  cr_check_status (_SELF);
  return self;
}

#save ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 252

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

#scale ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 603

static VALUE
cr_scale (VALUE self, VALUE sx, VALUE sy)
{
  cairo_scale (_SELF, NUM2DBL (sx), NUM2DBL (sy));
  cr_check_status (_SELF);
  return self;
}

#scaled_font ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1283

static VALUE
cr_get_scaled_font (VALUE self)
{
  return CRSCALEDFONT2RVAL (cairo_get_scaled_font (_SELF));
}

#select_font_face ⇒ `Object`

Font/Text functions

# File 'ext/cairo/rb_cairo_context.c', line 1176

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

#set_antialias(antialias) ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 497

static VALUE
cr_set_antialias(VALUE self, VALUE antialias)
{
  cairo_set_antialias(_SELF, RVAL2CRANTIALIAS (antialias));
  cr_check_status(_SELF);
  return self;
}

#set_dash ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 536

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

#set_fill_rule ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 505

static VALUE
cr_set_fill_rule (VALUE self, VALUE rule)
{
  cairo_set_fill_rule (_SELF, RVAL2CRFILLRULE (rule));
  cr_check_status (_SELF);
  return self;
}

#set_font_face ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1363

static VALUE
cr_set_font_face (VALUE self, VALUE face)
{
  cairo_set_font_face (_SELF, NIL_P (face) ? NULL : RVAL2CRFONTFACE (face));
  cr_check_status (_SELF);
  return self;
}

#set_font_matrix ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1228

static VALUE
cr_set_font_matrix (VALUE self, VALUE matrix)
{
  cairo_set_font_matrix (_SELF, RVAL2CRMATRIX (matrix));
  cr_check_status (_SELF);
  return self;
}

#set_font_options ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1245

static VALUE
cr_set_font_options (VALUE self, VALUE options)
{
  cairo_set_font_options (_SELF, RVAL2CRFONTOPTIONS (options));
  cr_check_status (_SELF);
  return self;
}

#set_font_size ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1220

static VALUE
cr_set_font_size (VALUE self, VALUE scale)
{
  cairo_set_font_size (_SELF, NUM2DBL (scale));
  cr_check_status (_SELF);
  return self;
}

#set_line_cap ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 520

static VALUE
cr_set_line_cap (VALUE self, VALUE cap)
{
  cairo_set_line_cap (_SELF, RVAL2CRLINECAP (cap));
  cr_check_status (_SELF);
  return self;
}

#set_line_join ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 528

static VALUE
cr_set_line_join (VALUE self, VALUE join)
{
  cairo_set_line_join (_SELF, RVAL2CRLINEJOIN (join));
  cr_check_status (_SELF);
  return self;
}

#set_line_width ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 513

static VALUE
cr_set_line_width (VALUE self, VALUE width)
{
  cairo_set_line_width (_SELF, NUM2DBL (width));
  return self;
}

#set_matrix ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 627

static VALUE
cr_set_matrix (VALUE self, VALUE matrix)
{
  cairo_set_matrix (_SELF, RVAL2CRMATRIX (matrix));
  cr_check_status (_SELF);
  return self;
}

#set_miter_limit ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 587

static VALUE
cr_set_miter_limit (VALUE self, VALUE limit)
{
  cairo_set_miter_limit (_SELF, NUM2DBL (limit));
  cr_check_status (_SELF);
  return self;
}

#set_operator ⇒ `Object`

Modify state

# File 'ext/cairo/rb_cairo_context.c', line 335

static VALUE
cr_set_operator (VALUE self, VALUE operator)
{
  cairo_set_operator (_SELF, RVAL2CROPERATOR (operator));
  cr_check_status (_SELF);
  return self;
}

#set_scaled_font ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1274

static VALUE
cr_set_scaled_font (VALUE self, VALUE scaled_font)
{
  cairo_set_scaled_font (_SELF, RVAL2CRSCALEDFONT (scaled_font));
  cr_check_status (_SELF);
  return self;
}

#set_source ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 449

static VALUE
cr_set_source_generic (int argc, VALUE *argv, VALUE self)
{
  VALUE arg1, arg2, arg3, arg4;
  int n;

  n = rb_scan_args (argc, argv, "13", &arg1, &arg2, &arg3, &arg4);

  if (n == 1 && rb_cairo__is_kind_of (arg1, rb_cArray))
    {
      return cr_set_source_rgba (argc, argv, self);
    }
  else if (n == 1 && rb_cairo__is_kind_of (arg1, rb_cCairo_Surface))
    {
      return cr_set_source_surface (self, arg1,
                                    rb_float_new (0),
                                    rb_float_new (0));
    }
  else if (n == 1)
    {
      return cr_set_source (self, arg1);
    }
  else if (n == 3 && rb_cairo__is_kind_of (arg1, rb_cCairo_Surface))
    {
      return cr_set_source_surface (self, arg1, arg2, arg3);
    }
  else if (n == 3 || n == 4)
    {
      return cr_set_source_rgba (argc, argv, self);
    }
  else
    {
      rb_raise (rb_eArgError,
                "invalid argument (expect "
                "(red, green, blue), (red, green, blue, alpha), "
                "([red, green, blue]), ([red, green, blue, alpha]), "
                "(surface), (pattern) or (surface, x, y))");
    }
}

#set_source_rgb ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 343

static VALUE
cr_set_source_rgb (int argc, VALUE *argv, VALUE self)
{
  VALUE red, green, blue;
  int n;

  n = rb_scan_args (argc, argv, "12", &red, &green, &blue);

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

  if (n == 3)
    {
      cairo_set_source_rgb (_SELF,
                            NUM2DBL (red),
                            NUM2DBL (green),
                            NUM2DBL (blue));
    }
  else
    {
      VALUE inspected_arg = rb_inspect (rb_ary_new4 (argc, argv));
      rb_raise (rb_eArgError,
                "invalid RGB: %s (expect "
                "(red, green, blue) or ([red, green, blue]))",
                StringValuePtr (inspected_arg));
    }
  cr_check_status (_SELF);
  rb_ivar_set (self, cr_id_source, Qnil);
  return self;
}

#set_source_rgba ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 380

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

#set_tolerance ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 489

static VALUE
cr_set_tolerance (VALUE self, VALUE tolerance)
{
  cairo_set_tolerance (_SELF, NUM2DBL (tolerance));
  cr_check_status (_SELF);
  return self;
}

#show_glyphs ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1298

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

#show_page ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1033

static VALUE
cr_show_page (VALUE self)
{
  cairo_show_page (_SELF);
  cr_check_status (_SELF);
  return self;
}

#show_text ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1290

static VALUE
cr_show_text (VALUE self, VALUE utf8)
{
  cairo_show_text (_SELF, RVAL2CSTR (utf8));
  cr_check_status (_SELF);
  return self;
}

#show_text_glyphs ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1311

static VALUE
cr_show_text_glyphs (VALUE self, VALUE rb_utf8, VALUE rb_glyphs,
                     VALUE rb_clusters, VALUE rb_cluster_flags)
{
  cairo_t *cr;
  const char *utf8;
  int utf8_len;
  cairo_glyph_t *glyphs = NULL;
  int num_glyphs = 0;
  cairo_text_cluster_t *clusters = NULL;
  int num_clusters = 0;
  cairo_text_cluster_flags_t cluster_flags;

  cr = _SELF;
  utf8 = RSTRING_PTR (rb_utf8);
  utf8_len = RSTRING_LEN (rb_utf8);
  rb_cairo__glyphs_from_ruby_object (rb_glyphs, &glyphs, &num_glyphs);
  rb_cairo__text_clusters_from_ruby_object (rb_clusters,
                                            &clusters, &num_clusters);
  cluster_flags = RVAL2CRTEXTCLUSTERFLAGS (rb_cluster_flags);
  cairo_show_text_glyphs (cr, utf8, utf8_len,
                          glyphs, num_glyphs,
                          clusters, num_clusters,
                          cluster_flags);
  if (glyphs)
    cairo_glyph_free (glyphs);
  if (clusters)
    cairo_text_cluster_free (clusters);

  return self;
}

#source ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1421

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

#stroke ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 980

static VALUE
cr_stroke (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_stroke_preserve (_SELF);
  else
    cairo_stroke (_SELF);

  cr_check_status (_SELF);
  return self;
}

#stroke_extents ⇒ `Object`

Rectangular extents

# File 'ext/cairo/rb_cairo_context.c', line 1078

static VALUE
cr_stroke_extents (VALUE self)
{
  double extents[4];
  if (rb_block_given_p ())
    {
      cr_new_path (self);
      rb_yield (self);
    }
  cairo_stroke_extents (_SELF, extents, extents + 1, extents + 2, extents + 3);
  return rb_cairo__float_array (extents, 4);
}

#stroke_preserve(&block) ⇒ `Object`



17
18
19

# File 'lib/cairo/context.rb', line 17

def stroke_preserve(&block)
  stroke(true, &block)
end

#tag ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1619

static VALUE
cr_tag (int argc, VALUE *argv, VALUE self)
{
  VALUE rb_name;
  VALUE rb_attributes;
  const char *name;
  const char *attributes = NULL;

  rb_scan_args (argc, argv, "11", &rb_name, &rb_attributes);

  name = RVAL2CSTR (rb_name);
  if (!NIL_P (rb_attributes))
    attributes = RVAL2CSTR (rb_attributes);

  cairo_tag_begin (_SELF, name, attributes);
  cr_check_status (_SELF);
  if (rb_block_given_p ())
    {
      rb_cairo_context_tag_ensure_data_t data;
      data.self = self;
      data.name = name;
      return rb_ensure (rb_yield, self,
                        cr_tag_ensure, (VALUE)&data);
    }
  else
    {
      return Qnil;
    }
}

#target ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1537

static VALUE
cr_get_target (VALUE self)
{
  cairo_surface_t *surface;
  VALUE rb_surface = Qnil;

  surface = cairo_get_target (_SELF);
  rb_cairo_check_status (cairo_surface_status (surface));

  if (RTEST (rb_ivar_defined (self, cr_id_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;
}

#text_extents ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1371

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

#text_path ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1393

static VALUE
cr_text_path (VALUE self, VALUE utf8)
{
  cairo_text_path (_SELF, StringValuePtr (utf8));
  cr_check_status (_SELF);
  return self;
}

#to_ptr ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 233

static VALUE
cr_to_ptr (VALUE self)
{
  if (NIL_P (rb_cairo__cFFIPointer))
    return Qnil;

  return rb_funcall (rb_cairo__cFFIPointer, rb_intern ("new"),
                     1, PTR2NUM (_SELF));
}

#tolerance ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 1447

static VALUE
cr_get_tolerance (VALUE self)
{
  return rb_float_new (cairo_get_tolerance (_SELF));
}

#transform ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 619

static VALUE
cr_transform (VALUE self, VALUE matrix)
{
  cairo_transform (_SELF, RVAL2CRMATRIX (matrix));
  cr_check_status (_SELF);
  return self;
}

#translate ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 595

static VALUE
cr_translate (VALUE self, VALUE tx, VALUE ty)
{
  cairo_translate (_SELF, NUM2DBL (tx), NUM2DBL (ty));
  cr_check_status (_SELF);
  return self;
}

#user_to_device ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 643

static VALUE
cr_user_to_device (VALUE self, VALUE x, VALUE y)
{
  double pair[2];
  pair[0] = NUM2DBL (x);
  pair[1] = NUM2DBL (y);
  cairo_user_to_device (_SELF, pair, pair + 1);
  cr_check_status (_SELF);
  return rb_cairo__float_array (pair, 2);
}

#user_to_device_distance ⇒ `Object`

# File 'ext/cairo/rb_cairo_context.c', line 654

static VALUE
cr_user_to_device_distance (VALUE self, VALUE dx, VALUE dy)
{
  double pair[2];
  pair[0] = NUM2DBL (dx);
  pair[1] = NUM2DBL (dy);
  cairo_user_to_device_distance (_SELF, pair, pair + 1);
  cr_check_status (_SELF);
  return rb_cairo__float_array (pair, 2);
}

Class: Cairo::Context

Defined Under Namespace

Constant Summary

Constants included from Color

Constants included from Cairo::Color::X11

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Color

Methods included from Blur

Methods included from Path

Methods included from Circle

Methods included from Triangle

Methods included from Rectangle

Constructor Details

#initialize ⇒ Object

Class Method Details

.create ⇒ Object

.wrap ⇒ Object

Instance Method Details

#antialias ⇒ Object

#append_path ⇒ Object

#arc ⇒ Object

#arc_negative ⇒ Object

#begin_tag ⇒ Object

#clip ⇒ Object

#clip_extents ⇒ Object

#clip_preserve(&block) ⇒ Object

#clip_rectangle_list ⇒ Object

#close_path ⇒ Object

#copy_page ⇒ Object

#copy_path ⇒ Object

#copy_path_flat ⇒ Object

#current_point ⇒ Object

#curve_to ⇒ Object

#dash ⇒ Object

#dash_count ⇒ Object

#destroy ⇒ Object

#destroyed? ⇒ Boolean

#device_to_user ⇒ Object

#device_to_user_distance ⇒ Object

#end_tag ⇒ Object

#fill ⇒ Object

#fill_extents ⇒ Object

#fill_preserve(&block) ⇒ Object

#fill_rule ⇒ Object

#font_extents ⇒ Object

#font_face ⇒ Object

#font_matrix ⇒ Object

#font_options ⇒ Object

#glyph_extents ⇒ Object

#glyph_path ⇒ Object

#group_target ⇒ Object

#have_current_point? ⇒ Boolean Also known as: has_current_point?

#identity_matrix ⇒ Object

#in_clip? ⇒ Boolean

#in_fill? ⇒ Boolean

#in_stroke? ⇒ Boolean

#line_cap ⇒ Object

#line_join ⇒ Object

#line_to ⇒ Object

#line_width ⇒ Object

#mask ⇒ Object

#matrix ⇒ Object

#miter_limit ⇒ Object

#move_to ⇒ Object

#new_path ⇒ Object

#new_sub_path ⇒ Object

#operator ⇒ Object

#paint ⇒ Object

#path_extents ⇒ Object

#pop_group ⇒ Object

#pop_group_to_source ⇒ Object

#push_group ⇒ Object

#rectangle ⇒ Object

#reference_count ⇒ Object

#rel_curve_to ⇒ Object

#rel_line_to ⇒ Object

#rel_move_to ⇒ Object

#reset_clip ⇒ Object

#restore ⇒ Object

#initialize ⇒ `Object`

.create ⇒ `Object`

.wrap ⇒ `Object`

#antialias ⇒ `Object`

#append_path ⇒ `Object`

#arc ⇒ `Object`

#arc_negative ⇒ `Object`

#begin_tag ⇒ `Object`

#clip ⇒ `Object`

#clip_extents ⇒ `Object`

#clip_preserve(&block) ⇒ `Object`

#clip_rectangle_list ⇒ `Object`

#close_path ⇒ `Object`

#copy_page ⇒ `Object`

#copy_path ⇒ `Object`

#copy_path_flat ⇒ `Object`

#current_point ⇒ `Object`

#curve_to ⇒ `Object`

#dash ⇒ `Object`

#dash_count ⇒ `Object`

#destroy ⇒ `Object`

#destroyed? ⇒ `Boolean`

#device_to_user ⇒ `Object`

#device_to_user_distance ⇒ `Object`

#end_tag ⇒ `Object`

#fill ⇒ `Object`

#fill_extents ⇒ `Object`

#fill_preserve(&block) ⇒ `Object`

#fill_rule ⇒ `Object`

#font_extents ⇒ `Object`

#font_face ⇒ `Object`

#font_matrix ⇒ `Object`

#font_options ⇒ `Object`

#glyph_extents ⇒ `Object`

#glyph_path ⇒ `Object`

#group_target ⇒ `Object`

#have_current_point? ⇒ `Boolean` Also known as: has_current_point?

#identity_matrix ⇒ `Object`

#in_clip? ⇒ `Boolean`

#in_fill? ⇒ `Boolean`

#in_stroke? ⇒ `Boolean`

#line_cap ⇒ `Object`

#line_join ⇒ `Object`

#line_to ⇒ `Object`

#line_width ⇒ `Object`

#mask ⇒ `Object`

#matrix ⇒ `Object`

#miter_limit ⇒ `Object`

#move_to ⇒ `Object`

#new_path ⇒ `Object`

#new_sub_path ⇒ `Object`

#operator ⇒ `Object`

#paint ⇒ `Object`

#path_extents ⇒ `Object`

#pop_group ⇒ `Object`

#pop_group_to_source ⇒ `Object`

#push_group ⇒ `Object`

#rectangle ⇒ `Object`

#reference_count ⇒ `Object`

#rel_curve_to ⇒ `Object`

#rel_line_to ⇒ `Object`

#rel_move_to ⇒ `Object`

#reset_clip ⇒ `Object`

#restore ⇒ `Object`

#rotate ⇒ `Object`

#save ⇒ `Object`

#scale ⇒ `Object`

#scaled_font ⇒ `Object`

#select_font_face ⇒ `Object`

#set_antialias(antialias) ⇒ `Object`

#set_dash ⇒ `Object`

#set_fill_rule ⇒ `Object`

#set_font_face ⇒ `Object`

#set_font_matrix ⇒ `Object`

#set_font_options ⇒ `Object`

#set_font_size ⇒ `Object`

#set_line_cap ⇒ `Object`

#set_line_join ⇒ `Object`

#set_line_width ⇒ `Object`

#set_matrix ⇒ `Object`