cairo 1.6.1-x86-mswin32

data/src/lib/cairo/papers.rb

@@ -0,0 +1,41 @@
+require 'cairo/paper'
+
+module Cairo
+  class Paper
+    [
+     [841, 1189, "A0"],
+     [594, 841, "A1"],
+     [420, 594, "A2"],
+     [297, 420, "A3"],
+     [210, 297, "A4"],
+     [148, 210, "A5"],
+     [105, 148, "A6"],
+     [74, 105, "A7"],
+     [52, 74, "A8"],
+     [37, 52, "A9"],
+     [26, 37, "A10"],
+
+     [1030, 1456, "B0"],
+     [728, 1030, "B1"],
+     [515, 728, "B2"],
+     [364, 515, "B3"],
+     [257, 364, "B4"],
+     [182, 257, "B5"],
+     [128, 182, "B6"],
+     [91, 128, "B7"],
+     [64, 91, "B8"],
+     [45, 64, "B9"],
+     [32, 45, "B10"],
+
+     [215.9, 279.4, "letter"],
+     [215.9, 355.6, "legal"],
+     [279.9, 431.8, "tabloid"],
+     [100, 148, "Japanese postcard"],
+    ].each do |width, height, name|
+      constant_name = name.upcase.gsub(/ +/, '_')
+      const_set(constant_name, new(width, height, "mm", name))
+      const_set("#{constant_name}_LANDSCAPE",
+                new(height, width, "mm", "#{name} (landscape)"))
+    end
+  end
+end

data/src/lib/cairo/path.rb

@@ -0,0 +1,15 @@
+require 'forwardable'
+
+module Cairo
+  class Path
+    extend Forwardable
+    methods = %w(new_path new_sub_path move_to line_to curve_to
+                 arc arc_negative rel_move_to rel_line_to rel_curve_to
+                 rectangle rounded_rectangle circle)
+    def_delegators :@context, *methods
+
+    def close
+      @context.close_path
+    end
+  end
+end

data/src/lib/cairo/point.rb

@@ -0,0 +1,7 @@
+module Cairo
+  class Point
+    def distance(other)
+      Math.sqrt((other.x - x) ** 2 + (other.y - y) ** 2)
+    end
+  end
+end

data/src/rb_cairo.c

@@ -0,0 +1,82 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-04-24 12:36:17 $
+ *
+ * Copyright 2006-2007 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_mCairo, rb_mCairo_Color, rb_cCairo_Color_Base, rb_cCairo_Paper;
+
+static ID id__add_one_arg_setter;
+
+void
+rb_cairo_def_setters (VALUE klass)
+{
+  rb_funcall (rb_mCairo, id__add_one_arg_setter, 1, klass);
+}
+
+void
+Init_cairo ()
+{
+  int major, minor, micro;
+
+  id__add_one_arg_setter = rb_intern("__add_one_arg_setter");
+
+  rb_mCairo = rb_define_module ("Cairo");
+
+  rb_define_const (rb_mCairo, "BUILD_VERSION",
+                   rb_ary_new3 (3,
+                                INT2FIX (CAIRO_VERSION_MAJOR),
+                                INT2FIX (CAIRO_VERSION_MINOR),
+                                INT2FIX (CAIRO_VERSION_MICRO)));
+
+  major = cairo_version () / 10000;
+  minor = (cairo_version () % 10000) / 100;
+  micro = cairo_version () % 100;
+
+  rb_define_const (rb_mCairo, "VERSION",
+                   rb_ary_new3 (3,
+                                INT2FIX (major),
+                                INT2FIX (minor),
+                                INT2FIX (micro)));
+
+  rb_define_const (rb_mCairo, "MAJOR_VERSION", INT2FIX (major));
+  rb_define_const (rb_mCairo, "MINOR_VERSION", INT2FIX (minor));
+  rb_define_const (rb_mCairo, "MICRO_VERSION", INT2FIX (micro));
+
+  rb_define_const (rb_mCairo, "BINDINGS_VERSION",
+                   rb_ary_new3 (4,
+                                INT2FIX (1), INT2FIX (6), INT2FIX (1), Qnil));
+
+  rb_mCairo_Color = rb_const_get (rb_mCairo, rb_intern ("Color"));
+  rb_cCairo_Color_Base = rb_const_get (rb_mCairo_Color, rb_intern ("Base"));
+  rb_cCairo_Paper = rb_const_get (rb_mCairo, rb_intern ("Paper"));
+
+  Init_cairo_private ();
+  Init_cairo_constants ();
+
+  Init_cairo_context ();
+  Init_cairo_path ();
+  Init_cairo_matrix ();
+  Init_cairo_surface ();
+  Init_cairo_exception ();
+  Init_cairo_font ();
+  Init_cairo_font_extents ();
+  Init_cairo_font_options ();
+  Init_cairo_scaled_font ();
+  Init_cairo_text_extents ();
+  Init_cairo_pattern ();
+  Init_cairo_glyph ();
+}

data/src/rb_cairo.h

