cairo 1.8.3-x86-mingw32

data/ext/cairo/rb_cairo_private.c

@@ -0,0 +1,242 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-08-17 07:21:42 $
+ *
+ * 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"
+
+static ID cr_id_normalize_const_name;
+static ID cr_id_objects;
+static ID cr_id_dup;
+static ID cr_id_inspect;
+static ID cr_id_exit_application;
+
+VALUE
+rb_cairo__float_array (double *values, unsigned count)
+{
+  VALUE result;
+  unsigned i;
+
+  result = rb_ary_new2 (count);
+  for (i = 0; i < count; i++)
+    {
+      rb_ary_push (result, rb_float_new (values[i]));
+    }
+  return result;
+}
+
+void
+rb_cairo__glyphs_to_array (VALUE rb_array, cairo_glyph_t *glyphs, int length)
+{
+  int i;
+
+  for (i = 0; i < length; i++)
+    {
+      memcpy ((char *) &glyphs[i],
+              (char *) RVAL2CRGLYPH (rb_ary_entry (rb_array, i)),
+              sizeof (cairo_glyph_t));
+    }
+}
+
+VALUE
+rb_cairo__const_get (VALUE name, const char *prefix)
+{
+  VALUE rb_normalized_name;
+  char *const_name, *normalized_name;
+  size_t prefix_len, normalized_name_len;
+
+  rb_normalized_name = rb_funcall (rb_mCairo,
+                                   cr_id_normalize_const_name, 1, name);
+  normalized_name = RVAL2CSTR (rb_normalized_name);
+
+  prefix_len = strlen (prefix);
+  normalized_name_len = strlen (normalized_name);
+
+  const_name = ALLOCA_N (char, prefix_len + normalized_name_len + 1);
+  strncpy (const_name, prefix, prefix_len);
+  strncpy (const_name + prefix_len, normalized_name, normalized_name_len);
+  const_name[prefix_len + normalized_name_len] = '\0';
+
+  return rb_const_get (rb_mCairo, rb_intern (const_name));
+}
+
+cairo_bool_t
+rb_cairo__is_kind_of (VALUE object, VALUE klass)
+{
+  return RVAL2CBOOL (rb_obj_is_kind_of (object, klass));
+}
+
+rb_cairo__object_holder_t *
+rb_cairo__object_holder_new (VALUE klass, VALUE object)
+{
+  rb_cairo__object_holder_t *holder;
+
+  holder = ALLOC(rb_cairo__object_holder_t);
+  rb_cairo__gc_guard_add (klass, object);
+  holder->object = object;
+  return holder;
+}
+
+void
+rb_cairo__object_holder_free (VALUE klass, void *ptr)
+{
+  rb_cairo__object_holder_t *holder = ptr;
+
+  if (!NIL_P (holder->object))
+    rb_cairo__gc_guard_remove (klass, holder->object);
+
+  xfree (holder);
+}
+
+void
+rb_cairo__initialize_gc_guard_holder_class (VALUE klass)
+{
+  rb_ivar_set (klass, cr_id_objects, rb_hash_new ());
+}
+
+void
+rb_cairo__gc_guard_add (VALUE klass, VALUE object)
+{
+  rb_hash_aset (rb_ivar_get (klass, cr_id_objects), object, Qnil);
+}
+
+void
+rb_cairo__gc_guard_remove (VALUE klass, VALUE object)
+{
+  rb_hash_delete (rb_ivar_get (klass, cr_id_objects), object);
+}
+
+VALUE
+rb_cairo__gc_guarded_objects (VALUE klass)
+{
+  return rb_funcall (rb_ivar_get (klass, cr_id_objects), cr_id_dup, 0);
+}
+
+const char *
+rb_cairo__inspect (VALUE object)
+{
+  VALUE inspected;
+
+  inspected = rb_funcall (object, cr_id_inspect, 0);
+  return RSTRING_PTR (inspected);
+}
+
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+VALUE
+rb_cairo__glyphs_to_ruby_object (cairo_glyph_t *glyphs, int num_glyphs)
+{
+  int i;
+  VALUE rb_glyphs;
+
+  rb_glyphs = rb_ary_new2 (num_glyphs);
+  for (i = 0; i < num_glyphs; i++)
+    {
+      RARRAY_PTR (rb_glyphs)[i] = CRGLYPH2RVAL (glyphs + i);
+    }
+
+  return rb_glyphs;
+}
+
+void
+rb_cairo__glyphs_from_ruby_object (VALUE rb_glyphs,
+                                   cairo_glyph_t **glyphs, int *num_glyphs)
+{
+  int i, len;
+
+  if (NIL_P (rb_glyphs))
+    {
+      *num_glyphs = -1;
+      return;
+    }
+
+  len = RARRAY_LEN (rb_glyphs);
+  if (*num_glyphs < len)
+    *glyphs = cairo_glyph_allocate (len);
+  *num_glyphs = len;
+  for (i = 0; i < len; i++)
+    {
+      cairo_glyph_t *glyph;
+
+      glyph = *glyphs + i;
+      *glyph = *(RVAL2CRGLYPH (RARRAY_PTR (rb_glyphs)[i]));
+    }
+}
+
+VALUE
+rb_cairo__text_clusters_to_ruby_object (cairo_text_cluster_t *clusters,
+                                        int num_clusters)
+{
+  int i;
+  VALUE rb_clusters;
+
+  rb_clusters = rb_ary_new2 (num_clusters);
+  for (i = 0; i < num_clusters; i++)
+    {
+      RARRAY_PTR (rb_clusters)[i] = CRTEXTCLUSTER2RVAL (clusters + i);
+    }
+
+  return rb_clusters;
+}
+
+void
+rb_cairo__text_clusters_from_ruby_object (VALUE rb_clusters,
+                                          cairo_text_cluster_t **clusters,
+                                          int *num_clusters)
+{
+  int i, len;
+
+  if (NIL_P (rb_clusters))
+    {
+      *num_clusters = -1;
+      return;
+    }
+
+  len = RARRAY_LEN (rb_clusters);
+  if (*num_clusters < len)
+    *clusters = cairo_text_cluster_allocate (len);
+  *num_clusters = len;
+  for (i = 0; i < len; i++)
+    {
+      cairo_text_cluster_t *cluster;
+
+      cluster = *clusters + i;
+      *cluster = *(RVAL2CRTEXTCLUSTER (RARRAY_PTR (rb_clusters)[i]));
+    }
+}
+#endif
+
+VALUE
+rb_cairo__invoke_callback (cr_callback_func_t func, VALUE data)
+{
+  int state = 0;
+  VALUE result, exception;
+
+  result = rb_protect (func, data, &state);
+  if (state)
+    {
+      exception = RB_ERRINFO;
+      if (exception)
+        rb_funcall (rb_mCairo, cr_id_exit_application, 2,
+                    exception, INT2NUM (EXIT_FAILURE));
+    }
+  return result;
+}
+
+void
+Init_cairo_private (void)
+{
+  cr_id_normalize_const_name = rb_intern ("normalize_const_name");
+  cr_id_objects = rb_intern ("objects");
+  cr_id_dup = rb_intern ("dup");
+  cr_id_inspect = rb_intern ("inspect");
+  cr_id_exit_application = rb_intern ("exit_application");
+}

