cairo 1.14.0-x64-mingw32

data/ext/cairo/rb_cairo_io.h

@@ -0,0 +1,44 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * Copyright 2005-2010 Kouhei Sutou <kou@cozmixng.org>
+ *
+ * This file is made available under the same terms as Ruby
+ *
+*/
+
+#ifndef RB_CAIRO_IO_H
+#define RB_CAIRO_IO_H
+
+#include <rb_cairo.h>
+
+typedef struct rb_cairo__io_callback_closure {
+  VALUE target;
+  VALUE error;
+  unsigned char *data;
+  unsigned int length;
+} rb_cairo__io_callback_closure_t;
+
+typedef struct rb_cairo__io_invoke_data {
+  cr_callback_func_t func;
+  VALUE data;
+} rb_cairo__io_invoke_data_t;
+
+RB_CAIRO_VAR ID rb_cairo__io_id_read;
+RB_CAIRO_VAR ID rb_cairo__io_id_write;
+RB_CAIRO_VAR ID rb_cairo__io_id_output;
+
+rb_cairo__io_callback_closure_t *
+               rb_cairo__io_closure_new     (VALUE                target);
+void           rb_cairo__io_closure_destroy (rb_cairo__io_callback_closure_t *closure);
+void           rb_cairo__io_closure_free    (void                *closure);
+cairo_status_t rb_cairo__io_write_func      (void                *write_closure,
+                                             const unsigned char *data,
+                                             unsigned int         length);
+cairo_status_t rb_cairo__io_read_func       (void                *read_closure,
+                                             unsigned char       *data,
+                                             unsigned int         length);
+
+
+#endif

data/ext/cairo/rb_cairo_matrix.c