@@ -0,0 +1,264 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-04-11 03:01:33 $
+ *
+ * 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
+ *
+ */
+
+
+#ifndef RB_CAIRO_H
+#define RB_CAIRO_H
+
+#include <cairo.h>
+
+#if CAIRO_HAS_PS_SURFACE
+#  include <cairo-ps.h>
+#endif
+
+#if CAIRO_HAS_PDF_SURFACE
+#  include <cairo-pdf.h>
+#endif
+
+#if CAIRO_HAS_SVG_SURFACE
+#  include <cairo-svg.h>
+#endif
+
+#if CAIRO_HAS_WIN32_SURFACE
+#  define OpenFile OpenFile_win32
+#  include <cairo-win32.h>
+#  undef OpenFile
+#endif
+
+#if CAIRO_HAS_QUARTZ_SURFACE
+#  include <cairo-quartz.h>
+#endif
+
+#define CAIRO_CHECK_VERSION(major, minor, micro)    \
+    (CAIRO_VERSION_MAJOR > (major) || \
+     (CAIRO_VERSION_MAJOR == (major) && CAIRO_VERSION_MINOR > (minor)) || \
+     (CAIRO_VERSION_MAJOR == (major) && CAIRO_VERSION_MINOR == (minor) && \
+      CAIRO_VERSION_MICRO >= (micro)))
+
+#include "ruby.h"
+
+#if defined(__cplusplus)
+#  define RB_CAIRO_BEGIN_DECLS extern "C" {
+#  define RB_CAIRO_END_DECLS }
+#else
+#  define RB_CAIRO_BEGIN_DECLS
+#  define RB_CAIRO_END_DECLS
+#endif
+
+RB_CAIRO_BEGIN_DECLS
+
+#if defined(RUBY_CAIRO_PLATFORM_WIN32) && !defined(RB_CAIRO_PLATFORM_WIN32)
+#  define RB_CAIRO_PLATFORM_WIN32 RUBY_CAIRO_PLATFORM_WIN32
+#endif
+
+#if defined(RUBY_CAIRO_STATIC_COMPILATION) && !defined(RB_CAIRO_STATIC_COMPILATION)
+#  define RB_CAIRO_STATIC_COMPILATION RUBY_CAIRO_STATIC_COMPILATION
+#endif
+
+#if defined(RB_CAIRO_PLATFORM_WIN32) && !defined(RB_CAIRO_STATIC_COMPILATION)
+#  ifdef RB_CAIRO_COMPILATION
+#    define RB_CAIRO_VAR __declspec(dllexport)
+#  else
+#    define RB_CAIRO_VAR extern __declspec(dllimport)
+#  endif
+#else
+#  define RB_CAIRO_VAR extern
+#endif
+
+RB_CAIRO_VAR VALUE rb_mCairo;
+RB_CAIRO_VAR VALUE rb_cCairo_Context;
+RB_CAIRO_VAR VALUE rb_cCairo_Point;
+RB_CAIRO_VAR VALUE rb_cCairo_Path;
+RB_CAIRO_VAR VALUE rb_cCairo_PathData;
+RB_CAIRO_VAR VALUE rb_cCairo_PathMoveTo;
+RB_CAIRO_VAR VALUE rb_cCairo_PathLineTo;
+RB_CAIRO_VAR VALUE rb_cCairo_PathCurveTo;
+RB_CAIRO_VAR VALUE rb_cCairo_PathClosePath;
+RB_CAIRO_VAR VALUE rb_cCairo_Matrix;
+RB_CAIRO_VAR VALUE rb_cCairo_Pattern;
+RB_CAIRO_VAR VALUE rb_cCairo_SolidPattern;
+RB_CAIRO_VAR VALUE rb_cCairo_SurfacePattern;
+RB_CAIRO_VAR VALUE rb_cCairo_GradientPattern;
+RB_CAIRO_VAR VALUE rb_cCairo_LinearPattern;
+RB_CAIRO_VAR VALUE rb_cCairo_RadialPattern;
+RB_CAIRO_VAR VALUE rb_cCairo_FontFace;
+RB_CAIRO_VAR VALUE rb_cCairo_FontExtents;
+RB_CAIRO_VAR VALUE rb_cCairo_FontOptions;
+RB_CAIRO_VAR VALUE rb_cCairo_ScaledFont;
+RB_CAIRO_VAR VALUE rb_cCairo_TextExtents;
+RB_CAIRO_VAR VALUE rb_cCairo_Glyph;
+RB_CAIRO_VAR VALUE rb_cCairo_Surface;
+RB_CAIRO_VAR VALUE rb_cCairo_ImageSurface;
+RB_CAIRO_VAR VALUE rb_cCairo_PDFSurface;
+RB_CAIRO_VAR VALUE rb_cCairo_PSSurface;
+RB_CAIRO_VAR VALUE rb_cCairo_SVGSurface;
+RB_CAIRO_VAR VALUE rb_cCairo_Win32Surface;
+RB_CAIRO_VAR VALUE rb_cCairo_Win32PrintingSurface;
+/* For backward compatibility*/
+#define rb_cCairo_WIN32Surface rb_cCairo_Win32Surface
+RB_CAIRO_VAR VALUE rb_cCairo_QuartzSurface;
+RB_CAIRO_VAR VALUE rb_cCairo_QuartzImageSurface;
+
+RB_CAIRO_VAR VALUE rb_mCairo_Operator;
+RB_CAIRO_VAR VALUE rb_mCairo_Antialias;
+RB_CAIRO_VAR VALUE rb_mCairo_FillRule;
+RB_CAIRO_VAR VALUE rb_mCairo_LineCap;
+RB_CAIRO_VAR VALUE rb_mCairo_LineJoin;
+RB_CAIRO_VAR VALUE rb_mCairo_FontSlant;
+RB_CAIRO_VAR VALUE rb_mCairo_FontWeight;
+RB_CAIRO_VAR VALUE rb_mCairo_SubpixelOrder;
+RB_CAIRO_VAR VALUE rb_mCairo_HintStyle;
+RB_CAIRO_VAR VALUE rb_mCairo_HintMetrics;
+RB_CAIRO_VAR VALUE rb_mCairo_FontType;
+RB_CAIRO_VAR VALUE rb_mCairo_PathDataType;
+RB_CAIRO_VAR VALUE rb_mCairo_Content;
+RB_CAIRO_VAR VALUE rb_mCairo_SurfaceType;
+RB_CAIRO_VAR VALUE rb_mCairo_Format;
+RB_CAIRO_VAR VALUE rb_mCairo_PatternType;
+RB_CAIRO_VAR VALUE rb_mCairo_Extend;
+RB_CAIRO_VAR VALUE rb_mCairo_Filter;
+RB_CAIRO_VAR VALUE rb_mCairo_SVGVersion;
+RB_CAIRO_VAR VALUE rb_mCairo_Color;
+RB_CAIRO_VAR VALUE rb_cCairo_Color_Base;
+RB_CAIRO_VAR VALUE rb_cCairo_Paper;
+
+
+#define RVAL2CRCONTEXT(obj)     (rb_cairo_context_from_ruby_object(obj))
+#define CRCONTEXT2RVAL(cr)      (rb_cairo_context_to_ruby_object(cr))
+
+#define RVAL2CRPATH(obj)        (rb_cairo_path_from_ruby_object(obj))
+#define CRPATH2RVAL(path)       (rb_cairo_path_to_ruby_object(path))
+
+#define RVAL2CRMATRIX(obj)      (rb_cairo_matrix_from_ruby_object(obj))
+#define CRMATRIX2RVAL(matrix)   (rb_cairo_matrix_to_ruby_object(matrix))
+
+#define RVAL2CRPATTERN(obj)     (rb_cairo_pattern_from_ruby_object(obj))
+#define CRPATTERN2RVAL(pattern) (rb_cairo_pattern_to_ruby_object(pattern))
+
+#define RVAL2CRFONTFACE(obj)    (rb_cairo_font_face_from_ruby_object(obj))
+#define CRFONTFACE2RVAL(face)   (rb_cairo_font_face_to_ruby_object(face))
+
+#define RVAL2CRFONTEXTENTS(obj) (rb_cairo_font_extents_from_ruby_object(obj))
+#define CRFONTEXTENTS2RVAL(ext) (rb_cairo_font_extents_to_ruby_object(ext))
+
+#define RVAL2CRFONTOPTIONS(obj) (rb_cairo_font_options_from_ruby_object(obj))
+#define CRFONTOPTIONS2RVAL(opt) (rb_cairo_font_options_to_ruby_object(opt))
+
+#define RVAL2CRSCALEDFONT(obj)  (rb_cairo_scaled_font_from_ruby_object(obj))
+#define CRSCALEDFONT2RVAL(font) (rb_cairo_scaled_font_to_ruby_object(font))
+
+#define RVAL2CRTEXTEXTENTS(obj) (rb_cairo_text_extents_from_ruby_object(obj))
+#define CRTEXTEXTENTS2RVAL(ext) (rb_cairo_text_extents_to_ruby_object(ext))
+
+#define RVAL2CRGLYPH(obj)       (rb_cairo_glyph_from_ruby_object(obj))
+#define CRGLYPH2RVAL(glyph)     (rb_cairo_glyph_to_ruby_object(glyph))
+
+#define RVAL2CRSURFACE(obj)     (rb_cairo_surface_from_ruby_object(obj))
+#define CRSURFACE2RVAL(surface) (rb_cairo_surface_to_ruby_object(surface))
+#define CRSURFACE2RVAL_WITH_DESTROY(surface) \
+  (rb_cairo_surface_to_ruby_object_with_destroy(surface))
+
+cairo_t              *rb_cairo_context_from_ruby_object      (VALUE obj);
+VALUE                 rb_cairo_context_to_ruby_object        (cairo_t *cr);
+
+cairo_path_t         *rb_cairo_path_from_ruby_object         (VALUE obj);
+VALUE                 rb_cairo_path_to_ruby_object           (cairo_path_t *path);
+
+cairo_matrix_t       *rb_cairo_matrix_from_ruby_object       (VALUE obj);
+VALUE                 rb_cairo_matrix_to_ruby_object         (cairo_matrix_t *matrix);
+
+cairo_pattern_t      *rb_cairo_pattern_from_ruby_object      (VALUE obj);
+VALUE                 rb_cairo_pattern_to_ruby_object        (cairo_pattern_t *pat);
+
+cairo_font_face_t    *rb_cairo_font_face_from_ruby_object    (VALUE obj);
+VALUE                 rb_cairo_font_face_to_ruby_object      (cairo_font_face_t *face);
+
+cairo_font_extents_t *rb_cairo_font_extents_from_ruby_object (VALUE obj);
+VALUE                 rb_cairo_font_extents_to_ruby_object   (cairo_font_extents_t *extents);
+
+cairo_font_options_t *rb_cairo_font_options_from_ruby_object (VALUE obj);
+VALUE                 rb_cairo_font_options_to_ruby_object   (cairo_font_options_t *options);
+
+cairo_scaled_font_t  *rb_cairo_scaled_font_from_ruby_object  (VALUE obj);
+VALUE                 rb_cairo_scaled_font_to_ruby_object    (cairo_scaled_font_t *options);
+
+cairo_text_extents_t *rb_cairo_text_extents_from_ruby_object (VALUE obj);
+VALUE                 rb_cairo_text_extents_to_ruby_object   (cairo_text_extents_t *extents);
+
+cairo_glyph_t        *rb_cairo_glyph_from_ruby_object        (VALUE obj);
+VALUE                 rb_cairo_glyph_to_ruby_object          (cairo_glyph_t *glyph);
+
+cairo_surface_t      *rb_cairo_surface_from_ruby_object      (VALUE obj);
+VALUE                 rb_cairo_surface_to_ruby_object        (cairo_surface_t *surface);
+VALUE                 rb_cairo_surface_to_ruby_object_with_destroy
+                                                             (cairo_surface_t *surface);
+
+
+#define RVAL2CROPERATOR(obj)      (rb_cairo_operator_from_ruby_object(obj))
+#define RVAL2CRANTIALIAS(obj)     (rb_cairo_antialias_from_ruby_object(obj))
+#define RVAL2CRFILLRULE(obj)      (rb_cairo_fill_rule_from_ruby_object(obj))
+#define RVAL2CRLINECAP(obj)       (rb_cairo_line_cap_from_ruby_object(obj))
+#define RVAL2CRLINEJOIN(obj)      (rb_cairo_line_join_from_ruby_object(obj))
+#define RVAL2CRFONTSLANT(obj)     (rb_cairo_font_slant_from_ruby_object(obj))
+#define RVAL2CRFONTWEIGHT(obj)    (rb_cairo_font_weight_from_ruby_object(obj))
+#define RVAL2CRSUBPIXELORDER(obj) (rb_cairo_subpixel_order_from_ruby_object(obj))
+#define RVAL2CRHINTSTYLE(obj)     (rb_cairo_hint_style_from_ruby_object(obj))
+#define RVAL2CRHINTMETRICS(obj)   (rb_cairo_hint_metrics_from_ruby_object(obj))
+#define RVAL2CRPATHDATATYPE(obj)  (rb_cairo_path_data_type_from_ruby_object(obj))
+#define RVAL2CRCONTENT(obj)       (rb_cairo_content_from_ruby_object(obj))
+#define RVAL2CRFORMAT(obj)        (rb_cairo_format_from_ruby_object(obj))
+#define RVAL2CREXTEND(obj)        (rb_cairo_extend_from_ruby_object(obj))
+#define RVAL2CRFILTER(obj)        (rb_cairo_filter_from_ruby_object(obj))
+#if CAIRO_HAS_SVG_SURFACE
+#define RVAL2CRSVGVERSION(obj)    (rb_cairo_svg_version_from_ruby_object(obj))
+#endif
+#if CAIRO_HAS_PS_SURFACE
+#  if CAIRO_CHECK_VERSION(1, 5, 2)
+#define RVAL2CRPSLEVEL(obj)       (rb_cairo_ps_level_from_ruby_object(obj))
+#  endif
+#endif
+
+cairo_operator_t       rb_cairo_operator_from_ruby_object       (VALUE obj);
+cairo_antialias_t      rb_cairo_antialias_from_ruby_object      (VALUE obj);
+cairo_fill_rule_t      rb_cairo_fill_rule_from_ruby_object      (VALUE obj);
+cairo_line_cap_t       rb_cairo_line_cap_from_ruby_object       (VALUE obj);
+cairo_line_join_t      rb_cairo_line_join_from_ruby_object      (VALUE obj);
+cairo_font_slant_t     rb_cairo_font_slant_from_ruby_object     (VALUE obj);
+cairo_font_weight_t    rb_cairo_font_weight_from_ruby_object    (VALUE obj);
+cairo_subpixel_order_t rb_cairo_subpixel_order_from_ruby_object (VALUE obj);
+cairo_hint_style_t     rb_cairo_hint_style_from_ruby_object     (VALUE obj);
+cairo_hint_metrics_t   rb_cairo_hint_metrics_from_ruby_object   (VALUE obj);
+cairo_path_data_type_t rb_cairo_path_data_type_from_ruby_object (VALUE obj);
+cairo_content_t        rb_cairo_content_from_ruby_object        (VALUE obj);
+cairo_format_t         rb_cairo_format_from_ruby_object         (VALUE obj);
+cairo_extend_t         rb_cairo_extend_from_ruby_object         (VALUE obj);
+cairo_filter_t         rb_cairo_filter_from_ruby_object         (VALUE obj);
+#if CAIRO_HAS_SVG_SURFACE
+cairo_svg_version_t    rb_cairo_svg_version_from_ruby_object    (VALUE obj);
+#endif
+#if CAIRO_HAS_PS_SURFACE
+#  if CAIRO_CHECK_VERSION(1, 5, 2)
+cairo_ps_level_t       rb_cairo_ps_level_from_ruby_object       (VALUE obj);
+#  endif
+#endif
+
+void rb_cairo_check_status (cairo_status_t status);
+
+
+#define RB_CAIRO_DEF_SETTERS(klass) rb_cairo_def_setters(klass);
+void rb_cairo_def_setters (VALUE klass);
+
+RB_CAIRO_END_DECLS
+
+#endif

