cairo 1.4.1

data/src/rb_cairo_glyph.c

@@ -0,0 +1,158 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2007/03/06 12:17:34 $
+ *
+ * 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"
+
+VALUE rb_cCairo_Glyph;
+
+#define _SELF(self)  (RVAL2CRGLYPH(self))
+
+cairo_glyph_t *
+rb_cairo_glyph_from_ruby_object (VALUE obj)
+{
+  cairo_glyph_t *glyph;
+  if (!RTEST (rb_obj_is_kind_of (obj, rb_cCairo_Glyph)))
+    {
+      rb_raise (rb_eTypeError, "not a cairo glyph");
+    }
+  Data_Get_Struct (obj, cairo_glyph_t, glyph);
+  return glyph;
+}
+
+static void
+cr_glyph_free (void *ptr)
+{
+  if (ptr)
+    {
+      free (ptr);
+    }
+}
+
+VALUE
+rb_cairo_glyph_to_ruby_object (cairo_glyph_t *glyph)
+{
+  if (glyph)
+    {
+      cairo_glyph_t *new_glyph = ALLOC (cairo_glyph_t);
+      *new_glyph = *glyph;
+      return Data_Wrap_Struct (rb_cCairo_Glyph, NULL, cr_glyph_free, new_glyph);
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+static VALUE
+cr_glyph_allocate (VALUE klass)
+{
+  return Data_Wrap_Struct (klass, NULL, cr_glyph_free, NULL);
+}
+
+static VALUE
+cr_glyph_initialize (VALUE self, VALUE index, VALUE x, VALUE y)
+{
+  cairo_glyph_t *glyph;
+
+  glyph = ALLOC (cairo_glyph_t);
+  glyph->index = NUM2ULONG (index);
+  glyph->x = NUM2DBL (x);
+  glyph->y = NUM2DBL (y);
+
+  DATA_PTR (self) = glyph;
+  return Qnil;
+}
+
+static VALUE
+cr_glyph_index (VALUE self)
+{
+  return ULONG2NUM (_SELF(self)->index);
+}
+
+static VALUE
+cr_glyph_x (VALUE self)
+{
+  return rb_float_new (_SELF(self)->x);
+}
+
+static VALUE
+cr_glyph_y (VALUE self)
+{
+  return rb_float_new (_SELF(self)->y);
+}
+
+static VALUE
+cr_glyph_set_index (VALUE self, VALUE index)
+{
+  _SELF(self)->index = NUM2ULONG (index);
+  return self;
+}
+
+static VALUE
+cr_glyph_set_x (VALUE self, VALUE x)
+{
+  _SELF(self)->x = NUM2DBL (x);
+  return self;
+}
+
+static VALUE
+cr_glyph_set_y (VALUE self, VALUE y)
+{
+  _SELF(self)->y = NUM2DBL (y);
+  return self;
+}
+
+static VALUE
+cr_glyph_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_cat2 (ret, "index=");
+  rb_str_concat (ret, rb_inspect (cr_glyph_index (self)));
+  rb_str_cat2 (ret, ", ");
+  rb_str_cat2 (ret, "x=");
+  rb_str_concat (ret, rb_inspect (cr_glyph_x (self)));
+  rb_str_cat2 (ret, ", ");
+  rb_str_cat2 (ret, "y=");
+  rb_str_concat (ret, rb_inspect (cr_glyph_y (self)));
+  rb_str_cat2 (ret, ">");
+                 
+  return ret;
+}
+
+
+void
+Init_cairo_glyph (void)
+{
+  rb_cCairo_Glyph = rb_define_class_under (rb_mCairo, "Glyph", rb_cObject);
+
+  rb_define_alloc_func (rb_cCairo_Glyph, cr_glyph_allocate);
+
+  rb_define_method (rb_cCairo_Glyph, "initialize", cr_glyph_initialize, 3);
+  
+  rb_define_method (rb_cCairo_Glyph, "index", cr_glyph_index, 0);
+  rb_define_method (rb_cCairo_Glyph, "x", cr_glyph_x, 0);
+  rb_define_method (rb_cCairo_Glyph, "y", cr_glyph_y, 0);
+  rb_define_method (rb_cCairo_Glyph, "set_index", cr_glyph_set_index, 1);
+  rb_define_method (rb_cCairo_Glyph, "set_x", cr_glyph_set_x, 1);
+  rb_define_method (rb_cCairo_Glyph, "set_y", cr_glyph_set_y, 1);
+
+  rb_define_method (rb_cCairo_Glyph, "to_s", cr_glyph_to_s, 0);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_Glyph);
+}

