cairo 1.8.3-x86-mingw32

data/ext/cairo/rb_cairo_font_options.c

@@ -0,0 +1,197 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-09-19 12:56:27 $
+ *
+ * Copyright 2005-2008 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) (RVAL2CRFONTOPTIONS(self))
+
+VALUE rb_cCairo_FontOptions;
+
+static inline void
+cr_options_check_status (cairo_font_options_t *options)
+{
+  rb_cairo_check_status (cairo_font_options_status (options));
+}
+
+cairo_font_options_t *
+rb_cairo_font_options_from_ruby_object (VALUE obj)
+{
+  cairo_font_options_t *options;
+  if (!rb_cairo__is_kind_of (obj, rb_cCairo_FontOptions))
+    {
+      rb_raise (rb_eTypeError, "not a cairo font options");
+    }
+  Data_Get_Struct (obj, cairo_font_options_t, options);
+  return options;
+}
+
+static void
+cr_options_free (void *ptr)
+{
+  if (ptr)
+    {
+      cairo_font_options_destroy ((cairo_font_options_t *) ptr);
+    }
+}
+
+VALUE
+rb_cairo_font_options_to_ruby_object (cairo_font_options_t *options)
+{
+  if (options)
+    {
+      return Data_Wrap_Struct (rb_cCairo_FontOptions, NULL,
+                               cr_options_free, options);
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+static VALUE
+cr_options_allocate (VALUE klass)
+{
+  return Data_Wrap_Struct (klass, NULL, cr_options_free, NULL);
+}
+
+static VALUE
+cr_options_create (VALUE self)
+{
+  cairo_font_options_t *options;
+
+  options = cairo_font_options_create ();
+  cr_options_check_status (options);
+  DATA_PTR (self) = options;
+  return Qnil;
+}
+
+static VALUE
+cr_options_copy (VALUE self)
+{
+  cairo_font_options_t *options;
+
+  options = cairo_font_options_copy (_SELF (self));
+  cr_options_check_status (options);
+  return CRFONTOPTIONS2RVAL (options);
+}
+
+static VALUE
+cr_options_merge (VALUE self, VALUE other)
+{
+  cairo_font_options_merge (_SELF (self), _SELF (other));
+  return self;
+}
+
+static VALUE
+cr_options_equal (VALUE self, VALUE other)
+{
+  return CBOOL2RVAL (cairo_font_options_equal (_SELF (self), _SELF (other)));
+}
+
+static VALUE
+cr_options_hash (VALUE self)
+{
+  return INT2NUM (cairo_font_options_hash (_SELF (self)));
+}
+
+static VALUE
+cr_options_set_antialias (VALUE self, VALUE antialias)
+{
+  cairo_font_options_set_antialias (_SELF (self), RVAL2CRANTIALIAS (antialias));
+  return self;
+}
+
+static VALUE
+cr_options_get_antialias (VALUE self)
+{
+  return INT2NUM (cairo_font_options_get_antialias (_SELF (self)));
+}
+
+static VALUE
+cr_options_set_subpixel_order (VALUE self, VALUE subpixel_order)
+{
+  cairo_font_options_set_subpixel_order (_SELF (self),
+                                         RVAL2CRSUBPIXELORDER (subpixel_order));
+  return self;
+}
+
+static VALUE
+cr_options_get_subpixel_order (VALUE self)
+{
+  return INT2NUM (cairo_font_options_get_subpixel_order (_SELF (self)));
+}
+
+static VALUE
+cr_options_set_hint_style (VALUE self, VALUE hint_style)
+{
+  cairo_font_options_set_hint_style (_SELF (self),
+                                     RVAL2CRHINTSTYLE (hint_style));
+  return self;
+}
+
+static VALUE
+cr_options_get_hint_style (VALUE self)
+{
+  return INT2NUM (cairo_font_options_get_hint_style (_SELF (self)));
+}
+
+static VALUE
+cr_options_set_hint_metrics (VALUE self, VALUE hint_metrics)
+{
+  cairo_font_options_set_hint_metrics (_SELF (self),
+                                       RVAL2CRHINTMETRICS (hint_metrics));
+  return self;
+}
+
+static VALUE
+cr_options_get_hint_metrics (VALUE self)
+{
+  return INT2NUM (cairo_font_options_get_hint_metrics (_SELF (self)));
+}
+
+
+void
+Init_cairo_font_options (void)
+{
+  rb_cCairo_FontOptions =
+    rb_define_class_under (rb_mCairo, "FontOptions", rb_cObject);
+
+  rb_define_alloc_func (rb_cCairo_FontOptions, cr_options_allocate);
+  
+  rb_define_method (rb_cCairo_FontOptions, "initialize", cr_options_create, 0);
+
+  rb_define_method (rb_cCairo_FontOptions, "dup", cr_options_copy, 0);
+  rb_define_method (rb_cCairo_FontOptions, "merge!", cr_options_merge, 1);
+  rb_define_alias (rb_cCairo_FontOptions, "update", "merge!");
+  rb_define_method (rb_cCairo_FontOptions, "eql?", cr_options_equal, 1);
+  rb_define_method (rb_cCairo_FontOptions, "hash", cr_options_hash, 0);
+  rb_define_method (rb_cCairo_FontOptions, "set_antialias",
+                    cr_options_set_antialias, 1);
+  rb_define_method (rb_cCairo_FontOptions, "antialias",
+                    cr_options_get_antialias, 0);
+  rb_define_method (rb_cCairo_FontOptions, "set_subpixel_order",
+                    cr_options_set_subpixel_order, 1);
+  rb_define_method (rb_cCairo_FontOptions, "subpixel_order",
+                    cr_options_get_subpixel_order, 0);
+  rb_define_method (rb_cCairo_FontOptions, "set_hint_style",
+                    cr_options_set_hint_style, 1);
+  rb_define_method (rb_cCairo_FontOptions, "hint_style",
+                    cr_options_get_hint_style, 0);
+  rb_define_method (rb_cCairo_FontOptions, "set_hint_metrics",
+                    cr_options_set_hint_metrics, 1);
+  rb_define_method (rb_cCairo_FontOptions, "hint_metrics",
+                    cr_options_get_hint_metrics, 0);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_FontOptions);
+}

data/ext/cairo/rb_cairo_glyph.c

@@ -0,0 +1,161 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-08-16 08:16:39 $
+ *
+ * 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_Glyph;
+
+#define _SELF(self)  (RVAL2CRGLYPH(self))
+
+cairo_glyph_t *
+rb_cairo_glyph_from_ruby_object (VALUE obj)
+{
+  cairo_glyph_t *glyph;
+  if (!rb_cairo__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)
+    {
+      xfree (ptr);
+    }
+}
+
+VALUE
+rb_cairo_glyph_to_ruby_object (cairo_glyph_t *glyph)
+{
+  if (glyph)
+    {
+      cairo_glyph_t *new_glyph;
+
+      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/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)
+    {
+      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);
+}
+
+
+/* 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);
+}