data/ext/cairo/rb_cairo_private.h

@@ -0,0 +1,114 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-08-17 07:21:42 $
+ *
+ * Copyright 2005-2008 Kouhei Sutou <kou@cozmixng.org>
+ *
+ * This file is made available under the same terms as Ruby
+ *
+*/
+
+#ifndef RB_CAIRO_PRIVATE_H
+#define RB_CAIRO_PRIVATE_H
+
+#define CR_TRUE 1
+#define CR_FALSE 0
+
+#define CAIRO_INT_STATUS_UNSUPPORTED 100
+
+#define CSTR2RVAL(str) rb_str_new2(str)
+#define RVAL2CSTR(str) StringValueCStr(str)
+
+#define CBOOL2RVAL(bool) (bool ? Qtrue : Qfalse)
+#define RVAL2CBOOL(bool) RTEST(bool)
+
+#ifndef RSTRING_LEN
+#  define RSTRING_LEN(string) (RSTRING(string)->len)
+#endif
+
+#ifndef RARRAY_PTR
+#  define RARRAY_PTR(array) (RARRAY(array)->ptr)
+#endif
+
+#ifndef RARRAY_LEN
+#  define RARRAY_LEN(array) (RARRAY(array)->len)
+#endif
+
+#ifdef HAVE_RB_ERRINFO
+#  define RB_ERRINFO (rb_errinfo())
+#else
+#  define RB_ERRINFO (ruby_errinfo)
+#endif
+
+extern void Init_cairo_private (void);
+extern void Init_cairo_constants (void);
+
+extern void Init_cairo_context (void);
+extern void Init_cairo_path (void);
+extern void Init_cairo_matrix (void);
+extern void Init_cairo_surface (void);
+extern void Init_cairo_quartz_surface (void);
+extern void Init_cairo_exception (void);
+extern void Init_cairo_font (void);
+extern void Init_cairo_font_extents (void);
+extern void Init_cairo_font_options (void);
+extern void Init_cairo_scaled_font (void);
+extern void Init_cairo_text_extents (void);
+extern void Init_cairo_pattern (void);
+extern void Init_cairo_glyph (void);
+extern void Init_cairo_text_cluster (void);
+
+#define RB_CAIRO__GLYPHS_TO_ARRAY(rb_array, glyphs, length)     \
+do                                                              \
+  {                                                             \
+    Check_Type (rb_array, T_ARRAY);                             \
+    length = RARRAY_LEN (rb_array);                             \
+    glyphs = ALLOCA_N (cairo_glyph_t, length);                  \
+                                                                \
+    if (!glyphs)                                                \
+      rb_cairo_check_status (CAIRO_STATUS_NO_MEMORY);           \
+                                                                \
+    rb_cairo__glyphs_to_array (rb_array, glyphs, length);       \
+  } while (0)
+
+VALUE rb_cairo__float_array (double *values, unsigned count);
+void rb_cairo__glyphs_to_array (VALUE rb_array, cairo_glyph_t *glyphs, int length);
+
+VALUE rb_cairo__const_get (VALUE name, const char *prefix);
+cairo_bool_t rb_cairo__is_kind_of (VALUE object, VALUE klass);
+
+typedef struct rb_cairo__object_holder {
+  VALUE object;
+} rb_cairo__object_holder_t;
+
+rb_cairo__object_holder_t *rb_cairo__object_holder_new (VALUE klass, VALUE object);
+void rb_cairo__object_holder_free (VALUE klass, void *ptr);
+
+
+void rb_cairo__initialize_gc_guard_holder_class (VALUE klass);
+void rb_cairo__gc_guard_add (VALUE klass, VALUE object);
+void rb_cairo__gc_guard_remove (VALUE klass, VALUE object);
+VALUE rb_cairo__gc_guarded_objects (VALUE klass);
+
+const char *rb_cairo__inspect (VALUE object);
+
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+VALUE rb_cairo__glyphs_to_ruby_object (cairo_glyph_t *glyphs, int num_glyphs);
+void rb_cairo__glyphs_from_ruby_object (VALUE rb_glyphs,
+                                        cairo_glyph_t **glyphs, int *num_glyphs);
+VALUE rb_cairo__text_clusters_to_ruby_object (cairo_text_cluster_t *clusters,
+                                              int num_clusters);
+void rb_cairo__text_clusters_from_ruby_object (VALUE rb_clusters,
+                                               cairo_text_cluster_t **clusters,
+                                               int *num_clusters);
+#endif
+
+cairo_status_t rb_cairo__exception_to_status (VALUE exception);
+
+typedef VALUE (*cr_callback_func_t) (VALUE user_data);
+VALUE rb_cairo__invoke_callback (cr_callback_func_t func, VALUE user_data);
+
+#endif

