cairo 1.6.1-x86-mswin32

data/src/rb_cairo_exception.c

@@ -0,0 +1,214 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-02-21 13:18:10 $
+ *
+ * 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"
+
+static VALUE rb_eCairo_InvalidRestoreError;
+static VALUE rb_eCairo_InvalidPopGroupError;
+static VALUE rb_eCairo_NoCurrentPointError;
+static VALUE rb_eCairo_InvalidMatrixError;
+static VALUE rb_eCairo_InvalidStatusError;
+static VALUE rb_eCairo_NullPointerError;
+static VALUE rb_eCairo_InvalidStringError;
+static VALUE rb_eCairo_InvalidPathDataError;
+static VALUE rb_eCairo_ReadError;
+static VALUE rb_eCairo_WriteError;
+static VALUE rb_eCairo_SurfaceFinishedError;
+static VALUE rb_eCairo_SurfaceTypeMismatchError;
+static VALUE rb_eCairo_PatternTypeMismatchError;
+static VALUE rb_eCairo_InvalidContentError;
+static VALUE rb_eCairo_InvalidFormatError;
+static VALUE rb_eCairo_InvalidVisualError;
+static VALUE rb_eCairo_FileNotFoundError;
+static VALUE rb_eCairo_InvalidDashError;
+static VALUE rb_eCairo_InvalidDscCommentError;
+#if CAIRO_CHECK_VERSION(1, 3, 0)
+static VALUE rb_eCairo_InvalidIndexError;
+static VALUE rb_eCairo_ClipNotRepresentableError;
+#endif
+#if CAIRO_CHECK_VERSION(1, 5, 6)
+static VALUE rb_eCairo_TempFileError;
+static VALUE rb_eCairo_InvalidStrideError;
+#endif
+
+void
+rb_cairo_check_status (cairo_status_t status)
+{
+  const char *string = cairo_status_to_string (status);
+  
+  switch (status)
+    {
+    case CAIRO_STATUS_SUCCESS:
+      break;
+    case CAIRO_STATUS_NO_MEMORY:
+      rb_raise (rb_eNoMemError, string);
+      break;
+    case CAIRO_STATUS_INVALID_RESTORE:
+      rb_raise (rb_eCairo_InvalidRestoreError, string);
+      break;
+    case CAIRO_STATUS_INVALID_POP_GROUP:
+      rb_raise (rb_eCairo_InvalidPopGroupError, string);
+      break;
+    case CAIRO_STATUS_NO_CURRENT_POINT:
+      rb_raise (rb_eCairo_NoCurrentPointError, string);
+      break;
+    case CAIRO_STATUS_INVALID_MATRIX:
+      rb_raise (rb_eCairo_InvalidMatrixError, string);
+      break;
+    case CAIRO_STATUS_INVALID_STATUS:
+      rb_raise (rb_eCairo_InvalidStatusError, string);
+      break;
+    case CAIRO_STATUS_NULL_POINTER:
+      rb_raise (rb_eCairo_NullPointerError, string);
+      break;
+    case CAIRO_STATUS_INVALID_STRING:
+      rb_raise (rb_eCairo_InvalidStringError, string);
+      break;
+    case CAIRO_STATUS_INVALID_PATH_DATA:
+      rb_raise (rb_eCairo_InvalidPathDataError, string);
+      break;
+    case CAIRO_STATUS_READ_ERROR:
+      rb_raise (rb_eCairo_ReadError, string);
+      break;
+    case CAIRO_STATUS_WRITE_ERROR:
+      rb_raise (rb_eCairo_WriteError, string);
+      break;
+    case CAIRO_STATUS_SURFACE_FINISHED:
+      rb_raise (rb_eCairo_SurfaceFinishedError, string);
+      break;
+    case CAIRO_STATUS_SURFACE_TYPE_MISMATCH:
+      rb_raise (rb_eCairo_SurfaceTypeMismatchError, string);
+      break;
+    case CAIRO_STATUS_PATTERN_TYPE_MISMATCH:
+      rb_raise (rb_eCairo_PatternTypeMismatchError, string);
+      break;
+    case CAIRO_STATUS_INVALID_CONTENT:
+      rb_raise (rb_eCairo_InvalidContentError, string);
+      break;
+    case CAIRO_STATUS_INVALID_FORMAT:
+      rb_raise (rb_eCairo_InvalidFormatError, string);
+      break;
+    case CAIRO_STATUS_INVALID_VISUAL:
+      rb_raise (rb_eCairo_InvalidVisualError, string);
+      break;
+    case CAIRO_STATUS_FILE_NOT_FOUND:
+      rb_raise (rb_eCairo_FileNotFoundError, string);
+      break;
+    case CAIRO_STATUS_INVALID_DASH:
+      rb_raise (rb_eCairo_InvalidDashError, string);
+      break;
+    case CAIRO_STATUS_INVALID_DSC_COMMENT:
+      rb_raise (rb_eCairo_InvalidDscCommentError, string);
+      break;
+#if CAIRO_CHECK_VERSION(1, 3, 0)
+    case CAIRO_STATUS_INVALID_INDEX:
+      rb_raise (rb_eCairo_InvalidIndexError, string);
+      break;
+    case CAIRO_STATUS_CLIP_NOT_REPRESENTABLE:
+      rb_raise (rb_eCairo_ClipNotRepresentableError, string);
+      break;
+#endif
+#if CAIRO_CHECK_VERSION(1, 5, 6)
+    case CAIRO_STATUS_TEMP_FILE_ERROR:
+      rb_raise (rb_eCairo_TempFileError, string);
+      break;
+    case CAIRO_STATUS_INVALID_STRIDE:
+      rb_raise (rb_eCairo_InvalidStringError, string);
+      break;
+#endif
+    }
+}
+
+void
+Init_cairo_exception ()
+{
+  VALUE rb_eCairo_Error;
+  rb_eCairo_Error =
+    rb_define_class_under (rb_mCairo, "Error", rb_eStandardError);
+  rb_eCairo_InvalidRestoreError =
+    rb_define_class_under (rb_mCairo, "InvalidRestoreError",
+                           rb_eCairo_Error);
+  rb_eCairo_InvalidPopGroupError =
+    rb_define_class_under (rb_mCairo, "InvalidPopGroupError",
+                           rb_eCairo_Error);
+  rb_eCairo_NoCurrentPointError =
+    rb_define_class_under (rb_mCairo, "NoCurrentPointError",
+                           rb_eCairo_Error);
+  rb_eCairo_InvalidMatrixError =
+    rb_define_class_under (rb_mCairo, "InvalidMatrixError",
+                           rb_eArgError);
+  rb_eCairo_InvalidStatusError =
+    rb_define_class_under (rb_mCairo, "InvalidStatusError",
+                           rb_eArgError);
+  rb_eCairo_NullPointerError =
+    rb_define_class_under (rb_mCairo, "NullPointerError",
+                           rb_eTypeError);
+  rb_eCairo_InvalidStringError =
+    rb_define_class_under (rb_mCairo, "InvalidStringError",
+                           rb_eArgError);
+  rb_eCairo_InvalidPathDataError =
+    rb_define_class_under (rb_mCairo, "InvalidPathDataError",
+                           rb_eArgError);
+  rb_eCairo_ReadError =
+    rb_define_class_under (rb_mCairo, "ReadError",
+                           rb_eIOError);
+  rb_eCairo_WriteError =
+    rb_define_class_under (rb_mCairo, "WriteError",
+                           rb_eIOError);
+  rb_eCairo_SurfaceFinishedError =
+    rb_define_class_under (rb_mCairo, "SurfaceFinishedError",
+                           rb_eCairo_Error);
+  rb_eCairo_SurfaceTypeMismatchError =
+    rb_define_class_under (rb_mCairo, "SurfaceTypeMismatchError",
+                           rb_eTypeError);
+  rb_eCairo_PatternTypeMismatchError =
+    rb_define_class_under (rb_mCairo, "PatternTypeMismatchError",
+                           rb_eTypeError);
+  rb_eCairo_InvalidContentError =
+    rb_define_class_under (rb_mCairo, "InvalidContentError",
+                           rb_eArgError);
+  rb_eCairo_InvalidFormatError =
+    rb_define_class_under (rb_mCairo, "InvalidFormatError",
+                           rb_eArgError);
+  rb_eCairo_InvalidVisualError =
+    rb_define_class_under (rb_mCairo, "InvalidVisualError",
+                           rb_eArgError);
+  rb_eCairo_FileNotFoundError =
+    rb_define_class_under (rb_mCairo, "FileNotFound",
+                           rb_eCairo_Error);
+  rb_eCairo_InvalidDashError =
+    rb_define_class_under (rb_mCairo, "InvalidDashError",
+                           rb_eArgError);
+  rb_eCairo_InvalidDscCommentError =
+    rb_define_class_under (rb_mCairo, "InvalidDscCommentError",
+                           rb_eArgError);
+#if CAIRO_CHECK_VERSION(1, 3, 0)
+  rb_eCairo_InvalidIndexError =
+    rb_define_class_under (rb_mCairo, "InvalidIndexError",
+                           rb_eArgError);
+  rb_eCairo_ClipNotRepresentableError =
+    rb_define_class_under (rb_mCairo, "ClipNotRepresentableError",
+                           rb_eCairo_Error);
+#endif
+
+#if CAIRO_CHECK_VERSION(1, 5, 6)
+  rb_eCairo_TempFileError =
+    rb_define_class_under (rb_mCairo, "TempFileError",
+                           rb_eCairo_Error);
+
+  rb_eCairo_InvalidStrideError =
+        rb_define_class_under (rb_mCairo, "InvalidStrideError",
+                               rb_eArgError);
+#endif
+}