@@ -0,0 +1,366 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-08-14 12:37:50 $
+ *
+ * Copyright 2006-2008 Kouhei Sutou <kou@cozmixng.org>
+ * Copyright 2005 Øyvind Kolås <pippin@freedesktop.org>
+ * Copyright 2004-2005 MenTaLguY <mental@rydia.com>
+ *
+ * This file is made available under the same terms as Ruby
+ *
+ */
+
+
+#include "rb_cairo.h"
+#include "rb_cairo_private.h"
+
+VALUE rb_cCairo_Matrix;
+
+static ID cr_id_equal;
+
+#define _SELF  (RVAL2CRMATRIX(self))
+
+cairo_matrix_t *
+rb_cairo_matrix_from_ruby_object (VALUE obj)
+{
+  cairo_matrix_t *matrix;
+  if (!rb_cairo__is_kind_of (obj, rb_cCairo_Matrix))
+    {
+      rb_raise (rb_eTypeError, "not a cairo matrix");
+    }
+  Data_Get_Struct (obj, cairo_matrix_t, matrix);
+  return matrix;
+}
+
+static void
+cr_matrix_free (void *ptr)
+{
+  if (ptr)
+    {
+      xfree ((cairo_matrix_t *) ptr);
+    }
+}
+
+VALUE
+rb_cairo_matrix_to_ruby_object (cairo_matrix_t *matrix)
+{
+  if (matrix)
+    {
+      cairo_matrix_t *new_matrix = ALLOC (cairo_matrix_t);
+      *new_matrix = *matrix;
+      return Data_Wrap_Struct (rb_cCairo_Matrix, NULL,
+                               cr_matrix_free, new_matrix);
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+static VALUE
+cr_matrix_allocate (VALUE klass)
+{
+  return Data_Wrap_Struct (klass, NULL, cr_matrix_free, NULL);
+}
+
+static VALUE
+cr_matrix_initialize (VALUE self,
+                      VALUE xx, VALUE yx,
+                      VALUE xy, VALUE yy,
+                      VALUE x0, VALUE y0)
+{
+  cairo_matrix_t *matrix = ALLOC (cairo_matrix_t);
+
+  cairo_matrix_init (matrix,
+                     NUM2DBL (xx), NUM2DBL (yx),
+                     NUM2DBL (xy), NUM2DBL (yy),
+                     NUM2DBL (x0), NUM2DBL (y0));
+  DATA_PTR (self) = matrix;
+  return Qnil;
+}
+
+static VALUE
+cr_matrix_init_identity (VALUE self)
+{
+  cairo_matrix_t matrix;
+  cairo_matrix_init_identity (&matrix);
+  return CRMATRIX2RVAL (&matrix);
+}
+
+static VALUE
+cr_matrix_init_translate (VALUE self, VALUE tx, VALUE ty)
+{
+  cairo_matrix_t matrix;
+  cairo_matrix_init_translate (&matrix, NUM2DBL (tx), NUM2DBL (ty));
+  return CRMATRIX2RVAL (&matrix);
+}
+
+static VALUE
+cr_matrix_init_scale (VALUE self, VALUE sx, VALUE sy)
+{
+  cairo_matrix_t matrix;
+  cairo_matrix_init_scale (&matrix, NUM2DBL (sx), NUM2DBL (sy));
+  return CRMATRIX2RVAL (&matrix);
+}
+
+static VALUE
+cr_matrix_init_rotate (VALUE self, VALUE radius)
+{
+  cairo_matrix_t matrix;
+  cairo_matrix_init_rotate (&matrix, NUM2DBL (radius));
+  return CRMATRIX2RVAL (&matrix);
+}
+
+static VALUE
+cr_matrix_identity (VALUE self)
+{
+  cairo_matrix_init_identity (_SELF);
+  return self;
+}
+
+static VALUE
+cr_matrix_translate (VALUE self, VALUE tx, VALUE ty)
+{
+  cairo_matrix_translate (_SELF, NUM2DBL (tx), NUM2DBL (ty));
+  return self;
+}
+
+static VALUE
+cr_matrix_scale (VALUE self, VALUE sx, VALUE sy)
+{
+  cairo_matrix_scale (_SELF, NUM2DBL (sx), NUM2DBL (sy));
+  return self;
+}
+
+static VALUE
+cr_matrix_rotate (VALUE self, VALUE radians)
+{
+  cairo_matrix_rotate (_SELF, NUM2DBL (radians));
+  return self;
+}
+
+static VALUE
+cr_matrix_invert (VALUE self)
+{
+  rb_cairo_check_status (cairo_matrix_invert (_SELF));
+  return self;
+}
+
+static VALUE
+cr_matrix_multiply (VALUE self, VALUE other)
+{
+  cairo_matrix_multiply (_SELF, _SELF, RVAL2CRMATRIX (other));
+  return self;
+}
+
+static VALUE
+cr_matrix_transform_distance (VALUE self, VALUE dx, VALUE dy)
+{
+  double pair[2];
+  pair[0] = NUM2DBL (dx);
+  pair[1] = NUM2DBL (dy);
+  cairo_matrix_transform_distance (_SELF, pair, pair + 1);
+  return rb_cairo__float_array (pair, 2);
+}
+
+static VALUE
+cr_matrix_transform_point (VALUE self, VALUE x, VALUE y)
+{
+  double pair[2];
+  pair[0] = NUM2DBL (x);
+  pair[1] = NUM2DBL (y);
+  cairo_matrix_transform_point (_SELF, pair, pair + 1);
+  return rb_cairo__float_array (pair, 2);
+}
+
+
+/* Accessors */
+static VALUE
+cr_matrix_get_xx (VALUE self)
+{
+  return rb_float_new (_SELF->xx);
+}
+
+static VALUE
+cr_matrix_set_xx (VALUE self, VALUE xx)
+{
+  _SELF->xx = NUM2DBL (xx);
+  return Qnil;
+}
+
+static VALUE
+cr_matrix_get_yx (VALUE self)
+{
+  return rb_float_new (_SELF->yx);
+}
+
+static VALUE
+cr_matrix_set_yx (VALUE self, VALUE yx)
+{
+  _SELF->yx = NUM2DBL (yx);
+  return Qnil;
+}
+
+static VALUE
+cr_matrix_get_xy (VALUE self)
+{
+  return rb_float_new (_SELF->xy);
+}
+
+static VALUE
+cr_matrix_set_xy (VALUE self, VALUE xy)
+{
+  _SELF->xy = NUM2DBL (xy);
+  return Qnil;
+}
+
+static VALUE
+cr_matrix_get_yy (VALUE self)
+{
+  return rb_float_new (_SELF->yy);
+}
+
+static VALUE
+cr_matrix_set_yy (VALUE self, VALUE yy)
+{
+  _SELF->yy = NUM2DBL (yy);
+  return Qnil;
+}
+
+static VALUE
+cr_matrix_get_x0 (VALUE self)
+{
+  return rb_float_new (_SELF->x0);
+}
+
+static VALUE
+cr_matrix_set_x0 (VALUE self, VALUE x0)
+{
+  _SELF->x0 = NUM2DBL (x0);
+  return Qnil;
+}
+
+static VALUE
+cr_matrix_get_y0 (VALUE self)
+{
+  return rb_float_new (_SELF->y0);
+}
+
+static VALUE
+cr_matrix_set_y0 (VALUE self, VALUE y0)
+{
+  _SELF->y0 = NUM2DBL (y0);
+  return Qnil;
+}
+
+/* Utilities */
+static VALUE
+cr_matrix_set (VALUE self,
+               VALUE xx, VALUE yx,
+               VALUE xy, VALUE yy,
+               VALUE x0, VALUE y0)
+{
+  cairo_matrix_init (_SELF,
+                     NUM2DBL (xx), NUM2DBL (yx),
+                     NUM2DBL (xy), NUM2DBL (yy),
+                     NUM2DBL (x0), NUM2DBL (y0));
+  return self;
+}
+
+static VALUE
+cr_matrix_to_a (VALUE self)
+{
+  cairo_matrix_t *matrix = _SELF;
+  double affine[6];
+  affine[0] = matrix->xx;
+  affine[1] = matrix->yx;
+  affine[2] = matrix->xy;
+  affine[3] = matrix->yy;
+  affine[4] = matrix->x0;
+  affine[5] = matrix->y0;
+  return rb_cairo__float_array (affine, 6);
+}
+
+static VALUE
+cr_matrix_to_s(VALUE self)
+{
+  VALUE ret;
+
+  ret = rb_str_new2 ("#<");
+  rb_str_cat2 (ret, rb_class2name (CLASS_OF (self)));
+  rb_str_cat2 (ret, ":");
+  rb_str_concat (ret, rb_inspect (cr_matrix_to_a (self)));
+  rb_str_cat2 (ret, ">");
+  
+  return ret;
+}
+
+static VALUE
+cr_matrix_equal (VALUE self, VALUE other)
+{
+  if (!rb_cairo__is_kind_of (other, rb_cCairo_Matrix))
+    return Qfalse;
+
+  return rb_funcall (cr_matrix_to_a (self),
+                     cr_id_equal, 1,
+                     cr_matrix_to_a (other));
+}
+
+void
+Init_cairo_matrix (void)
+{
+  cr_id_equal = rb_intern ("==");
+
+  rb_cCairo_Matrix =
+    rb_define_class_under (rb_mCairo, "Matrix", rb_cObject);
+
+  rb_define_alloc_func (rb_cCairo_Matrix, cr_matrix_allocate);
+
+  rb_define_singleton_method (rb_cCairo_Matrix, "identity",
+                              cr_matrix_init_identity, 0);
+  rb_define_singleton_method (rb_cCairo_Matrix, "translate",
+                              cr_matrix_init_translate, 2);
+  rb_define_singleton_method (rb_cCairo_Matrix, "scale",
+                              cr_matrix_init_scale, 2);
+  rb_define_singleton_method (rb_cCairo_Matrix, "rotate",
+                              cr_matrix_init_rotate, 1);
+  
+  rb_define_method (rb_cCairo_Matrix, "initialize", cr_matrix_initialize, 6);
+  
+  rb_define_method (rb_cCairo_Matrix, "identity!", cr_matrix_identity, 0);
+  rb_define_method (rb_cCairo_Matrix, "translate!", cr_matrix_translate, 2);
+  rb_define_method (rb_cCairo_Matrix, "scale!", cr_matrix_scale, 2);
+  rb_define_method (rb_cCairo_Matrix, "rotate!", cr_matrix_rotate, 1);
+  rb_define_method (rb_cCairo_Matrix, "invert!", cr_matrix_invert, 0);
+  rb_define_method (rb_cCairo_Matrix, "multiply!", cr_matrix_multiply, 1);
+  rb_define_method (rb_cCairo_Matrix, "transform_distance",
+                    cr_matrix_transform_distance, 2);
+  rb_define_method (rb_cCairo_Matrix, "transform_point",
+                    cr_matrix_transform_point, 2);
+
+  /* Accessors */
+  rb_define_method (rb_cCairo_Matrix, "xx", cr_matrix_get_xx, 0);
+  rb_define_method (rb_cCairo_Matrix, "set_xx", cr_matrix_set_xx, 1);
+  rb_define_method (rb_cCairo_Matrix, "yx", cr_matrix_get_yx, 0);
+  rb_define_method (rb_cCairo_Matrix, "set_yx", cr_matrix_set_yx, 1);
+  rb_define_method (rb_cCairo_Matrix, "xy", cr_matrix_get_xy, 0);
+  rb_define_method (rb_cCairo_Matrix, "set_xy", cr_matrix_set_xy, 1);
+  rb_define_method (rb_cCairo_Matrix, "yy", cr_matrix_get_yy, 0);
+  rb_define_method (rb_cCairo_Matrix, "set_yy", cr_matrix_set_yy, 1);
+  rb_define_method (rb_cCairo_Matrix, "x0", cr_matrix_get_x0, 0);
+  rb_define_method (rb_cCairo_Matrix, "set_x0", cr_matrix_set_x0, 1);
+  rb_define_method (rb_cCairo_Matrix, "y0", cr_matrix_get_y0, 0);
+  rb_define_method (rb_cCairo_Matrix, "set_y0", cr_matrix_set_y0, 1);
+
+  /* Utilities */
+  rb_define_method (rb_cCairo_Matrix, "set", cr_matrix_set, 6);
+  rb_define_method (rb_cCairo_Matrix, "to_a", cr_matrix_to_a, 0);
+  rb_define_method (rb_cCairo_Matrix, "to_s", cr_matrix_to_s, 0);
+  rb_define_method (rb_cCairo_Matrix, "==", cr_matrix_equal, 1);
+
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_Matrix);
+}

data/ext/cairo/rb_cairo_path.c

@@ -0,0 +1,459 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-04-04 03:52:31 $
+ *
+ * Copyright 2005 Kouhei Sutou <kou@cozmixng.org>
+ *
+ * This file is made available under the same terms as Ruby
+ *
+ */
+
+#include "rb_cairo.h"
+#include "rb_cairo_private.h"
+
+#define _SELF(self) (RVAL2CRPATH (self))
+
+VALUE rb_cCairo_Point;
+VALUE rb_cCairo_Path;
+VALUE rb_cCairo_PathData;
+VALUE rb_cCairo_PathMoveTo;
+VALUE rb_cCairo_PathLineTo;
+VALUE rb_cCairo_PathCurveTo;
+VALUE rb_cCairo_PathClosePath;
+
+static ID id_new, id_current_path;
+static ID id_at_x, id_at_y, id_at_type, id_at_points, id_at_context;
+
+static VALUE
+cr_point_new (VALUE x, VALUE y)
+{
+  return rb_funcall (rb_cCairo_Point, id_new, 2, x, y);
+}
+
+static VALUE
+cr_point_initialize (VALUE self, VALUE x, VALUE y)
+{
+  rb_ivar_set (self, id_at_x, x);
+  rb_ivar_set (self, id_at_y, y);
+  return Qnil;
+}
+
+static VALUE
+cr_point_to_a (VALUE self)
+{
+  return rb_ary_new3 (2,
+                      rb_ivar_get (self, id_at_x),
+                      rb_ivar_get (self, id_at_y));
+}
+
+static VALUE
+cr_path_data_initialize (VALUE self, VALUE type, VALUE points)
+{
+  rb_ivar_set (self, id_at_type, type);
+  rb_ivar_set (self, id_at_points, points);
+  return Qnil;
+}
+
+static VALUE
+cr_path_data_move_to_p (VALUE self)
+{
+  return CBOOL2RVAL (RVAL2CRPATHDATATYPE (rb_ivar_get (self, id_at_type)) ==
+                     CAIRO_PATH_MOVE_TO);
+}
+
+static VALUE
+cr_path_data_line_to_p (VALUE self)
+{
+  return CBOOL2RVAL (RVAL2CRPATHDATATYPE (rb_ivar_get (self, id_at_type)) ==
+                     CAIRO_PATH_LINE_TO);
+}
+
+static VALUE
+cr_path_data_curve_to_p (VALUE self)
+{
+  return CBOOL2RVAL (RVAL2CRPATHDATATYPE (rb_ivar_get (self, id_at_type)) ==
+                     CAIRO_PATH_CURVE_TO);
+}
+
+static VALUE
+cr_path_data_close_path_p (VALUE self)
+{
+  return CBOOL2RVAL (RVAL2CRPATHDATATYPE (rb_ivar_get (self, id_at_type)) ==
+                     CAIRO_PATH_CLOSE_PATH);
+}
+
+static VALUE
+cr_path_data_each (VALUE self)
+{
+  return rb_ary_each (rb_ivar_get (self, id_at_points));
+}
+
+
+static VALUE
+cr_path_data_to_a (VALUE self)
+{
+  return rb_ary_new3 (2,
+                      rb_ivar_get (self, id_at_type),
+                      rb_ivar_get (self, id_at_points));
+}
+
+static VALUE
+cr_path_data_to_ruby_object (cairo_path_data_t *data)
+{
+  VALUE rb_data = Qnil;
+
+  switch (data->header.type)
+    {
+    case CAIRO_PATH_MOVE_TO:
+      rb_data = rb_funcall (rb_cCairo_PathMoveTo, id_new, 2,
+                            rb_float_new (data[1].point.x),
+                            rb_float_new (data[1].point.y));
+      break;
+    case CAIRO_PATH_LINE_TO:
+      rb_data = rb_funcall (rb_cCairo_PathLineTo, id_new, 2,
+                            rb_float_new (data[1].point.x),
+                            rb_float_new (data[1].point.y));
+      break;
+    case CAIRO_PATH_CURVE_TO:
+      rb_data = rb_funcall (rb_cCairo_PathCurveTo, id_new, 6,
+                            rb_float_new (data[1].point.x),
+                            rb_float_new (data[1].point.y),
+                            rb_float_new (data[2].point.x),
+                            rb_float_new (data[2].point.y),
+                            rb_float_new (data[3].point.x),
+                            rb_float_new (data[3].point.y));
+      break;
+    case CAIRO_PATH_CLOSE_PATH:
+      rb_data = rb_funcall (rb_cCairo_PathClosePath, id_new, 0);
+      break;
+    }
+
+  return rb_data;
+}
+
+
+static VALUE
+cr_path_move_to_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE point, x, y;
+  VALUE super_argv[2];
+
+  rb_scan_args (argc, argv, "11", &x, &y);
+
+  if (argc == 1)
+    point = x;
+  else
+    point = cr_point_new (x, y);
+
+  super_argv[0] = INT2NUM (CAIRO_PATH_MOVE_TO);
+  super_argv[1] = rb_ary_new3 (1, point);
+  rb_call_super (2, super_argv);
+  return Qnil;
+}
+
+static VALUE
+cr_path_line_to_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE point, x, y;
+  VALUE super_argv[2];
+
+  rb_scan_args (argc, argv, "11", &x, &y);
+
+  if (argc == 1)
+    point = x;
+  else
+    point = cr_point_new (x, y);
+
+  super_argv[0] = INT2NUM (CAIRO_PATH_LINE_TO);
+  super_argv[1] = rb_ary_new3 (1, point);
+  rb_call_super (2, super_argv);
+  return Qnil;
+}
+
+static VALUE
+cr_path_curve_to_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE point1, point2, point3, x1, y1, x2, y2, x3, y3;
+  VALUE super_argv[2];
+
+  rb_scan_args (argc, argv, "33", &x1, &y1, &x2, &y2, &x3, &y3);
+
+  if (argc == 3)
+    {
+      point1 = x1;
+      point2 = y1;
+      point3 = x2;
+    }
+  else if (argc == 6)
+    {
+      point1 = cr_point_new (x1, y1);
+      point2 = cr_point_new (x2, y2);
+      point3 = cr_point_new (x3, y3);
+    }
+  else
+    {
+      VALUE inspected_arg = rb_inspect (rb_ary_new4 (argc, argv));
+      rb_raise (rb_eArgError,
+                "invalid argument: %s (expect "
+                "(point1, point2, point3) or "
+                "(x1, y1, x2, y2, x3, y3))",
+                StringValuePtr (inspected_arg));
+    }
+
+  super_argv[0] = INT2NUM (CAIRO_PATH_CURVE_TO);
+  super_argv[1] = rb_ary_new3 (3, point1, point2, point3);
+  rb_call_super (2, super_argv);
+  return Qnil;
+}
+
+static VALUE
+cr_path_close_path_initialize (VALUE self)
+{
+  VALUE super_argv[2];
+  super_argv[0] = INT2NUM (CAIRO_PATH_CLOSE_PATH);
+  super_argv[1] = rb_ary_new ();
+  rb_call_super (2, super_argv);
+  return Qnil;
+}
+
+
+static void
+cr_path_free (void *ptr)
+{
+  if (ptr)
+    {
+      cairo_path_destroy ((cairo_path_t *)ptr);
+    }
+}
+
+cairo_path_t *
+rb_cairo_path_from_ruby_object (VALUE obj)
+{
+  VALUE context;
+  cairo_t *cr;
+  cairo_path_t *path, *copied_path;
+
+  if (!rb_cairo__is_kind_of (obj, rb_cCairo_Path))
+    {
+      rb_raise (rb_eTypeError, "not a cairo path");
+    }
+  Data_Get_Struct (obj, cairo_path_t, path);
+
+  context = rb_ivar_get (obj, id_at_context);
+  if (NIL_P (context))
+    return path;
+
+  cr = RVAL2CRCONTEXT (context);
+  if (cairo_status (cr) != CAIRO_STATUS_SUCCESS)
+    return path;
+
+  copied_path = cairo_copy_path (cr);
+  rb_ivar_set (obj, id_current_path, CRPATH2RVAL (copied_path));
+  return copied_path;
+}
+
+static void
+cr_path_ensure_internal_context (VALUE rb_path, cairo_path_t *path)
+{
+  cairo_surface_t *surface;
+  cairo_t *cr;
+
+  if (!NIL_P (rb_ivar_get (rb_path, id_at_context)))
+    return;
+
+  surface = cairo_image_surface_create (CAIRO_FORMAT_A1, 1, 1);
+  cr = cairo_create (surface);
+  if (path->num_data > 0)
+    cairo_append_path (cr, path);
+  rb_cairo_check_status (cairo_status (cr));
+  rb_ivar_set (rb_path, id_at_context, CRCONTEXT2RVAL (cr));
+  cairo_destroy (cr);
+}
+
+VALUE
+rb_cairo_path_to_ruby_object (cairo_path_t *path)
+{
+  if (path)
+    {
+      VALUE rb_path;
+      rb_path = Data_Wrap_Struct (rb_cCairo_Path, NULL, cr_path_free, path);
+      cr_path_ensure_internal_context (rb_path, path);
+      return rb_path;
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+static VALUE
+cr_path_allocate (VALUE klass)
+{
+  return Data_Wrap_Struct (klass, NULL, cr_path_free, NULL);
+}
+
+static VALUE
+cr_path_initialize (VALUE self)
+{
+  cairo_path_t *path;
+
+  path = ALLOC(cairo_path_t);
+  path->status = CAIRO_STATUS_SUCCESS;
+  path->data = NULL;
+  path->num_data = 0;
+
+  DATA_PTR (self) = path;
+  cr_path_ensure_internal_context (self, path);
+
+  return Qnil;
+}
+
+static VALUE
+cr_path_empty_p (VALUE self)
+{
+  cairo_path_t *path = _SELF (self);
+
+  return CBOOL2RVAL (path->num_data == 0);
+}
+
+static int
+cairo_path_get_size (cairo_path_t *path)
+{
+  int i, size;
+
+  for (i = 0, size = 0; i < path->num_data; i += path->data[i].header.length)
+    size++;
+
+  return size;
+}
+
+static VALUE
+cr_path_size (VALUE self)
+{
+  cairo_path_t *path = _SELF (self);
+  return INT2NUM (cairo_path_get_size (path));
+}
+
+static VALUE
+cr_path_ref (VALUE self, VALUE index)
+{
+  cairo_path_t *path = _SELF (self);
+  int i, requested_index, real_index;
+
+  requested_index = NUM2INT (index);
+  if (requested_index < 0)
+    {
+      requested_index += cairo_path_get_size (path);
+      if (requested_index < 0)
+        return Qnil;
+    }
+
+
+  for (i = 0, real_index = 0; i < requested_index; i++)
+    {
+      if (real_index >= path->num_data)
+        return Qnil;
+      real_index += path->data[real_index].header.length;
+    }
+
+  if (real_index < path->num_data)
+    return cr_path_data_to_ruby_object (&path->data[real_index]);
+  else
+    return Qnil;
+}
+
+static VALUE
+cr_path_each (VALUE self)
+{
+  cairo_path_t *path = _SELF(self);
+  int i;
+
+  for (i = 0; i < path->num_data; i += path->data[i].header.length)
+    {
+      rb_yield (cr_path_data_to_ruby_object (&(path->data[i])));
+    }
+
+  return self;
+}
+
+void
+Init_cairo_path (void)
+{
+  id_new = rb_intern ("new");
+  id_current_path = rb_intern ("current_path");
+
+  id_at_x = rb_intern ("@x");
+  id_at_y = rb_intern ("@y");
+  id_at_type = rb_intern ("@type");
+  id_at_points = rb_intern ("@points");
+  id_at_context = rb_intern ("@context");
+
+  rb_cCairo_Point = rb_define_class_under (rb_mCairo, "Point", rb_cObject);
+  rb_define_attr (rb_cCairo_Point, "x", CR_TRUE, CR_FALSE);
+  rb_define_attr (rb_cCairo_Point, "y", CR_TRUE, CR_FALSE);
+  rb_define_method (rb_cCairo_Point, "initialize", cr_point_initialize, 2);
+
+  rb_define_method (rb_cCairo_Point, "to_a", cr_point_to_a, 0);
+  rb_define_alias (rb_cCairo_Point, "to_ary", "to_a");
+
+
+  rb_cCairo_PathData = rb_define_class_under (rb_mCairo, "PathData", rb_cObject);
+
+  rb_include_module (rb_cCairo_PathData, rb_mEnumerable);
+
+  rb_define_attr (rb_cCairo_PathData, "type", CR_TRUE, CR_FALSE);
+  rb_define_attr (rb_cCairo_PathData, "points", CR_TRUE, CR_FALSE);
+  rb_define_method (rb_cCairo_PathData, "initialize",
+                    cr_path_data_initialize, 2);
+
+  rb_define_method (rb_cCairo_PathData, "move_to?", cr_path_data_move_to_p, 0);
+  rb_define_method (rb_cCairo_PathData, "line_to?", cr_path_data_line_to_p, 0);
+  rb_define_method (rb_cCairo_PathData, "curve_to?",
+                    cr_path_data_curve_to_p, 0);
+  rb_define_method (rb_cCairo_PathData, "close_path?",
+                    cr_path_data_close_path_p, 0);
+
+  rb_define_method (rb_cCairo_PathData, "each", cr_path_data_each, 0);
+
+  rb_define_method (rb_cCairo_PathData, "to_a", cr_path_data_to_a, 0);
+  rb_define_alias (rb_cCairo_PathData, "to_ary", "to_a");
+
+
+  rb_cCairo_PathMoveTo =
+    rb_define_class_under (rb_mCairo, "PathMoveTo", rb_cCairo_PathData);
+  rb_define_method (rb_cCairo_PathMoveTo, "initialize",
+                    cr_path_move_to_initialize, -1);
+
+  rb_cCairo_PathLineTo =
+    rb_define_class_under (rb_mCairo, "PathLineTo", rb_cCairo_PathData);
+  rb_define_method (rb_cCairo_PathLineTo, "initialize",
+                    cr_path_line_to_initialize, -1);
+
+  rb_cCairo_PathCurveTo =
+    rb_define_class_under (rb_mCairo, "PathCurveTo", rb_cCairo_PathData);
+  rb_define_method (rb_cCairo_PathCurveTo, "initialize",
+                    cr_path_curve_to_initialize, -1);
+
+  rb_cCairo_PathClosePath =
+    rb_define_class_under (rb_mCairo, "PathClosePath", rb_cCairo_PathData);
+  rb_define_method (rb_cCairo_PathClosePath, "initialize",
+                    cr_path_close_path_initialize, 0);
+
+
+  rb_cCairo_Path = rb_define_class_under (rb_mCairo, "Path", rb_cObject);
+  rb_define_alloc_func (rb_cCairo_Path, cr_path_allocate);
+
+  rb_include_module (rb_cCairo_Path, rb_mEnumerable);
+
+  rb_define_method (rb_cCairo_Path, "initialize", cr_path_initialize, 0);
+
+  rb_define_method (rb_cCairo_Path, "empty?", cr_path_empty_p, 0);
+  rb_define_method (rb_cCairo_Path, "size", cr_path_size, 0);
+  rb_define_alias (rb_cCairo_Path, "length", "size");
+  rb_define_method (rb_cCairo_Path, "[]", cr_path_ref, 1);
+
+  rb_define_method (rb_cCairo_Path, "each", cr_path_each, 0);
+}