cairo 1.4.1

data/src/lib/cairo/context/path.rb

@@ -0,0 +1,127 @@
+module Cairo
+  class Context
+    module Path
+      module Point
+        module_function
+        def distance(a, b)
+          ax, ay = a
+          bx, by = b
+          Math.sqrt((bx - ax) ** 2 + (by - ay) ** 2)
+        end
+      end
+
+      def transform_path(path, &block)
+        save do
+          new_path
+          path.each do |type, points|
+            case type
+            when PATH_CURVE_TO
+              curve_to(*points.collect(&block).flatten)
+            when PATH_MOVE_TO
+              move_to(*points.collect(&block).flatten)
+            when PATH_LINE_TO
+              line_to(*points.collect(&block).flatten)
+            when PATH_CLOSE_PATH
+              close_path
+            end
+          end
+          copy_path
+        end
+      end
+
+      def map_path_onto(path)
+        parameterized_path = parameterize_path(path)
+        transformed_path = transform_path(copy_path) do |x, y|
+          current_point = nil
+          d = x
+          i = -1
+          type = points = nil
+          path.each do |type, points|
+            i += 1
+            break if d <= parameterized_path[i]
+            d -= parameterized_path[i]
+            case type
+            when PATH_MOVE_TO
+              current_point = points[0]
+            when PATH_LINE_TO
+              current_point = points[0]
+            when PATH_CURVE_TO
+              current_point = points[2]
+            when PATH_CLOSE_PATH
+            end
+          end
+
+          case type
+          when PATH_MOVE_TO
+            [x, y]
+          when PATH_LINE_TO
+            ratio = d / parameterized_path[i]
+            current_x, current_y = current_point
+            lx, ly = points[0]
+            new_x = current_x * (1 - ratio) + lx * ratio
+            new_y = current_y * (1 - ratio) + ly * ratio
+            dx = -(current_x - lx)
+            dy = -(current_y - ly)
+
+            ratio = y / parameterized_path[i]
+            [new_x + -dy * ratio, new_y + dx * ratio]
+          when PATH_CURVE_TO
+            ratio = d / parameterized_path[i]
+            current_x, current_y = current_point
+            cx0, cy0 = points[0]
+            cx1, cy1 = points[1]
+            cx2, cy2 = points[2]
+
+            new_x = current_x * (1 - ratio) * (1 - ratio) * (1 - ratio) +
+                    3 * cx0   * (1 - ratio) * (1 - ratio) * ratio +
+                    3 * cx1   * (1 - ratio) *      ratio  * ratio +
+                        cx2   *      ratio  *      ratio  * ratio
+            new_y = current_y * (1 - ratio) * (1 - ratio) * (1 - ratio) +
+                    3 * cy0   * (1 - ratio) * (1 - ratio) * ratio +
+                    3 * cy1   * (1 - ratio) *      ratio  * ratio +
+                        cy2   *      ratio  *      ratio  * ratio
+
+            dx = -3 * current_x * (1 - ratio) * (1 - ratio) +
+                  3 * cx0       * (1 - 4 * ratio + 3 * ratio * ratio) +
+                  3 * cx1       * (    2 * ratio - 3 * ratio * ratio) +
+                  3 * cx2       *      ratio  * ratio
+            dy = -3 * current_y * (1 - ratio) * (1 - ratio) +
+                  3 * cy0       * (1 - 4 * ratio + 3 * ratio * ratio) +
+                  3 * cy1       * (    2 * ratio - 3 * ratio * ratio) +
+                  3 * cy2       *      ratio  * ratio
+
+            ratio = y / Math.sqrt(dx ** 2, dy ** 2)
+
+            [new_x + -dy * ratio, new_y + dx * ratio]
+          when PATH_CLOSE_PATH
+            [x, y]
+          end
+        end
+        new_path
+        append_path(transformed_path)
+      end
+
+      private
+      def parameterize_path(path)
+        current_point = nil
+        path.collect do |type, points|
+          result = 0
+          case type
+          when PATH_MOVE_TO
+            current_point = points[0]
+          when PATH_LINE_TO
+            result = Point.distance(current_point, points[0])
+            current_point = points[0]
+          when PATH_CURVE_TO
+            result = Point.distance(current_point, points[0])
+            result += Point.distance(points[0], points[1])
+            result += Point.distance(points[1], points[2])
+            current_point = points[2]
+          when PATH_CLOSE_PATH
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/src/lib/cairo/context/quad.rb