data/src/rb_cairo_font_extents.c

@@ -0,0 +1,125 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2007/05/03 02:47: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_FontExtents;
+
+#define _SELF(self)  (RVAL2CRFONTEXTENTS(self))
+
+cairo_font_extents_t *
+rb_cairo_font_extents_from_ruby_object (VALUE obj)
+{
+  cairo_font_extents_t *extents;
+  if (!rb_cairo__is_kind_of (obj, rb_cCairo_FontExtents))
+    {
+      rb_raise (rb_eTypeError, "not a cairo font extents");
+    }
+  Data_Get_Struct (obj, cairo_font_extents_t, extents);
+  return extents;
+}
+
+VALUE
+rb_cairo_font_extents_to_ruby_object (cairo_font_extents_t *extents)
+{
+  if (extents)
+    {
+      cairo_font_extents_t *new_extents = ALLOC (cairo_font_extents_t);
+      *new_extents = *extents;
+      return Data_Wrap_Struct (rb_cCairo_FontExtents, NULL, -1, new_extents);
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+static    VALUE
+cr_font_extents_ascent (VALUE self)
+{
+  return rb_float_new (_SELF(self)->ascent);
+}
+
+static    VALUE
+cr_font_extents_descent (VALUE self)
+{
+  return rb_float_new (_SELF(self)->descent);
+}
+
+static    VALUE
+cr_font_extents_height (VALUE self)
+{
+  return rb_float_new (_SELF(self)->height);
+}
+
+static    VALUE
+cr_font_extents_max_x_advance (VALUE self)
+{
+  return rb_float_new (_SELF(self)->max_x_advance);
+}
+
+static    VALUE
+cr_font_extents_max_y_advance (VALUE self)
+{
+  return rb_float_new (_SELF(self)->max_y_advance);
+}
+
+static VALUE
+cr_font_extents_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, "ascent=");
+  rb_str_concat (ret, rb_inspect (cr_font_extents_ascent (self)));
+  rb_str_cat2 (ret, ", ");
+  rb_str_cat2 (ret, "descent=");
+  rb_str_concat (ret, rb_inspect (cr_font_extents_descent (self)));
+  rb_str_cat2 (ret, ", ");
+  rb_str_cat2 (ret, "height=");
+  rb_str_concat (ret, rb_inspect (cr_font_extents_height (self)));
+  rb_str_cat2 (ret, ", ");
+  rb_str_cat2 (ret, "max_x_advance=");
+  rb_str_concat (ret, rb_inspect (cr_font_extents_max_x_advance (self)));
+  rb_str_cat2 (ret, ", ");
+  rb_str_cat2 (ret, "max_y_advance=");
+  rb_str_concat (ret, rb_inspect (cr_font_extents_max_y_advance (self)));
+  rb_str_cat2 (ret, ">");
+
+  return ret;
+}
+
+
+void
+Init_cairo_font_extents (void)
+{
+  rb_cCairo_FontExtents =
+    rb_define_class_under (rb_mCairo, "FontExtents", rb_cObject);
+
+  rb_define_method (rb_cCairo_FontExtents, "ascent",
+                    cr_font_extents_ascent, 0);
+  rb_define_method (rb_cCairo_FontExtents, "descent",
+                    cr_font_extents_descent, 0);
+  rb_define_method (rb_cCairo_FontExtents, "height",
+                    cr_font_extents_height, 0);
+  rb_define_method (rb_cCairo_FontExtents, "max_x_advance",
+                    cr_font_extents_max_x_advance, 0);
+  rb_define_method (rb_cCairo_FontExtents, "max_y_advance",
+                    cr_font_extents_max_y_advance, 0);
+
+  rb_define_method (rb_cCairo_FontExtents, "to_s", cr_font_extents_to_s, 0);
+}