data/ext/cairo/rb_cairo_scaled_font.c

@@ -0,0 +1,235 @@
+/* -*- 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"
+
+VALUE rb_cCairo_ScaledFont;
+
+#define _SELF(self)  (RVAL2CRSCALEDFONT(self))
+
+static inline void
+cr_scaled_font_check_status (cairo_scaled_font_t *font)
+{
+  rb_cairo_check_status (cairo_scaled_font_status (font));
+}
+
+cairo_scaled_font_t *
+rb_cairo_scaled_font_from_ruby_object (VALUE obj)
+{
+  cairo_scaled_font_t *font;
+  if (!rb_cairo__is_kind_of (obj, rb_cCairo_ScaledFont))
+    {
+      rb_raise (rb_eTypeError, "not a cairo scaled font");
+    }
+  Data_Get_Struct (obj, cairo_scaled_font_t, font);
+  return font;
+}
+
+static void
+cr_scaled_font_free (void *ptr)
+{
+  if (ptr)
+    {
+      cairo_scaled_font_destroy ((cairo_scaled_font_t *) ptr);
+    }
+}
+
+VALUE
+rb_cairo_scaled_font_to_ruby_object (cairo_scaled_font_t *font)
+{
+  if (font)
+    {
+      cairo_scaled_font_reference (font);
+      return Data_Wrap_Struct (rb_cCairo_ScaledFont, NULL,
+                               cr_scaled_font_free, font);
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+static VALUE
+cr_scaled_font_allocate (VALUE klass)
+{
+  return Data_Wrap_Struct (klass, NULL, cr_scaled_font_free, NULL);
+}
+
+static VALUE
+cr_scaled_font_initialize (VALUE self, VALUE face, VALUE matrix,
+                           VALUE ctm, VALUE options)
+{
+  cairo_scaled_font_t *font;
+
+  font = cairo_scaled_font_create (RVAL2CRFONTFACE (face),
+                                   RVAL2CRMATRIX (matrix),
+                                   RVAL2CRMATRIX (ctm),
+                                   RVAL2CRFONTOPTIONS (options));
+  cr_scaled_font_check_status (font);
+  DATA_PTR (self) = font;
+  return Qnil;
+}
+
+static VALUE
+cr_scaled_font_extents (VALUE self)
+{
+  cairo_font_extents_t extents;
+  cairo_scaled_font_extents (_SELF (self), &extents);
+  cr_scaled_font_check_status (_SELF (self));
+  return CRFONTEXTENTS2RVAL (&extents);
+}
+
+static VALUE
+cr_scaled_font_text_extents (VALUE self, VALUE utf8)
+{
+  cairo_text_extents_t extents;
+  cairo_scaled_font_text_extents (_SELF (self), StringValueCStr (utf8),
+                                  &extents);
+  cr_scaled_font_check_status (_SELF (self));
+  return CRTEXTEXTENTS2RVAL (&extents);
+}
+
+static VALUE
+cr_scaled_font_glyph_extents (VALUE self, VALUE rb_glyphs)
+{
+  cairo_text_extents_t extents;
+  cairo_glyph_t *glyphs;
+  int count;
+
+  RB_CAIRO__GLYPHS_TO_ARRAY (rb_glyphs, glyphs, count);
+  cairo_scaled_font_glyph_extents (_SELF (self), glyphs, count, &extents);
+  cr_scaled_font_check_status (_SELF (self));
+  return CRTEXTEXTENTS2RVAL (&extents);
+}
+
+#if CAIRO_CHECK_VERSION(1, 7, 6)
+static VALUE
+cr_scaled_font_text_to_glyphs (VALUE self, VALUE rb_x, VALUE rb_y, VALUE rb_utf8)
+{
+  double x, y;
+  const char *utf8;
+  int utf8_len;
+  cairo_glyph_t *glyphs = NULL;
+  int num_glyphs;
+  cairo_text_cluster_t *clusters = NULL;
+  int num_clusters;
+  cairo_text_cluster_flags_t cluster_flags;
+  cairo_status_t status;
+  VALUE rb_glyphs, rb_clusters;
+
+  x = NUM2DBL (rb_x);
+  y = NUM2DBL (rb_y);
+  utf8 = RSTRING_PTR (rb_utf8);
+  utf8_len = RSTRING_LEN (rb_utf8);
+
+  status = cairo_scaled_font_text_to_glyphs (_SELF (self),
+                                             x, y, utf8, utf8_len,
+                                             &glyphs, &num_glyphs,
+                                             &clusters, &num_clusters,
+                                             &cluster_flags);
+  rb_cairo_check_status (status);
+
+  rb_glyphs = rb_cairo__glyphs_to_ruby_object (glyphs, num_glyphs);
+  cairo_glyph_free (glyphs);
+  rb_clusters = rb_cairo__text_clusters_to_ruby_object (clusters, num_clusters);
+  cairo_text_cluster_free (clusters);
+
+  return rb_ary_new3 (3, rb_glyphs, rb_clusters, INT2NUM (cluster_flags));
+}
+#endif
+
+static VALUE
+cr_scaled_font_get_font_face (VALUE self)
+{
+  cairo_font_face_t *face;
+  face = cairo_scaled_font_get_font_face (_SELF (self));
+  cr_scaled_font_check_status (_SELF (self));
+  return CRFONTFACE2RVAL (face);
+}
+
+static VALUE
+cr_scaled_font_get_font_matrix (VALUE self)
+{
+  cairo_matrix_t font_matrix;
+  cairo_scaled_font_get_font_matrix (_SELF (self), &font_matrix);
+  cr_scaled_font_check_status (_SELF (self));
+  return CRMATRIX2RVAL (&font_matrix);
+}
+
+static VALUE
+cr_scaled_font_get_ctm (VALUE self)
+{
+  cairo_matrix_t ctm;
+  cairo_scaled_font_get_font_matrix (_SELF (self), &ctm);
+  cr_scaled_font_check_status (_SELF (self));
+  return CRMATRIX2RVAL (&ctm);
+}
+
+static VALUE
+cr_scaled_font_get_font_options (VALUE self)
+{
+  cairo_font_options_t *options;
+
+  options = cairo_font_options_create();
+  cairo_scaled_font_get_font_options (_SELF (self), options);
+  cr_scaled_font_check_status (_SELF (self));
+  rb_cairo_check_status (cairo_font_options_status (options));
+  return CRFONTOPTIONS2RVAL (options);
+}
+
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+static VALUE
+cr_scaled_font_get_scale_matrix (VALUE self)
+{
+  cairo_matrix_t matrix;
+
+  cairo_scaled_font_get_scale_matrix (_SELF (self), &matrix);
+  cr_scaled_font_check_status (_SELF (self));
+  return CRMATRIX2RVAL (&matrix);
+}
+#endif
+
+void
+Init_cairo_scaled_font (void)
+{
+  rb_cCairo_ScaledFont =
+    rb_define_class_under (rb_mCairo, "ScaledFont", rb_cObject);
+
+  rb_define_alloc_func (rb_cCairo_ScaledFont, cr_scaled_font_allocate);
+
+  rb_define_method (rb_cCairo_ScaledFont, "initialize",
+                    cr_scaled_font_initialize, 4);
+
+  rb_define_method (rb_cCairo_ScaledFont, "extents", cr_scaled_font_extents, 0);
+  rb_define_method (rb_cCairo_ScaledFont, "text_extents",
+                    cr_scaled_font_text_extents, 1);
+  rb_define_method (rb_cCairo_ScaledFont, "glyph_extents",
+                    cr_scaled_font_glyph_extents, 1);
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  rb_define_method (rb_cCairo_ScaledFont, "text_to_glyphs",
+                    cr_scaled_font_text_to_glyphs, 3);
+#endif
+  rb_define_method (rb_cCairo_ScaledFont, "font_face",
+                    cr_scaled_font_get_font_face, 0);
+  rb_define_method (rb_cCairo_ScaledFont, "font_matrix",
+                    cr_scaled_font_get_font_matrix, 0);
+  rb_define_method (rb_cCairo_ScaledFont, "ctm", cr_scaled_font_get_ctm, 0);
+  rb_define_method (rb_cCairo_ScaledFont, "font_options",
+                    cr_scaled_font_get_font_options, 0);
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  rb_define_method (rb_cCairo_ScaledFont, "scale_matrix",
+                    cr_scaled_font_get_scale_matrix, 0);
+#endif
+}