@@ -0,0 +1,19 @@
+module Cairo
+  class Context
+    module Quad
+      def quad_to(x1, y1, x2, y2)
+        x0, y0 = current_point
+        cx1 = x0 + 2 * (x1 - x0) / 3.0
+        cy1 = y0 + 2 * (y1 - y0) / 3.0
+        cx2 = cx1 + (x2 - x0) / 3.0
+        cy2 = cy1 + (y2 - y0) / 3.0
+        curve_to(cx1, cy1, cx2, cy2, x2, y2)
+      end
+
+      def rel_quad_to(x1, y1, x2, y2)
+        x0, y0 = current_point
+        quad_to(x1 + x0, y1 + y0, x2 + x0, y2 + x0)
+      end
+    end
+  end
+end

data/src/lib/cairo/context/rectangle.rb

@@ -0,0 +1,33 @@
+module Cairo
+  class Context
+    module Rectangle
+      def rounded_rectangle(x, y, width, height, x_radius, y_radius=nil)
+        x1 = x
+        x2 = x1 + width
+        y1 = y
+        y2 = y1 + height
+
+        y_radius ||= x_radius
+
+        x_radius = [x_radius, width / 2.0].min
+        y_radius = [y_radius, height / 2.0].min
+
+        xr1 = x_radius
+        xr2 = x_radius / 2.0
+        yr1 = y_radius
+        yr2 = y_radius / 2.0
+
+        move_to(x1 + xr1, y1)
+        line_to(x2 - xr1, y1)
+        curve_to(x2 - xr2, y1, x2, y1 + yr2, x2, y1 + yr1)
+        line_to(x2, y2 - yr1)
+        curve_to(x2, y2 - yr2, x2 - xr2, y2, x2 - xr1, y2)
+        line_to(x1 + xr1, y2)
+        curve_to(x1 + xr2, y2, x1, y2 - yr2, x1, y2 - yr1)
+        line_to(x1, y1 + yr1)
+        curve_to(x1, y1 + yr2, x1 + xr2, y1, x1 + xr1, y1)
+        close_path
+      end
+    end
+  end
+end

data/src/rb_cairo.c

@@ -0,0 +1,90 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2007/03/10 11:54: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"
+
+VALUE rb_mCairo;
+
+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_constants (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);
+
+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 (4), INT2FIX (1), Qnil));
+
+  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,180 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2007/03/06 12:17:34 $
+ *
+ * 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
+
+#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(RUBY_CAIRO_PLATFORM_WIN32) && !defined(RUBY_CAIRO_STATIC_COMPILATION)
+#  ifdef RUBY_CAIRO_COMPILATION
+#    define RUBY_CAIRO_VAR __declspec(dllexport)
+#  else
+#    define RUBY_CAIRO_VAR extern __declspec(dllimport)
+#  endif
+#else
+#  define RUBY_CAIRO_VAR extern
+#endif
+
+RUBY_CAIRO_VAR VALUE rb_mCairo;
+RUBY_CAIRO_VAR VALUE rb_cCairo_Context;
+RUBY_CAIRO_VAR VALUE rb_cCairo_Path;
+RUBY_CAIRO_VAR VALUE rb_cCairo_Matrix;
+RUBY_CAIRO_VAR VALUE rb_cCairo_Pattern;
+RUBY_CAIRO_VAR VALUE rb_cCairo_SolidPattern;
+RUBY_CAIRO_VAR VALUE rb_cCairo_SurfacePattern;
+RUBY_CAIRO_VAR VALUE rb_cCairo_GradientPattern;
+RUBY_CAIRO_VAR VALUE rb_cCairo_LinearPattern;
+RUBY_CAIRO_VAR VALUE rb_cCairo_RadialPattern;
+RUBY_CAIRO_VAR VALUE rb_cCairo_FontFace;
+RUBY_CAIRO_VAR VALUE rb_cCairo_FontExtents;
+RUBY_CAIRO_VAR VALUE rb_cCairo_FontOptions;
+RUBY_CAIRO_VAR VALUE rb_cCairo_ScaledFont;
+RUBY_CAIRO_VAR VALUE rb_cCairo_TextExtents;
+RUBY_CAIRO_VAR VALUE rb_cCairo_Glyph;
+RUBY_CAIRO_VAR VALUE rb_cCairo_Surface;
+
+#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, klass) (rb_cairo_pattern_to_ruby_object(pattern, klass))
+
+#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))
+
+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, VALUE klass);
+
+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);
+
+
+#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
+
+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
+
+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);
+
+#endif