cairo 1.8.3-x86-mingw32

data/ext/cairo/rb_cairo_text_cluster.c

@@ -0,0 +1,151 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-08-16 08:16:40 $
+ *
+ * Copyright 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_TextCluster = Qnil;
+
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+#define _SELF(self)  (RVAL2CRTEXTCLUSTER(self))
+
+cairo_text_cluster_t *
+rb_cairo_text_cluster_from_ruby_object (VALUE obj)
+{
+  cairo_text_cluster_t *cluster;
+  if (!rb_cairo__is_kind_of (obj, rb_cCairo_TextCluster))
+    {
+      rb_raise (rb_eTypeError,
+                "not a cairo cluster: %s", rb_cairo__inspect (obj));
+    }
+  Data_Get_Struct (obj, cairo_text_cluster_t, cluster);
+  return cluster;
+}
+
+static void
+cr_text_cluster_free (void *ptr)
+{
+  if (ptr)
+    {
+      xfree (ptr);
+    }
+}
+
+VALUE
+rb_cairo_text_cluster_to_ruby_object (cairo_text_cluster_t *cluster)
+{
+  if (cluster)
+    {
+      cairo_text_cluster_t *new_cluster;
+
+      new_cluster = ALLOC (cairo_text_cluster_t);
+      *new_cluster = *cluster;
+      return Data_Wrap_Struct (rb_cCairo_TextCluster, NULL,
+                               cr_text_cluster_free, new_cluster);
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+static VALUE
+cr_text_cluster_allocate (VALUE klass)
+{
+  return Data_Wrap_Struct (klass, NULL, cr_text_cluster_free, NULL);
+}
+
+static VALUE
+cr_text_cluster_initialize (VALUE self, VALUE num_bytes, VALUE num_glyphs)
+{
+  cairo_text_cluster_t *cluster;
+
+  cluster = ALLOC (cairo_text_cluster_t);
+  cluster->num_bytes = NUM2INT (num_bytes);
+  cluster->num_glyphs = NUM2INT (num_glyphs);
+
+  DATA_PTR (self) = cluster;
+  return Qnil;
+}
+
+static VALUE
+cr_text_cluster_num_bytes (VALUE self)
+{
+  return INT2NUM (_SELF(self)->num_bytes);
+}
+
+static VALUE
+cr_text_cluster_num_glyphs (VALUE self)
+{
+  return INT2NUM (_SELF(self)->num_glyphs);
+}
+
+static VALUE
+cr_text_cluster_set_num_bytes (VALUE self, VALUE num_bytes)
+{
+  _SELF(self)->num_bytes = NUM2INT (num_bytes);
+  return self;
+}
+
+static VALUE
+cr_text_cluster_set_num_glyphs (VALUE self, VALUE num_glyphs)
+{
+  _SELF(self)->num_glyphs = NUM2INT (num_glyphs);
+  return self;
+}
+
+static VALUE
+cr_text_cluster_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, "num_bytes=");
+  rb_str_concat (ret, rb_inspect (cr_text_cluster_num_bytes (self)));
+  rb_str_cat2 (ret, ", ");
+  rb_str_cat2 (ret, "num_glyphs=");
+  rb_str_concat (ret, rb_inspect (cr_text_cluster_num_glyphs (self)));
+  rb_str_cat2 (ret, ">");
+
+  return ret;
+}
+#endif
+
+void
+Init_cairo_text_cluster (void)
+{
+#if CAIRO_CHECK_VERSION(1, 7, 2)
+  rb_cCairo_TextCluster = rb_define_class_under (rb_mCairo, "TextCluster", rb_cObject);
+
+  rb_define_alloc_func (rb_cCairo_TextCluster, cr_text_cluster_allocate);
+
+  rb_define_method (rb_cCairo_TextCluster, "initialize",
+                    cr_text_cluster_initialize, 2);
+
+  rb_define_method (rb_cCairo_TextCluster, "num_bytes",
+                    cr_text_cluster_num_bytes, 0);
+  rb_define_method (rb_cCairo_TextCluster, "num_glyphs",
+                    cr_text_cluster_num_glyphs, 0);
+  rb_define_method (rb_cCairo_TextCluster, "set_num_bytes",
+                    cr_text_cluster_set_num_bytes, 1);
+  rb_define_method (rb_cCairo_TextCluster, "set_num_glyphs",
+                    cr_text_cluster_set_num_glyphs, 1);
+
+  rb_define_method (rb_cCairo_TextCluster, "to_s", cr_text_cluster_to_s, 0);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_TextCluster);
+#endif
+}

