cairo 1.14.0-x64-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_io.c

@@ -0,0 +1,166 @@
+/* -*- 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
+ *
+ */
+
+#include "rb_cairo.h"
+#include "rb_cairo_private.h"
+#include "rb_cairo_io.h"
+
+ID rb_cairo__io_id_read;
+ID rb_cairo__io_id_write;
+ID rb_cairo__io_id_output;
+
+/* read/write callback */
+rb_cairo__io_callback_closure_t *
+rb_cairo__io_closure_new (VALUE target)
+{
+  rb_cairo__io_callback_closure_t *closure;
+  closure = ALLOC (rb_cairo__io_callback_closure_t);
+
+  closure->target = target;
+  closure->error = Qnil;
+
+  return closure;
+}
+
+void
+rb_cairo__io_closure_destroy (rb_cairo__io_callback_closure_t *closure)
+{
+  xfree (closure);
+}
+
+void
+rb_cairo__io_closure_free (void *closure)
+{
+  rb_cairo__io_closure_destroy ((rb_cairo__io_callback_closure_t *) closure);
+}
+
+static VALUE
+rb_cairo__io_func_rescue (VALUE io_closure)
+{
+  rb_cairo__io_callback_closure_t *closure;
+  closure = (rb_cairo__io_callback_closure_t *)io_closure;
+  closure->error = RB_ERRINFO;
+  return Qnil;
+}
+
+static VALUE
+rb_cairo__io_func_invoke (VALUE user_data)
+{
+  rb_cairo__io_invoke_data_t *data;
+
+  data = (rb_cairo__io_invoke_data_t *)user_data;
+  return rb_rescue2 (data->func, data->data,
+                     rb_cairo__io_func_rescue, data->data, rb_eException,
+                     (VALUE)0);
+}
+
+/* write callback */
+static VALUE
+rb_cairo__io_write_func_invoke (VALUE write_closure)
+{
+  VALUE output, data;
+  long written_bytes;
+  rb_cairo__io_callback_closure_t *closure;
+  unsigned int length;
+
+  closure = (rb_cairo__io_callback_closure_t *)write_closure;
+
+  output = closure->target;
+  data = rb_str_new ((const char *)closure->data, closure->length);
+
+  length = RSTRING_LEN (data);
+  while (length != 0)
+    {
+      VALUE rb_written_bytes = rb_funcall (output,
+                                           rb_cairo__io_id_write, 1, data);
+      written_bytes = NUM2LONG (rb_written_bytes);
+      data = rb_str_substr (data, written_bytes,
+                            RSTRING_LEN (data) - written_bytes);
+      length -= written_bytes;
+    }
+
+  return Qnil;
+}
+
+cairo_status_t
+rb_cairo__io_write_func (void *write_closure,
+                         const unsigned char *data, unsigned int length)
+{
+  rb_cairo__io_callback_closure_t *closure;
+  rb_cairo__io_invoke_data_t invoke_data;
+
+  closure = (rb_cairo__io_callback_closure_t *)write_closure;
+  closure->data = (unsigned char *)data;
+  closure->length = length;
+
+  invoke_data.func = rb_cairo__io_write_func_invoke;
+  invoke_data.data = (VALUE)closure;
+  rb_cairo__invoke_callback (rb_cairo__io_func_invoke, (VALUE)&invoke_data);
+
+  if (NIL_P (closure->error))
+    return CAIRO_STATUS_SUCCESS;
+  else
+    return CAIRO_STATUS_WRITE_ERROR;
+}
+
+/* read callback */
+static VALUE
+rb_cairo__io_read_func_invoke (VALUE read_closure)
+{
+  VALUE input, result;
+  rb_cairo__io_callback_closure_t *closure;
+  unsigned int length, rest;
+
+  closure = (rb_cairo__io_callback_closure_t *)read_closure;
+  input = closure->target;
+  length = closure->length;
+
+  result = rb_str_new2 ("");
+
+  for (rest = length; rest != 0; rest = length - RSTRING_LEN (result))
+    {
+      rb_str_concat (result,
+                     rb_funcall (input,
+                                 rb_cairo__io_id_read, 1, INT2NUM (rest)));
+    }
+
+  memcpy ((void *)closure->data, (const void *)StringValuePtr (result), length);
+
+  return Qnil;
+}
+
+cairo_status_t
+rb_cairo__io_read_func (void *read_closure,
+                        unsigned char *data, unsigned int length)
+{
+  rb_cairo__io_callback_closure_t *closure;
+  rb_cairo__io_invoke_data_t invoke_data;
+
+  closure = (rb_cairo__io_callback_closure_t *)read_closure;
+  closure->data = data;
+  closure->length = length;
+
+  invoke_data.func = rb_cairo__io_read_func_invoke;
+  invoke_data.data = (VALUE)closure;
+  rb_cairo__invoke_callback (rb_cairo__io_func_invoke, (VALUE)&invoke_data);
+
+  if (NIL_P (closure->error))
+    return CAIRO_STATUS_SUCCESS;
+  else
+    return CAIRO_STATUS_READ_ERROR;
+}
+
+void
+Init_cairo_io (void)
+{
+  rb_cairo__io_id_read = rb_intern ("read");
+  rb_cairo__io_id_write = rb_intern ("write");
+  rb_cairo__io_id_output = rb_intern ("output");
+}