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 206

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 145

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 161

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 1447

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

#append_path ⇒ `Object`

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

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 778

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 788

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 1643

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 1107

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 1130

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 1141

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 873

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 1019

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 1564

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 1574

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 1461

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 755

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 1506

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 1500

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

#device_to_user ⇒ `Object`

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

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 670

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 1663

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 996

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 1085

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 1469

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 1348

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 1338

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 1230

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 1247

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 1374

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 1395

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 1551

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 1454

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 629

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 1059

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 1047

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 1036

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 1481

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 1487

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 707

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 1475

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 951

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 1522

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 1493

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 691

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 683

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 699

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 1409

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 911

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 882

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 280

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 272

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 291

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 864

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 133

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 841

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 806

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 798

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 1099

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 238

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 605

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 246

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 597

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 1277

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 1170

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 491

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 530

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 499

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 1357

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 1222

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 1239

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 1214

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 514

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 522

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 507

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 621

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 581

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 329

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 1268

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 443

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 337

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 374

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 483

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 1292

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 1027

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 1284

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 1305

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 1415

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 974

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 1072

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 1613

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 1531

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 1365

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 1387

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 227

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 1441

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 613

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 589

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 637

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 648

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

#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

#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`

#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`

#set_miter_limit ⇒ `Object`