cairo 1.6.1-x86-mswin32

data/extconf.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+# vim: filetype=ruby:expandtab:shiftwidth=2:tabstop=8:softtabstop=2 :
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'English'
+require 'mkmf'
+require 'pkg-config'
+require 'fileutils'
+
+# from mkmf-gnome2.rb
+STDOUT.print("checking for GCC... ")
+STDOUT.flush
+if macro_defined?("__GNUC__", "")
+  STDOUT.print "yes\n"
+  $CFLAGS += ' -Wall'
+  $cc_is_gcc = true
+else
+  STDOUT.print "no\n"
+  $cc_is_gcc = false
+end
+
+def check_win32
+  checking_for("Win32 OS") do
+    win32_os = /cygwin|mingw|mswin32/ =~ RUBY_PLATFORM
+    if win32_os
+      $defs << "-DRUBY_CAIRO_PLATFORM_WIN32"
+      if $cc_is_gcc
+        if /^2\./ =~ `#{Config::CONFIG['CC']} -dumpversion`.chomp
+          $CFLAGS += ' -fnative-struct'
+        else
+          $CFLAGS += ' -mms-bitfields'
+        end
+      end
+    end
+    win32_os
+  end
+end
+
+def set_output_lib(target_name, directory=nil)
+  case RUBY_PLATFORM
+  when /cygwin|mingw/
+    filename = File.join(*([directory, "libruby-#{target_name}.a"].compact))
+    if RUBY_VERSION > "1.8.0"
+      $DLDFLAGS << ",--out-implib=#{filename}"
+    elsif RUBY_VERSION > "1.8"
+      $DLDFLAGS.gsub!(/ -Wl,--out-implib=[^ ]+/, '')
+      $DLDFLAGS << " -Wl,--out-implib=#{filename}"
+    else
+      $DLDFLAGS.gsub!(/ --output-lib\s+[^ ]+/, '')
+      $DLDFLAGS << " --output-lib #{filename}"
+    end
+    $cleanfiles << filename
+  when /mswin32/
+    $DLDFLAGS.gsub!(/ --output-lib\s+[^ ]+/, '')
+    $DLDFLAGS.gsub!(/ \/IMPLIB:[^ ]+/, '')
+    $DLDFLAGS << " /IMPLIB:$(IMPLIB)"
+  when /darwin/
+    if have_macro("CAIRO_HAS_QUARTZ_SURFACE", ["cairo.h"])
+      checking_for("RubyCocoa") do
+        begin
+          require 'osx/cocoa'
+          $defs << "-DHAVE_RUBY_COCOA"
+          $DLDFLAGS << " -Wl,-framework,RubyCocoa"
+          true
+        rescue LoadError
+          false
+        end
+      end
+    end
+  end
+end
+
+
+pkg = "cairo"
+modname = "cairo"
+ext_dir_name = "src"
+srcdir = File.join(File.expand_path(File.dirname(__FILE__)), ext_dir_name)
+major, minor, micro = 1, 2, 0
+
+PKGConfig.have_package(pkg, major, minor, micro) or exit 1
+
+have_func("rb_errinfo")
+
+check_win32
+target_name = File.basename(modname)
+set_output_lib(target_name, ext_dir_name)
+$defs << "-DRB_CAIRO_COMPILATION"
+create_makefile(modname, srcdir)
+
+wine = with_config("wine", false)
+
+makefile = File.read("Makefile")
+File.open("Makefile", "w") do |f|
+  objs = []
+  co = nil
+  makefile.each_line do |line|
+    if wine
+      line.gsub!(/\s+gcc\b/, " i586-mingw32msvc-gcc")
+      line.gsub!(/C:/, "$(HOME)/.wine/drive_c")
+      line.gsub!(/Z:/, "")
+    end
+
+    case line
+    when /^DLLIB\s*=\s*/
+      dllib = $POSTMATCH
+      f.puts("DLLIB = #{ext_dir_name}/#{dllib}")
+      f.puts("IMPLIB = #{ext_dir_name}/libruby-#{dllib.gsub(/\..+?$/, '.lib')}")
+    when /^(SRCS)\s*=\s*/
+      name = $1
+      vars = $POSTMATCH.split.collect {|var| "$(srcdir)/#{var}"}.join(" ")
+      f.puts("#{name} = #{vars}")
+    when /^(OBJS|CLEANLIBS|CLEANOBJS)\s*=\s*/
+      name = $1
+      vars = $POSTMATCH.split.collect {|var| "#{ext_dir_name}/#{var}"}
+      objs = vars if name == "OBJS"
+      vars = vars.join(" ")
+      f.puts("#{name} = #{vars}")
+    when /^LDSHARED\s*=/
+      def_file = "#{ext_dir_name}/#{target_name}.def"
+      line.gsub!(/\b-shared\b/, "-shared #{def_file}") if wine
+      f.puts(line)
+    when /^\t\$\(CC\)/
+      if PKGConfig.msvc?
+        output_option = "-Fo"
+      else
+        output_option = "-o"
+      end
+      unless /#{Regexp.escape(output_option)}/ =~ line
+        line = "#{line.chomp} #{output_option}$@"
+      end
+      co = line
+      f.puts(line)
+    else
+      f.puts(line)
+    end
+  end
+
+  if co and !objs.empty?
+    f.puts
+    if PKGConfig.msvc?
+      f.puts "{$(srcdir)}.c{#{ext_dir_name}}.obj:"
+      f.puts co
+    else
+      objs.each do |obj|
+        f.puts "#{obj}: $(srcdir)/#{File.basename(obj).sub(/\..+?$/, '.c')}"
+        f.puts co
+      end
+    end
+  end
+end
+
+FileUtils.mkdir_p(ext_dir_name)

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,278 @@
+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 guess_default_path
+    default_path = "/usr/local/lib/pkgconfig:/usr/lib/pkgconfig"
+    libdir = ENV["PKG_CONFIG_LIBDIR"]
+    default_path = "#{libdir}:#{default_path}" if libdir
+    pkg_config = with_config("pkg-config", ENV["PKG_CONFIG"] || "pkg-config")
+    pkg_config = Pathname.new(pkg_config)
+    unless pkg_config.absolute?
+      begin
+        require "dl/import"
+      rescue LoadError
+        return default_path
+      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 default_path if $!.message == "unknown error"
+          raise
+        rescue DL::DLError
+          return default_path
+        end
+        extern "const char *dln_find_exe(const char *, const char *)"
+      end
+      pkg_config = dln.dln_find_exe(pkg_config.to_s, nil)
+      return default_path if pkg_config.nil?
+      pkg_config = Pathname.new(pkg_config)
+    end
+    [(pkg_config.parent.parent + "lib" + "pkgconfig").to_s,
+     default_path].join(":")
+  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