cairo 1.8.3-x86-mingw32

data/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/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/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/misc/update-colors.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'scrapi'
+rescue LoadError
+  require 'rubygems'
+  require 'scrapi'
+end
+
+def collect_popular_colors(src=nil)
+  src ||= URI("http://en.wikipedia.org/wiki/List_of_colors")
+
+  row = Scraper.define do
+    process "th > a:first-child", :name => :text
+    process "td:nth-child(3)", :hex_triplet => :text
+    process "td:nth-child(4)", :red => :text
+    process "td:nth-child(5)", :green => :text
+    process "td:nth-child(6)", :blue => :text
+    result :name, :hex_triplet, :red, :green, :blue
+  end
+
+  scraper = Scraper.define do
+    process "table > tr", "rows[]" => row
+    result :rows
+  end
+
+  scraper.scrape(src)
+end
+
+def collect_x11_colors(src=nil)
+  src ||= URI("http://en.wikipedia.org/wiki/X11_color_names")
+
+  row = Scraper.define do
+    process "th", :name => :text
+    process "td:nth-child(2)", :hex_triplet => "@bgcolor"
+    process "td:nth-child(6)", :red => :text
+    process "td:nth-child(7)", :green => :text
+    process "td:nth-child(8)", :blue => :text
+    result :name, :hex_triplet, :red, :green, :blue
+  end
+
+  scraper = Scraper.define do
+    process "table > tr", "rows[]" => row
+    result :rows
+  end
+
+  x11_colors = scraper.scrape(src)
+  x11_colors.collect do |color|
+    if color.name
+      color.name = color.name.gsub(/([a-z]|[A-Z]+)([A-Z])/, "\\1 \\2")
+    end
+    color
+  end
+end
+
+def constanize_color_name(name)
+  names = name.gsub(/é/, "e").upcase.split(/(?:\s*\(|\)\s*)/)
+  names = names.collect {|name| name.gsub(/[ \-]/, "_")}
+  if names[1] and ["WEB", "COLOR_WHEEL", "X11"].include?(names[1])
+    real_names = [names.join("_")]
+    if names == ["ORANGE", "COLOR_WHEEL"]
+      real_names << names.first
+    end
+    names = real_names
+  end
+  names
+end
+
+colors = collect_popular_colors
+x11_colors = collect_x11_colors
+
+top_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+colors_rb = File.join(top_dir, "src", "lib", "cairo", "colors.rb")
+File.open(colors_rb, "w") do |rb|
+  rb.puts <<-HEADER
+require 'cairo/color'
+
+module Cairo
+  module Color
+HEADER
+
+  [
+   [colors, nil],
+   [x11_colors, "X11"]
+  ].each do |colors, mod|
+    indent = "  " * 2
+    if mod
+      rb.puts("#{indent}module #{mod}")
+      indent << "  "
+    end
+    colors.each do |color|
+      if color.name and color.hex_triplet and
+          color.red and color.green and color.blue
+        begin
+          names = constanize_color_name(color.name)
+
+          hexes = color.hex_triplet.scan(/[\da-f]{2,2}/i)
+          red_hex, green_hex, blue_hex = hexes.collect {|hex| hex.hex}
+
+          red = Integer(color.red)
+          green = Integer(color.green)
+          blue = Integer(color.blue)
+
+          if [red_hex, green_hex, blue_hex] != [red, green, blue]
+            warning_message = "Hex triplet(#{color.hex_triplet}) of "
+            warning_message << "#{color.name} is difference from RGB"
+            warning_message << "(#{red}, #{green}, #{blue}). "
+            if ["Alice Blue", "Old Rose"].include?(color.name)
+              warning_message << "Use hex triplet value."
+              red, green, blue = red_hex, green_hex, blue_hex
+            else
+              warning_message << "Use RGB value."
+            end
+            puts warning_message
+          end
+
+          r, g, b = [red, green, blue].collect {|v| v / 255.0}
+
+          rb.puts("#{indent}# #{color.name}: #{color.hex_triplet}")
+          name, *alias_names = names
+          rb.puts("#{indent}#{name} = RGB.new(#{r}, #{g}, #{b})")
+          alias_names.each do |alias_name|
+              rb.puts("#{indent}#{alias_name} = #{name}")
+            end
+        rescue ArgumentError
+          next
+        end
+      end
+    end
+
+    if mod
+      indent = indent[0..-3]
+      rb.puts("#{indent}end")
+      rb.puts("#{indent}include #{mod}")
+      rb.puts
+    end
+  end
+
+  rb.puts <<-FOOTER
+  end
+end
+FOOTER
+end

data/pkg-config.rb