data/src/rb_cairo_font_face.c

@@ -0,0 +1,56 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2007/05/20 09:25:37 $
+ *
+ * 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_FontFace;
+
+#define _SELF  (RVAL2CRFONTFACE(self))
+
+cairo_font_face_t *
+rb_cairo_font_face_from_ruby_object (VALUE obj)
+{
+  cairo_font_face_t *face;
+  if (!rb_cairo__is_kind_of (obj, rb_cCairo_FontFace))
+    {
+      rb_raise (rb_eTypeError, "not a cairo font face");
+    }
+  Data_Get_Struct (obj, cairo_font_face_t, face);
+  return face;
+}
+
+VALUE
+rb_cairo_font_face_to_ruby_object (cairo_font_face_t *face)
+{
+  if (face)
+    {
+      cairo_font_face_reference (face);
+      return Data_Wrap_Struct (rb_cCairo_FontFace, NULL,
+                               cairo_font_face_destroy, face);
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+
+void
+Init_cairo_font (void)
+{
+  rb_cCairo_FontFace =
+    rb_define_class_under (rb_mCairo, "FontFace", rb_cObject);
+}

data/src/rb_cairo_font_options.c

@@ -0,0 +1,197 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2007-05-26 15:13:25 $
+ *
+ * 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) (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);
+}