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

.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 189

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

.wrap ⇒ `Object`

For integrate other libraries such as a FFI based library.

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

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 1419

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

#append_path ⇒ `Object`

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

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 761

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 771

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 1615

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 1090

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 1113

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 1124

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 856

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 1002

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 1536

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 1546

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 1433

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 738

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 1478

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 1472

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 111

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 642

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 653

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 1635

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 979

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 1068

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 1441

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 1320

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 1310

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 1213

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 1230

static VALUE
cr_get_font_options (VALUE self)
{
  cairo_font_options_t *options = cairo_font_options_create ();
  rb_cairo_check_status (cairo_font_options_status (options));
  cairo_get_font_options (_SELF, options);
  rb_cairo_check_status (cairo_font_options_status (options));
  return CRFONTOPTIONS2RVAL (options);
}

#glyph_extents ⇒ `Object`

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

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 1367

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 1523

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 1426

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 612

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 1042

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 1030

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 1019

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 1453

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 1459

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 690

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 1447

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 934

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 1494

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 1465

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 674

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 666

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 682

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 1381

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 894

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 865

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 263

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 255

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 274

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 847

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 132

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 824

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 789

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 781

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 1082

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 221

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 588

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 229

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 580

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 1249

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 1153

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 474

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 513

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 482

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 1329

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 1205

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 1222

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 1197

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 497

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 505

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 490

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 604

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 564

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 312

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 1240

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 426

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 320

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 357

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 466

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 1264

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 1010

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 1256

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 1277

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 1387

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 957

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 1055

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 1585

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 1503

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 1337

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 1359

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 210

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 1413

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 596

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 572

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 620

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 631

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

.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

#save ⇒ Object

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

#set_operator ⇒ `Object`