@@ -0,0 +1,313 @@
+# Copyright 2008-2009 Kouhei Sutou <kou@cozmixng.org>
+# This file is made available under the same terms as Ruby.
+
+require "rbconfig"
+
+require 'mkmf'
+require 'shellwords'
+require 'English'
+require 'pathname'
+
+class PackageConfig
+  attr_accessor :msvc_syntax
+  def initialize(name, path=nil, msvc_syntax=false)
+    @name = name
+    @path = path || ENV["PKG_CONFIG_PATH"]
+    @path = [@path, guess_default_path].compact.join(separator)
+    @msvc_syntax = msvc_syntax
+    @variables = @declarations = nil
+    override_variables = with_config("override-variables", "")
+    @override_variables = parse_override_variables(override_variables)
+  end
+
+  def exist?
+    not pc.nil?
+  end
+
+  def requires
+    parse_requires(declaration("Requires"))
+  end
+
+  def requires_private
+    parse_requires(declaration("Requires.private"))
+  end
+
+  def cflags
+    path_flags, other_flags = collect_cflags
+    (other_flags + path_flags).join(" ")
+  end
+
+  def cflags_only_I
+    collect_cflags[0].join(" ")
+  end
+
+  def libs
+    path_flags, other_flags = collect_libs
+    (other_flags + path_flags).join(" ")
+  end
+
+  def libs_only_l
+    collect_libs[1].find_all do |arg|
+      if @msvc_syntax
+        /\.lib\z/ =~ arg
+      else
+        /\A-l/ =~ arg
+      end
+    end.join(" ")
+  end
+
+  def version
+    declaration("Version")
+  end
+
+  def variable(name)
+    parse_pc if @variables.nil?
+    expand_value(@override_variables[name] || @variables[name])
+  end
+
+  def declaration(name)
+    parse_pc if @declarations.nil?
+    expand_value(@declarations[name])
+  end
+
+  private
+  def pc
+    @path.split(separator).each do |path|
+      pc_name = File.join(path, "#{@name}.pc")
+      return pc_name if File.exist?(pc_name)
+    end
+    return nil
+  end
+
+  def separator
+    File.expand_path(".").index(":") ? ";" : ":"
+  end
+
+  def collect_cflags
+    all_cflags = (requires_private + requires.reverse).collect do |package|
+      self.class.new(package, @path, @msvc_syntax).cflags
+    end
+    all_cflags = [declaration("Cflags")] + all_cflags
+    all_cflags = all_cflags.join(" ").gsub(/-I /, '-I').split.uniq
+    path_flags, other_flags = all_cflags.partition {|flag| /\A-I/ =~ flag}
+    path_flags = path_flags.reject do |flag|
+      flag == "-I/usr/include"
+    end
+    if @msvc_syntax
+      path_flags = path_flags.collect do |flag|
+        flag.gsub(/\A-I/, "/I")
+      end
+    end
+    [path_flags, other_flags]
+  end
+
+  def collect_libs
+    all_libs = requires.collect do |package|
+      self.class.new(package, @path, @msvc_syntax).libs
+    end
+    all_libs = [declaration("Libs")] + all_libs
+    all_libs = all_libs.join(" ").gsub(/-([Ll]) /, '\1').split.uniq
+    path_flags, other_flags = all_libs.partition {|flag| /\A-L/ =~ flag}
+    path_flags = path_flags.reject do |flag|
+      /\A-L\/usr\/lib(?:64)?\z/ =~ flag
+    end
+    if @msvc_syntax
+      path_flags = path_flags.collect do |flag|
+        flag.gsub(/\A-L/, "/libpath:")
+      end
+      other_flags = other_flags.collect do |flag|
+        if /\A-l/ =~ flag
+          "#{$POSTMATCH}.lib"
+        else
+          flag
+        end
+      end
+    end
+    [path_flags, other_flags]
+  end
+
+  IDENTIFIER_RE = /[\w\d_.]+/
+  def parse_pc
+    raise ".pc for #{@name} doesn't exist." unless exist?
+    @variables = {}
+    @declarations = {}
+    File.open(pc) do |input|
+      input.each_line do |line|
+        line = line.gsub(/#.*/, '').strip
+        next if line.empty?
+        case line
+        when /^(#{IDENTIFIER_RE})=/
+          @variables[$1] = $POSTMATCH.strip
+        when /^(#{IDENTIFIER_RE}):/
+          @declarations[$1] = $POSTMATCH.strip
+        end
+      end
+    end
+  end
+
+  def parse_requires(requires)
+    return [] if requires.nil?
+    requires_without_version = requires.gsub(/[<>]?=\s*[\d.]+\s*/, '')
+    requires_without_version.split(/[,\s]+/)
+  end
+
+  def parse_override_variables(override_variables)
+    variables = {}
+    override_variables.split(",").each do |variable|
+      name, value = variable.split("=", 2)
+      variables[name] = value
+    end
+    variables
+  end
+
+  def expand_value(value)
+    return nil if value.nil?
+    value.gsub(/\$\{(#{IDENTIFIER_RE})\}/) do
+      variable($1)
+    end
+  end
+
+  def search_pkg_config_from_path(pkg_config)
+    (ENV["PATH"] || "").split(separator).each do |path|
+      try_pkg_config = Pathname(path) + pkg_config
+      return try_pkg_config if try_pkg_config.exist?
+    end
+    nil
+  end
+
+  def search_pkg_config_by_dln_find_exe(pkg_config)
+    begin
+      require "dl/import"
+    rescue LoadError
+      return nil
+    end
+    dln = Module.new
+    dln.module_eval do
+      if DL.const_defined?(:Importer)
+        extend DL::Importer
+      else
+        extend DL::Importable
+      end
+      begin
+        dlload RbConfig::CONFIG["LIBRUBY"]
+      rescue RuntimeError
+        return nil if $!.message == "unknown error"
+        return nil if /: image not found\z/ =~ $!.message
+        raise
+      rescue DL::DLError
+        return nil
+      end
+      extern "const char *dln_find_exe(const char *, const char *)"
+    end
+    path = dln.dln_find_exe(pkg_config.to_s, nil)
+    if path.size.zero?
+      nil
+    else
+      Pathname(path.to_s)
+    end
+  end
+
+  def guess_default_path
+    default_path = ["/usr/local/lib64/pkgconfig",
+                    "/usr/local/lib/pkgconfig",
+                    "/usr/local/libdata/pkgconfig",
+                    "/opt/local/lib/pkgconfig",
+                    "/usr/lib64/pkgconfig",
+                    "/usr/lib/pkgconfig",
+                    "/usr/X11/lib/pkgconfig/",
+                    "/usr/share/pkgconfig"].join(separator)
+    libdir = ENV["PKG_CONFIG_LIBDIR"]
+    default_path = [libdir, default_path].join(separator) if libdir
+
+    pkg_config = with_config("pkg-config", ENV["PKG_CONFIG"] || "pkg-config")
+    pkg_config = Pathname.new(pkg_config)
+    unless pkg_config.absolute?
+      found_pkg_config = search_pkg_config_from_path(pkg_config)
+      pkg_config = found_pkg_config if found_pkg_config
+    end
+    unless pkg_config.absolute?
+      found_pkg_config = search_pkg_config_by_dln_find_exe(pkg_config)
+      pkg_config = found_pkg_config if found_pkg_config
+    end
+
+    return default_path unless pkg_config.absolute?
+    [(pkg_config.parent.parent + "lib" + "pkgconfig").to_s,
+     (pkg_config.parent.parent + "libdata" + "pkgconfig").to_s,
+     default_path].join(separator)
+  end
+end
+
+module PKGConfig
+  module_function
+  def msvc?
+    /mswin32/.match(RUBY_PLATFORM) and /^cl\b/.match(Config::CONFIG['CC'])
+  end
+
+  def package_config(package)
+    PackageConfig.new(package, nil, msvc?)
+  end
+
+  def exist?(pkg)
+    package_config(pkg).exist?
+  end
+
+  def libs(pkg)
+    package_config(pkg).libs
+  end
+
+  def libs_only_l(pkg)
+    package_config(pkg).libs_only_l
+  end
+
+  def cflags(pkg)
+    package_config(pkg).cflags
+  end
+
+  def cflags_only_I(pkg)
+    package_config(pkg).cflags_only_I
+  end
+
+  def modversion(pkg)
+    package_config(pkg).version
+  end
+
+  def check_version?(pkg, major = 0, minor = 0, micro = 0)
+    return false unless exist?(pkg)
+    ver = modversion(pkg).split(".").collect{|item| item.to_i}
+    (0..2).each {|i| ver[i] = 0 unless ver[i]}
+
+    (ver[0] > major ||
+     (ver[0] == major && ver[1] > minor) ||
+     (ver[0] == major && ver[1] == minor &&
+      ver[2] >= micro))
+  end
+
+  def have_package(pkg, major = nil, minor = 0, micro = 0)
+    if major.nil?
+      STDOUT.print("checking for #{pkg}... ")
+    else
+      STDOUT.print("checking for #{pkg} version (>= #{major}.#{minor}.#{micro})... ")
+    end
+    major ||= 0
+    STDOUT.flush
+    if check_version?(pkg, major, minor, micro)
+      STDOUT.print "yes\n"
+      libraries = libs_only_l(pkg)
+      dldflags = libs(pkg)
+      dldflags = (Shellwords.shellwords(dldflags) -
+                  Shellwords.shellwords(libraries))
+      dldflags = dldflags.map {|s| /\s/ =~ s ? "\"#{s}\"" : s }.join(' ')
+      $libs   += ' ' + libraries
+      if /mswin32/ =~ RUBY_PLATFORM
+	$DLDFLAGS += ' ' + dldflags
+      else
+	$LDFLAGS += ' ' + dldflags
+      end
+      $CFLAGS += ' ' + cflags(pkg)
+      true
+    else
+      STDOUT.print "no\n"
+      false
+    end
+  end
+end