data/src/rb_cairo_matrix.c

@@ -0,0 +1,257 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2007/03/06 12:17:34 $
+ *
+ * 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;
+
+#define _SELF  (RVAL2CRMATRIX(self))
+
+cairo_matrix_t *
+rb_cairo_matrix_from_ruby_object (VALUE obj)
+{
+  cairo_matrix_t *matrix;
+  if (!RTEST (rb_obj_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)
+    {
+      free ((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);
+}
+
+
+/* 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;
+}
+
+
+void
+Init_cairo_matrix (void)
+{
+  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, "matrix_distance",
+                    cr_matrix_transform_distance, 2);
+  rb_define_method (rb_cCairo_Matrix, "transform_point",
+                    cr_matrix_transform_point, 2);
+
+  /* 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_CAIRO_DEF_SETTERS (rb_cCairo_Matrix);
+}

data/src/rb_cairo_path.c

@@ -0,0 +1,88 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2007/03/06 12:17:34 $
+ *
+ * Copyright 2005 Kouhei Sutou <kou@cozmixng.org>
+ *
+ * This file is made available under the same terms as Ruby
+ *
+ */
+
+#include "rb_cairo.h"
+
+#define _SELF(self) (RVAL2CRPATH (self))
+
+VALUE rb_cCairo_Path;
+
+cairo_path_t *
+rb_cairo_path_from_ruby_object (VALUE obj)
+{
+  cairo_path_t *path;
+  if (!RTEST (rb_obj_is_kind_of (obj, rb_cCairo_Path)))
+    {
+      rb_raise (rb_eTypeError, "not a cairo path");
+    }
+  Data_Get_Struct (obj, cairo_path_t, path);
+  return path;
+}
+
+static void
+cr_path_free (void *ptr)
+{
+  if (ptr)
+    {
+      cairo_path_destroy ((cairo_path_t *)ptr);
+    }
+}
+
+VALUE
+rb_cairo_path_to_ruby_object (cairo_path_t *path)
+{
+  if (path)
+    {
+      return Data_Wrap_Struct (rb_cCairo_Path, NULL, cr_path_free, path);
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+static VALUE
+cr_path_each (VALUE self)
+{
+  cairo_path_t *path = _SELF(self);
+  int i, j;
+  
+  for (i = 0; i < path->num_data; i += path->data[i].header.length)
+    {
+      cairo_path_data_t *data = &(path->data[i]);
+      VALUE points;
+
+      points = rb_ary_new ();
+
+      for (j = 1; j < data->header.length; j++)
+        {
+          rb_ary_push (points, rb_ary_new3 (2,
+                                            rb_float_new (data[j].point.x),
+                                            rb_float_new (data[j].point.y)));
+        }
+      rb_yield_values (2, INT2FIX (data->header.type), points);
+    }
+
+  return self;
+}
+
+
+void
+Init_cairo_path (void)
+{
+  rb_cCairo_Path = rb_define_class_under (rb_mCairo, "Path", rb_cObject);
+
+  rb_include_module (rb_cCairo_Path, rb_mEnumerable);
+
+  rb_define_method (rb_cCairo_Path, "each", cr_path_each, 0);
+}