data/ext/cairo/rb_cairo_text_extents.c

@@ -0,0 +1,221 @@
+/* -*- c-file-style: "gnu"; indent-tabs-mode: nil -*- */
+/*
+ * Ruby Cairo Binding
+ *
+ * $Author: kou $
+ * $Date: 2008-08-17 05:41:28 $
+ *
+ * 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_TextExtents;
+
+#define _SELF(self)  (RVAL2CRTEXTEXTENTS(self))
+
+cairo_text_extents_t *
+rb_cairo_text_extents_from_ruby_object (VALUE obj)
+{
+  cairo_text_extents_t *extents;
+  if (!rb_cairo__is_kind_of (obj, rb_cCairo_TextExtents))
+    {
+      rb_raise (rb_eTypeError, "not a cairo text_extents");
+    }
+  Data_Get_Struct (obj, cairo_text_extents_t, extents);
+  return extents;
+}
+
+VALUE
+rb_cairo_text_extents_to_ruby_object (cairo_text_extents_t *extents)
+{
+  if (extents)
+    {
+      cairo_text_extents_t *new_extents = ALLOC (cairo_text_extents_t);
+      *new_extents = *extents;
+      return Data_Wrap_Struct (rb_cCairo_TextExtents, NULL, -1, new_extents);
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+static VALUE
+cr_text_extents_allocate (VALUE klass)
+{
+  return Data_Wrap_Struct (klass, NULL, -1, NULL);
+}
+
+static VALUE
+cr_text_extents_initialize (VALUE self)
+{
+  cairo_text_extents_t *extents;
+
+  extents = ALLOC (cairo_text_extents_t);
+  extents->x_bearing = 0.0;
+  extents->y_bearing = -1.0;
+  extents->width = 0.0;
+  extents->height = 1.0;
+  extents->x_advance = 1.0;
+  extents->y_advance = 0.0;
+
+  DATA_PTR (self) = extents;
+
+  return Qnil;
+}
+
+static VALUE
+cr_text_extents_x_bearing (VALUE self)
+{
+  return rb_float_new (_SELF(self)->x_bearing);
+}
+
+static VALUE
+cr_text_extents_set_x_bearing (VALUE self, VALUE x_bearing)
+{
+  _SELF(self)->x_bearing = NUM2DBL (x_bearing);
+  return Qnil;
+}
+
+static VALUE
+cr_text_extents_y_bearing (VALUE self)
+{
+  return rb_float_new (_SELF(self)->y_bearing);
+}
+
+static VALUE
+cr_text_extents_set_y_bearing (VALUE self, VALUE y_bearing)
+{
+  _SELF(self)->y_bearing = NUM2DBL (y_bearing);
+  return Qnil;
+}
+
+static VALUE
+cr_text_extents_width (VALUE self)
+{
+  return rb_float_new (_SELF(self)->width);
+}
+
+static VALUE
+cr_text_extents_set_width (VALUE self, VALUE width)
+{
+  _SELF(self)->width = NUM2DBL (width);
+  return Qnil;
+}
+
+static VALUE
+cr_text_extents_height (VALUE self)
+{
+  return rb_float_new (_SELF(self)->height);
+}
+
+static VALUE
+cr_text_extents_set_height (VALUE self, VALUE height)
+{
+  _SELF(self)->height = NUM2DBL (height);
+  return Qnil;
+}
+
+static VALUE
+cr_text_extents_x_advance (VALUE self)
+{
+  return rb_float_new (_SELF(self)->x_advance);
+}
+
+static VALUE
+cr_text_extents_set_x_advance (VALUE self, VALUE x_advance)
+{
+  _SELF(self)->x_advance = NUM2DBL (x_advance);
+  return Qnil;
+}
+
+static VALUE
+cr_text_extents_y_advance (VALUE self)
+{
+  return rb_float_new (_SELF(self)->y_advance);
+}
+
+static VALUE
+cr_text_extents_set_y_advance (VALUE self, VALUE y_advance)
+{
+  _SELF(self)->y_advance = NUM2DBL (y_advance);
+  return Qnil;
+}
+
+static VALUE
+cr_text_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, "x_bearing=");
+  rb_str_concat (ret, rb_inspect (cr_text_extents_x_bearing (self)));
+  rb_str_cat2 (ret, ", ");
+  rb_str_cat2 (ret, "y_bearing=");
+  rb_str_concat (ret, rb_inspect (cr_text_extents_y_bearing (self)));
+  rb_str_cat2 (ret, ", ");
+  rb_str_cat2 (ret, "width=");
+  rb_str_concat (ret, rb_inspect (cr_text_extents_width (self)));
+  rb_str_cat2 (ret, ", ");
+  rb_str_cat2 (ret, "height=");
+  rb_str_concat (ret, rb_inspect (cr_text_extents_height (self)));
+  rb_str_cat2 (ret, ", ");
+  rb_str_cat2 (ret, "x_advance=");
+  rb_str_concat (ret, rb_inspect (cr_text_extents_x_advance (self)));
+  rb_str_cat2 (ret, ", ");
+  rb_str_cat2 (ret, "y_advance=");
+  rb_str_concat (ret, rb_inspect (cr_text_extents_y_advance (self)));
+  rb_str_cat2 (ret, ">");
+
+  return ret;
+}
+
+
+void
+Init_cairo_text_extents (void)
+{
+  rb_cCairo_TextExtents =
+    rb_define_class_under (rb_mCairo, "TextExtents", rb_cObject);
+  rb_define_alloc_func (rb_cCairo_TextExtents, cr_text_extents_allocate);
+
+  rb_define_method (rb_cCairo_TextExtents, "initialize",
+                    cr_text_extents_initialize, 0);
+
+  rb_define_method (rb_cCairo_TextExtents, "x_bearing",
+                    cr_text_extents_x_bearing, 0);
+  rb_define_method (rb_cCairo_TextExtents, "set_x_bearing",
+                    cr_text_extents_set_x_bearing, 1);
+  rb_define_method (rb_cCairo_TextExtents, "y_bearing",
+                    cr_text_extents_y_bearing, 0);
+  rb_define_method (rb_cCairo_TextExtents, "set_y_bearing",
+                    cr_text_extents_set_y_bearing, 1);
+  rb_define_method (rb_cCairo_TextExtents, "width",
+                    cr_text_extents_width, 0);
+  rb_define_method (rb_cCairo_TextExtents, "set_width",
+                    cr_text_extents_set_width, 1);
+  rb_define_method (rb_cCairo_TextExtents, "height",
+                    cr_text_extents_height, 0);
+  rb_define_method (rb_cCairo_TextExtents, "set_height",
+                    cr_text_extents_set_height, 1);
+  rb_define_method (rb_cCairo_TextExtents, "x_advance",
+                    cr_text_extents_x_advance, 0);
+  rb_define_method (rb_cCairo_TextExtents, "set_x_advance",
+                    cr_text_extents_set_x_advance, 1);
+  rb_define_method (rb_cCairo_TextExtents, "y_advance",
+                    cr_text_extents_y_advance, 0);
+  rb_define_method (rb_cCairo_TextExtents, "set_y_advance",
+                    cr_text_extents_set_y_advance, 1);
+
+  rb_define_method (rb_cCairo_TextExtents, "to_s",
+                    cr_text_extents_to_s, 0);
+
+  RB_CAIRO_DEF_SETTERS (rb_cCairo_TextExtents);
+}

data/extconf.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require 'mkmf'
+require 'rbconfig'
+require 'fileutils'
+
+base_dir = Pathname(__FILE__).dirname.expand_path
+ext_dir = base_dir + "ext" + "cairo"
+
+ruby = File.join(RbConfig::CONFIG['bindir'],
+                 RbConfig::CONFIG['ruby_install_name'] +
+                 RbConfig::CONFIG["EXEEXT"])
+
+Dir.chdir(ext_dir.to_s) do
+  system(ruby, "extconf.rb")
+end
+
+create_makefile("cairo")
+FileUtils.mv("Makefile", "Makefile.lib")
+
+File.open("Makefile", "w") do |makefile|
+  makefile.puts(<<-EOM)
+all:
+	$(MAKE) $(MAKEFLAGS) -C ext/cairo
+	$(MAKE) $(MAKEFLAGS) -f Makefile.lib
+
+install:
+	$(MAKE) $(MAKEFLAGS) -C ext/cairo install
+	$(MAKE) $(MAKEFLAGS) -f Makefile.lib install
+
+site-install:
+	$(MAKE) $(MAKEFLAGS) -C ext/cairo site-install
+	$(MAKE) $(MAKEFLAGS) -f Makefile.lib site-install
+
+clean:
+	$(MAKE) $(MAKEFLAGS) -C ext/cairo clean
+	$(MAKE) $(MAKEFLAGS) -f Makefile.lib clean
+
+distclean:
+	$(MAKE) $(MAKEFLAGS) -C ext/cairo distclean
+	$(MAKE) $(MAKEFLAGS) -f Makefile.lib distclean
+	@rm -f Makefile.lib
+EOM
+end

data/lib/cairo.rb

@@ -0,0 +1,151 @@
+# vim: filetype=ruby:expandtab:shiftwidth=2:tabstop=8:softtabstop=2 :
+
+if /mingw|mswin|mswin32/ =~ RUBY_PLATFORM
+  require 'pathname'
+  base_dir = Pathname(File.dirname(__FILE__))
+  base_dir = base_dir.parent + "vendor" + "local"
+  if base_dir.exist?
+    base_dir = base_dir.to_s.gsub(/\//, "\\")
+    ENV['PATH'] = %w(bin lib).collect do |dir|
+      "#{base_dir}\\#{dir};"
+    end.join('') + ENV['PATH']
+  else
+    require 'rbconfig'
+    ENV['PATH'] = %w(bin lib).collect do |dir|
+      "#{Config::CONFIG["prefix"]}\\lib\\GTK\\#{dir};"
+    end.join('') + ENV['PATH']
+  end
+end
+
+module Cairo
+  class << self
+    def __add_one_arg_setter(klass)
+      names = klass.instance_methods(false)
+      names.each do |name|
+        if /^set_(.*)/ =~ name and
+            not names.include? "#{$1}=" and
+            klass.instance_method(name).arity == 1
+          klass.module_eval("def #{$1}=(val); set_#{$1}(val); val; end")
+        end
+      end
+    end
+
+    def normalize_const_name(name)
+      name.to_s.upcase.gsub(/[\s\-_.]+/, "_")
+    end
+  end
+end
+
+require 'cairo/color'
+require 'cairo/paper'
+
+begin
+  major, minor, micro, = RUBY_VERSION.split(/\./)
+  require "#{major}.#{minor}/cairo.so"
+rescue LoadError
+  require 'cairo.so'
+end
+require 'cairo/constants'
+
+module Cairo
+  class << self
+    undef __add_one_arg_setter
+
+    def bindings_version
+      major, minor, micro, tag = BINDINGS_VERSION
+      version = [major, minor, micro].join('.')
+      version << "-#{tag}" if tag
+      version
+    end
+
+    def exit_application(exception, status)
+      puts("#{exception.class}: #{exception}")
+      puts(exception.backtrace)
+      exit(status)
+    end
+  end
+
+  class Surface
+    def dup
+      raise NotImplementedError
+    end
+    def clone
+      raise NotImplementedError
+    end
+  end
+
+  if const_defined?("PSLevel")
+    module PSLevel
+      class << self
+        def names
+          list.collect {|version| name(version)}
+        end
+      end
+    end
+  end
+
+  if const_defined?("SVGVersion")
+    module SVGVersion
+      class << self
+        def names
+          list.collect {|version| name(version)}
+        end
+      end
+    end
+  end
+
+  if const_defined?("SVGSurface")
+    class SVGSurface
+      class << self
+        def versions_as_string
+          SVGVersion.names
+        end
+
+        def versions
+          SVGVersion.list
+        end
+
+        def version_to_string(version)
+          SVGVersion.name(version)
+        end
+      end
+    end
+  end
+
+  class Matrix
+    def dup
+      Matrix.new(*to_a)
+    end
+
+    def clone
+      copy = dup
+      copy.freeze if self.frozen?
+      copy
+    end
+
+    def translate(tx, ty); dup.translate!(tx, ty); end
+    def scale(sx, sy); dup.scale!(sx, sy); end
+    def rotate(radians); dup.rotate!(radians); end
+    def invert; dup.invert!; end
+    def multiply(other); dup.multiply!(other); end
+    alias * multiply
+  end
+
+  class FontOptions
+    def merge(other)
+      dup.merge!(other)
+    end
+  end
+end
+
+require 'cairo/point'
+require 'cairo/colors'
+require 'cairo/papers'
+require 'cairo/context'
+require 'cairo/path'
+
+module Cairo
+  if const_defined?(:Win32Surface)
+    WIN32Surface = Win32Surface # For backward compatibility
+  end
+end