data/src/rb_cairo_constants.c

@@ -0,0 +1,456 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-04-04 04:25:16 $
+ *
+ * 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_mCairo_Operator;
+VALUE rb_mCairo_Antialias;
+VALUE rb_mCairo_FillRule;
+VALUE rb_mCairo_LineCap;
+VALUE rb_mCairo_LineJoin;
+VALUE rb_mCairo_FontSlant;
+VALUE rb_mCairo_FontWeight;
+VALUE rb_mCairo_SubpixelOrder;
+VALUE rb_mCairo_HintStyle;
+VALUE rb_mCairo_HintMetrics;
+VALUE rb_mCairo_PathDataType;
+VALUE rb_mCairo_Content;
+VALUE rb_mCairo_Format;
+VALUE rb_mCairo_Extend;
+VALUE rb_mCairo_Filter;
+VALUE rb_mCairo_SVGVersion = Qnil;
+VALUE rb_mCairo_PSLevel = Qnil;
+
+#define CAIRO_OPERATOR_MIN CAIRO_OPERATOR_CLEAR
+#define CAIRO_OPERATOR_MAX CAIRO_OPERATOR_SATURATE
+
+#define CAIRO_ANTIALIAS_MIN CAIRO_ANTIALIAS_DEFAULT
+#define CAIRO_ANTIALIAS_MAX CAIRO_ANTIALIAS_SUBPIXEL
+
+#define CAIRO_FILL_RULE_MIN CAIRO_FILL_RULE_WINDING
+#define CAIRO_FILL_RULE_MAX CAIRO_FILL_RULE_EVEN_ODD
+
+#define CAIRO_LINE_CAP_MIN CAIRO_LINE_CAP_BUTT
+#define CAIRO_LINE_CAP_MAX CAIRO_LINE_CAP_SQUARE
+
+#define CAIRO_LINE_JOIN_MIN CAIRO_LINE_JOIN_MITER
+#define CAIRO_LINE_JOIN_MAX CAIRO_LINE_JOIN_BEVEL
+
+#define CAIRO_FONT_SLANT_MIN CAIRO_FONT_SLANT_NORMAL
+#define CAIRO_FONT_SLANT_MAX CAIRO_FONT_SLANT_OBLIQUE
+
+#define CAIRO_FONT_WEIGHT_MIN CAIRO_FONT_WEIGHT_NORMAL
+#define CAIRO_FONT_WEIGHT_MAX CAIRO_FONT_WEIGHT_BOLD
+
+#define CAIRO_SUBPIXEL_ORDER_MIN CAIRO_SUBPIXEL_ORDER_DEFAULT
+#define CAIRO_SUBPIXEL_ORDER_MAX CAIRO_SUBPIXEL_ORDER_VBGR
+
+#define CAIRO_HINT_STYLE_MIN CAIRO_HINT_STYLE_DEFAULT
+#define CAIRO_HINT_STYLE_MAX CAIRO_HINT_STYLE_FULL
+
+#define CAIRO_HINT_METRICS_MIN CAIRO_HINT_METRICS_DEFAULT
+#define CAIRO_HINT_METRICS_MAX CAIRO_HINT_METRICS_OFF
+
+#define CAIRO_PATH_MIN CAIRO_PATH_MOVE_TO
+#define CAIRO_PATH_MAX CAIRO_PATH_CLOSE_PATH
+
+#define CAIRO_CONTENT_MIN CAIRO_CONTENT_COLOR
+#define CAIRO_CONTENT_MAX CAIRO_CONTENT_COLOR_ALPHA
+
+#define CAIRO_FORMAT_MIN CAIRO_FORMAT_ARGB32
+#define CAIRO_FORMAT_MAX CAIRO_FORMAT_A1
+
+#define CAIRO_EXTEND_MIN CAIRO_EXTEND_NONE
+#define CAIRO_EXTEND_MAX CAIRO_EXTEND_REFLECT
+
+#define CAIRO_FILTER_MIN CAIRO_FILTER_FAST
+#define CAIRO_FILTER_MAX CAIRO_FILTER_GAUSSIAN
+
+#define CAIRO_SVG_VERSION_MIN CAIRO_SVG_VERSION_1_1
+#define CAIRO_SVG_VERSION_MAX CAIRO_SVG_VERSION_1_2
+
+#define CAIRO_PS_LEVEL_MIN CAIRO_PS_LEVEL_2
+#define CAIRO_PS_LEVEL_MAX CAIRO_PS_LEVEL_3
+
+#define DEFINE_RVAL2ENUM(name, const_name)                      \
+cairo_ ## name ## _t                                            \
+rb_cairo_ ## name ## _from_ruby_object (VALUE rb_ ## name)      \
+{                                                               \
+  cairo_ ## name ## _t name;                                    \
+                                                                \
+  if (!rb_cairo__is_kind_of (rb_ ## name, rb_cNumeric))         \
+    rb_ ## name = rb_cairo__const_get (rb_ ## name,             \
+                                       # const_name "_");       \
+                                                                \
+  name = FIX2INT (rb_ ## name);                                 \
+  if (name < CAIRO_ ## const_name ## _MIN ||                    \
+      name > CAIRO_ ## const_name ## _MAX)                      \
+    {                                                           \
+      rb_raise (rb_eArgError,                                   \
+                "invalid %s: %d (expect %d <= %s <= %d)",       \
+                #name, name,                                    \
+                CAIRO_ ## const_name ## _MIN,                   \
+                #name,                                          \
+                CAIRO_ ## const_name ## _MAX);                  \
+    }                                                           \
+  return name;                                                  \
+}
+
+DEFINE_RVAL2ENUM(operator, OPERATOR)
+DEFINE_RVAL2ENUM(antialias, ANTIALIAS)
+DEFINE_RVAL2ENUM(fill_rule, FILL_RULE)
+DEFINE_RVAL2ENUM(line_cap, LINE_CAP)
+DEFINE_RVAL2ENUM(line_join, LINE_JOIN)
+DEFINE_RVAL2ENUM(font_slant, FONT_SLANT)
+DEFINE_RVAL2ENUM(font_weight, FONT_WEIGHT)
+DEFINE_RVAL2ENUM(subpixel_order, SUBPIXEL_ORDER)
+DEFINE_RVAL2ENUM(hint_style, HINT_STYLE)
+DEFINE_RVAL2ENUM(hint_metrics, HINT_METRICS)
+DEFINE_RVAL2ENUM(path_data_type, PATH)
+DEFINE_RVAL2ENUM(content, CONTENT)
+DEFINE_RVAL2ENUM(format, FORMAT)
+DEFINE_RVAL2ENUM(extend, EXTEND)
+DEFINE_RVAL2ENUM(filter, FILTER)
+#if CAIRO_HAS_SVG_SURFACE
+DEFINE_RVAL2ENUM(svg_version, SVG_VERSION)
+#endif
+#if CAIRO_HAS_PS_SURFACE && CAIRO_CHECK_VERSION(1, 5, 2)
+DEFINE_RVAL2ENUM(ps_level, PS_LEVEL)
+#else
+#  ifdef RB_CAIRO_PLATFORM_WIN32
+void
+rb_cairo_ps_level_from_ruby_object (VALUE rb_ps_level)
+{
+  /* dummy */
+}
+#  endif
+#endif
+
+
+#if CAIRO_HAS_SVG_SURFACE
+static VALUE
+cr_svg_get_versions (VALUE self)
+{
+  VALUE rb_versions;
+  int i, num_versions;
+  cairo_svg_version_t const *versions;
+
+  cairo_svg_get_versions (&versions, &num_versions);
+
+  rb_versions = rb_ary_new2 (num_versions);
+
+  for (i = 0; i < num_versions; i++)
+    {
+      rb_ary_push (rb_versions, INT2NUM (versions[i]));
+    }
+
+  return rb_versions;
+}
+
+static VALUE
+cr_svg_version_to_string (int argc, VALUE *argv, VALUE self)
+{
+  if (argc == 0)
+    {
+      return rb_call_super (argc, argv);
+    }
+  else
+    {
+      VALUE version;
+      const char *ver_str;
+      rb_scan_args (argc, argv, "1", &version);
+      ver_str = cairo_svg_version_to_string (RVAL2CRSVGVERSION(version));
+      return rb_str_new2 (ver_str);
+    }
+}
+#endif
+
+#if CAIRO_CHECK_VERSION(1, 5, 8)
+static VALUE
+cr_format_stride_for_width (VALUE self, VALUE format, VALUE width)
+{
+  return INT2NUM (cairo_format_stride_for_width (RVAL2CRFORMAT (format),
+                                                 NUM2INT (width)));
+}
+#endif
+
+#if CAIRO_HAS_PS_SURFACE
+#  if CAIRO_CHECK_VERSION(1, 5, 8)
+static VALUE
+cr_ps_get_levels (VALUE self)
+{
+  VALUE rb_levels;
+  const cairo_ps_level_t *levels;
+  int i, n_levels;
+
+  cairo_ps_get_levels (&levels, &n_levels);
+
+  rb_levels = rb_ary_new2 (n_levels);
+  for (i = 0; i < n_levels; i++)
+    {
+      rb_ary_push (rb_levels, INT2NUM (levels[i]));
+    }
+
+  return rb_levels;
+}
+
+static VALUE
+cr_ps_level_to_string (int argc, VALUE *argv, VALUE self)
+{
+  if (argc == 0)
+    {
+      return rb_call_super (argc, argv);
+    }
+  else
+    {
+      VALUE level;
+      rb_scan_args (argc, argv, "1", &level);
+      return rb_str_new2 (cairo_ps_level_to_string (RVAL2CRPSLEVEL (level)));
+    }
+}
+#  endif
+#endif
+
+void
+Init_cairo_constants (void)
+{
+  /* cairo_operator_t */
+  rb_mCairo_Operator = rb_define_module_under (rb_mCairo, "Operator");
+  rb_define_const (rb_mCairo_Operator,    "CLEAR",
+                   INT2FIX (CAIRO_OPERATOR_CLEAR));
+
+  rb_define_const (rb_mCairo_Operator,    "SOURCE",
+                   INT2FIX (CAIRO_OPERATOR_SOURCE));
+  rb_define_const (rb_mCairo_Operator,    "OVER",
+                   INT2FIX (CAIRO_OPERATOR_OVER));
+  rb_define_const (rb_mCairo_Operator,    "IN",
+                   INT2FIX (CAIRO_OPERATOR_IN));
+  rb_define_const (rb_mCairo_Operator,    "OUT",
+                   INT2FIX (CAIRO_OPERATOR_OUT));
+  rb_define_const (rb_mCairo_Operator,    "ATOP",
+                   INT2FIX (CAIRO_OPERATOR_ATOP));
+
+  rb_define_const (rb_mCairo_Operator,    "DEST",
+                   INT2FIX (CAIRO_OPERATOR_DEST));
+  rb_define_const (rb_mCairo_Operator,    "DEST_OVER",
+                   INT2FIX (CAIRO_OPERATOR_DEST_OVER));
+  rb_define_const (rb_mCairo_Operator,    "DEST_IN",
+                   INT2FIX (CAIRO_OPERATOR_DEST_IN));
+  rb_define_const (rb_mCairo_Operator,    "DEST_OUT",
+                   INT2FIX (CAIRO_OPERATOR_DEST_OUT));
+  rb_define_const (rb_mCairo_Operator,    "DEST_ATOP",
+                   INT2FIX (CAIRO_OPERATOR_DEST_ATOP));
+
+  rb_define_const (rb_mCairo_Operator,    "XOR",
+                   INT2FIX (CAIRO_OPERATOR_XOR));
+  rb_define_const (rb_mCairo_Operator,    "ADD",
+                   INT2FIX (CAIRO_OPERATOR_ADD));
+  rb_define_const (rb_mCairo_Operator,    "SATURATE",
+                   INT2FIX (CAIRO_OPERATOR_SATURATE));
+
+
+  /* cairo_antialias_t */
+  rb_mCairo_Antialias = rb_define_module_under (rb_mCairo, "Antialias");
+  rb_define_const (rb_mCairo_Antialias,    "DEFAULT",
+                   INT2FIX (CAIRO_ANTIALIAS_DEFAULT));
+  rb_define_const (rb_mCairo_Antialias,    "NONE",
+                   INT2FIX (CAIRO_ANTIALIAS_NONE));
+  rb_define_const (rb_mCairo_Antialias,    "GRAY",
+                   INT2FIX (CAIRO_ANTIALIAS_GRAY));
+  rb_define_const (rb_mCairo_Antialias,    "SUBPIXEL",
+                   INT2FIX (CAIRO_ANTIALIAS_SUBPIXEL));
+
+
+  /* cairo_fill_rule_t */
+  rb_mCairo_FillRule = rb_define_module_under (rb_mCairo, "FillRule");
+  rb_define_const (rb_mCairo_FillRule,     "WINDING",
+                   INT2FIX (CAIRO_FILL_RULE_WINDING));
+  rb_define_const (rb_mCairo_FillRule,     "EVEN_ODD",
+                   INT2FIX (CAIRO_FILL_RULE_EVEN_ODD));
+
+
+  /* cairo_line_cap_t */
+  rb_mCairo_LineCap = rb_define_module_under (rb_mCairo, "LineCap");
+  rb_define_const (rb_mCairo_LineCap,     "BUTT",
+                   INT2FIX (CAIRO_LINE_CAP_BUTT));
+  rb_define_const (rb_mCairo_LineCap,     "ROUND",
+                   INT2FIX (CAIRO_LINE_CAP_ROUND));
+  rb_define_const (rb_mCairo_LineCap,     "SQUARE",
+                   INT2FIX (CAIRO_LINE_CAP_SQUARE));
+
+
+  /* cairo_line_join_t */
+  rb_mCairo_LineJoin = rb_define_module_under (rb_mCairo, "LineJoin");
+  rb_define_const (rb_mCairo_LineJoin,     "MITER",
+                   INT2FIX (CAIRO_LINE_JOIN_MITER));
+  rb_define_const (rb_mCairo_LineJoin,     "ROUND",
+                   INT2FIX (CAIRO_LINE_JOIN_ROUND));
+  rb_define_const (rb_mCairo_LineJoin,     "BEVEL",
+                   INT2FIX (CAIRO_LINE_JOIN_BEVEL));
+
+
+  /* cairo_font_slant_t */
+  rb_mCairo_FontSlant = rb_define_module_under (rb_mCairo, "FontSlant");
+  rb_define_const (rb_mCairo_FontSlant,     "NORMAL",
+                   INT2FIX (CAIRO_FONT_SLANT_NORMAL));
+  rb_define_const (rb_mCairo_FontSlant,     "ITALIC",
+                   INT2FIX (CAIRO_FONT_SLANT_ITALIC));
+  rb_define_const (rb_mCairo_FontSlant,     "OBLIQUE",
+                   INT2FIX (CAIRO_FONT_SLANT_OBLIQUE));
+
+
+  /* cairo_font_weight_t */
+  rb_mCairo_FontWeight = rb_define_module_under (rb_mCairo, "FontWeight");
+  rb_define_const (rb_mCairo_FontWeight,     "NORMAL",
+                   INT2FIX (CAIRO_FONT_WEIGHT_NORMAL));
+  rb_define_const (rb_mCairo_FontWeight,     "BOLD",
+                   INT2FIX (CAIRO_FONT_WEIGHT_BOLD));
+
+
+  /* cairo_subpixel_order_t */
+  rb_mCairo_SubpixelOrder = rb_define_module_under (rb_mCairo, "SubpixelOrder");
+  rb_define_const (rb_mCairo_SubpixelOrder,     "DEFAULT",
+                   INT2FIX (CAIRO_SUBPIXEL_ORDER_DEFAULT));
+  rb_define_const (rb_mCairo_SubpixelOrder,     "RGB",
+                   INT2FIX (CAIRO_SUBPIXEL_ORDER_RGB));
+  rb_define_const (rb_mCairo_SubpixelOrder,     "BGR",
+                   INT2FIX (CAIRO_SUBPIXEL_ORDER_BGR));
+  rb_define_const (rb_mCairo_SubpixelOrder,     "VRGB",
+                   INT2FIX (CAIRO_SUBPIXEL_ORDER_VRGB));
+  rb_define_const (rb_mCairo_SubpixelOrder,     "VBGR",
+                   INT2FIX (CAIRO_SUBPIXEL_ORDER_VBGR));
+
+
+  /* cairo_hint_style_t */
+  rb_mCairo_HintStyle = rb_define_module_under (rb_mCairo, "HintStyle");
+  rb_define_const (rb_mCairo_HintStyle,     "DEFAULT",
+                   INT2FIX (CAIRO_HINT_STYLE_DEFAULT));
+  rb_define_const (rb_mCairo_HintStyle,     "NONE",
+                   INT2FIX (CAIRO_HINT_STYLE_NONE));
+  rb_define_const (rb_mCairo_HintStyle,     "SLIGHT",
+                   INT2FIX (CAIRO_HINT_STYLE_SLIGHT));
+  rb_define_const (rb_mCairo_HintStyle,     "MEDIUM",
+                   INT2FIX (CAIRO_HINT_STYLE_MEDIUM));
+  rb_define_const (rb_mCairo_HintStyle,     "FULL",
+                   INT2FIX (CAIRO_HINT_STYLE_FULL));
+
+
+  /* cairo_hint_metrics_t */
+  rb_mCairo_HintMetrics = rb_define_module_under (rb_mCairo, "HintMetrics");
+  rb_define_const (rb_mCairo_HintMetrics,     "DEFAULT",
+                   INT2FIX (CAIRO_HINT_METRICS_DEFAULT));
+  rb_define_const (rb_mCairo_HintMetrics,     "ON",
+                   INT2FIX (CAIRO_HINT_METRICS_ON));
+  rb_define_const (rb_mCairo_HintMetrics,     "OFF",
+                   INT2FIX (CAIRO_HINT_METRICS_OFF));
+
+
+  /* cairo_path_data_type_t */
+  rb_mCairo_PathDataType = rb_define_module_under (rb_mCairo, "PathDataType");
+  rb_define_const (rb_mCairo_PathDataType, "MOVE_TO",
+                   INT2FIX (CAIRO_PATH_MOVE_TO));
+  rb_define_const (rb_mCairo_PathDataType, "LINE_TO",
+                   INT2FIX (CAIRO_PATH_LINE_TO));
+  rb_define_const (rb_mCairo_PathDataType, "CURVE_TO",
+                   INT2FIX (CAIRO_PATH_CURVE_TO));
+  rb_define_const (rb_mCairo_PathDataType, "CLOSE_PATH",
+                   INT2FIX (CAIRO_PATH_CLOSE_PATH));
+
+
+  /* cairo_content_t */
+  rb_mCairo_Content = rb_define_module_under (rb_mCairo, "Content");
+  rb_define_const (rb_mCairo_Content,    "COLOR",
+                   INT2FIX (CAIRO_CONTENT_COLOR));
+  rb_define_const (rb_mCairo_Content,    "ALPHA",
+                   INT2FIX (CAIRO_CONTENT_ALPHA));
+  rb_define_const (rb_mCairo_Content,    "COLOR_ALPHA",
+                   INT2FIX (CAIRO_CONTENT_COLOR_ALPHA));
+
+
+  /* cairo_format_t */
+  rb_mCairo_Format = rb_define_module_under (rb_mCairo, "Format");
+  rb_define_const (rb_mCairo_Format,    "ARGB32",
+                   INT2FIX (CAIRO_FORMAT_ARGB32));
+  rb_define_const (rb_mCairo_Format,    "RGB24",
+                   INT2FIX (CAIRO_FORMAT_RGB24));
+  rb_define_const (rb_mCairo_Format,    "A8",
+                   INT2FIX (CAIRO_FORMAT_A8));
+  rb_define_const (rb_mCairo_Format,    "A1",
+                   INT2FIX (CAIRO_FORMAT_A1));
+#if !CAIRO_CHECK_VERSION(1, 3, 0)
+  rb_define_const (rb_mCairo_Format,    "RGB16_565",
+                   INT2FIX (CAIRO_FORMAT_RGB16_565));
+#endif
+
+#if CAIRO_CHECK_VERSION(1, 5, 8)
+  rb_define_singleton_method (rb_mCairo_Format, "stride_for_width",
+                              cr_format_stride_for_width, 2);
+#endif
+
+
+  /* cairo_extend_t */
+  rb_mCairo_Extend = rb_define_module_under (rb_mCairo, "Extend");
+  rb_define_const (rb_mCairo_Extend,    "NONE",
+                   INT2FIX (CAIRO_EXTEND_NONE));
+  rb_define_const (rb_mCairo_Extend,    "REPEAT",
+                   INT2FIX (CAIRO_EXTEND_REPEAT));
+  rb_define_const (rb_mCairo_Extend,    "REFLECT",
+                   INT2FIX (CAIRO_EXTEND_REFLECT));
+  rb_define_const (rb_mCairo_Extend,    "PAD",
+                   INT2FIX (CAIRO_EXTEND_PAD));
+
+
+  /* cairo_filter_t */
+  rb_mCairo_Filter = rb_define_module_under (rb_mCairo, "Filter");
+  rb_define_const (rb_mCairo_Filter,    "FAST",
+                   INT2FIX (CAIRO_FILTER_FAST));
+  rb_define_const (rb_mCairo_Filter,    "GOOD",
+                   INT2FIX (CAIRO_FILTER_GOOD));
+  rb_define_const (rb_mCairo_Filter,    "BEST",
+                   INT2FIX (CAIRO_FILTER_BEST));
+  rb_define_const (rb_mCairo_Filter,    "NEAREST",
+                   INT2FIX (CAIRO_FILTER_NEAREST));
+  rb_define_const (rb_mCairo_Filter,    "BILINEAR",
+                   INT2FIX (CAIRO_FILTER_BILINEAR));
+  rb_define_const (rb_mCairo_Filter,    "GAUSSIAN",
+                   INT2FIX (CAIRO_FILTER_GAUSSIAN));
+
+#if CAIRO_HAS_SVG_SURFACE
+  /* cairo_svg_version_t */
+  rb_mCairo_SVGVersion = rb_define_module_under (rb_mCairo, "SVGVersion");
+  rb_define_const (rb_mCairo_SVGVersion, "VERSION_1_1",
+                   INT2FIX (CAIRO_SVG_VERSION_1_1));
+  rb_define_const (rb_mCairo_SVGVersion, "VERSION_1_2",
+                   INT2FIX (CAIRO_SVG_VERSION_1_2));
+
+  rb_define_singleton_method (rb_mCairo_SVGVersion, "list",
+                              cr_svg_get_versions, 0);
+  rb_define_singleton_method (rb_mCairo_SVGVersion, "name",
+                              cr_svg_version_to_string, -1);
+#endif
+
+#if CAIRO_HAS_PS_SURFACE && CAIRO_CHECK_VERSION(1, 5, 2)
+  /* cairo_ps_level_t */
+  rb_mCairo_PSLevel = rb_define_module_under (rb_mCairo, "PSLevel");
+  rb_define_const (rb_mCairo_PSLevel, "LEVEL_2", INT2FIX (CAIRO_PS_LEVEL_2));
+  rb_define_const (rb_mCairo_PSLevel, "LEVEL_3", INT2FIX (CAIRO_PS_LEVEL_3));
+
+  rb_define_singleton_method (rb_mCairo_PSLevel, "list",
+                              cr_ps_get_levels, 0);
+  rb_define_singleton_method (rb_mCairo_PSLevel, "name",
+                              cr_ps_level_to_string, -1);
+#endif
+}