cairo 1.5.1 → 1.6.0

data/extconf.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # vim: filetype=ruby:expandtab:shiftwidth=2:tabstop=8:softtabstop=2 :
 
-$LOAD_PATH.unshift(".")
+$LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'English'
 require 'mkmf'
@@ -37,27 +37,36 @@ def check_win32
   end
 end
 
-def set_output_lib(target_name)
+def set_output_lib(target_name, directory=nil)
   case RUBY_PLATFORM
   when /cygwin|mingw/
-    filename = "libruby-#{target_name}.a"
+    filename = File.join(*([directory, "libruby-#{target_name}.a"].compact))
     if RUBY_VERSION > "1.8.0"
-      $DLDFLAGS << ",--out-implib=#{filename}" if filename
+      $DLDFLAGS << ",--out-implib=#{filename}"
     elsif RUBY_VERSION > "1.8"
       $DLDFLAGS.gsub!(/ -Wl,--out-implib=[^ ]+/, '')
-      $DLDFLAGS << " -Wl,--out-implib=#{filename}" if filename
+      $DLDFLAGS << " -Wl,--out-implib=#{filename}"
     else
       $DLDFLAGS.gsub!(/ --output-lib\s+[^ ]+/, '')
-      $DLDFLAGS << " --output-lib #{filename}" if filename
+      $DLDFLAGS << " --output-lib #{filename}"
     end
+    $cleanfiles << filename
   when /mswin32/
-    filename = "libruby-#{target_name}.lib"
     $DLDFLAGS.gsub!(/ --output-lib\s+[^ ]+/, '')
     $DLDFLAGS.gsub!(/ \/IMPLIB:[^ ]+/, '')
-    $DLDFLAGS << " /IMPLIB:#{filename}" if filename
+    $DLDFLAGS << " /IMPLIB:$(IMPLIB)"
   when /darwin/
     if have_macro("CAIRO_HAS_QUARTZ_SURFACE", ["cairo.h"])
-      $DLDFLAGS << " -Wl,-framework,RubyCocoa"
+      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
@@ -74,18 +83,29 @@ PKGConfig.have_package(pkg, major, minor, micro) or exit 1
 have_func("rb_errinfo")
 
 check_win32
-set_output_lib(File.basename(modname))
-$defs << "-DRUBY_CAIRO_COMPILATION"
+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!(/\bgcc\b/, "i586-mingw32msvc-gcc")
+      line.gsub!(/C:/, "$(HOME)/.wine/drive_c")
+      line.gsub!(/Z:/, "")
+    end
+
     case line
-    when /^TARGET\s*=\s*/
-      f.print("TARGET = #{ext_dir_name}/#{$POSTMATCH}")
+    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(" ")
@@ -96,20 +116,36 @@ File.open("Makefile", "w") do |f|
       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\)/
-      line = "#{line.chomp} -o $@" if /-o/ !~ line
+      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.print(line)
+      f.puts(line)
     end
   end
 
   if co and !objs.empty?
     f.puts
-    objs.each do |obj|
-      f.puts "#{obj}: $(srcdir)/#{File.basename(obj).sub(/.o$/, '.c')}"
+    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

data/pkg-config.rb

@@ -1,89 +1,232 @@
-#
-# pkg-config.rb
-#
-# Wrapper of pkg-config tool.
-#
-# Copyright(C) 2003-2005 Ruby-GNOME2 Project.
-#
-# This program is licenced under the same
-# license of Ruby-GNOME2.
-#
+require "rbconfig"
 
 require 'mkmf'
 require 'shellwords'
+require 'English'
+require 'pathname'
 
-module PKGConfig
-  @@cmd = with_config('pkg-config', ENV["PKG_CONFIG"] ||  'pkg-config')
-  if /mswin32/ =~ RUBY_PLATFORM and /^cl\b/ =~ Config::CONFIG['CC']
-    @@cmd += ' --msvc-syntax'
+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
 
-  @@list = {}
-  `#{@@cmd} --list-all`.chomp.split(/\n/).each{|v| 
-    pkg, name, desc = /(\S+?)\s+(.*?)\s-\s(.*)/.match(v).to_a[1..3]
-    @@list[pkg] = [name, desc]
-  }
+  def exist?
+    not pc.nil?
+  end
 
-  module_function
-  def exist?(pkg)
-    system("#{@@cmd} --exists #{pkg}")
+  def requires
+    parse_requires(declaration("Requires"))
   end
 
-  def libs(pkg)
-    `#{@@cmd} --libs #{pkg}`.chomp
+  def requires_private
+    parse_requires(declaration("Requires.private"))
   end
 
-  def libs_only_L(pkg)
-    `#{@@cmd} --libs-only-L #{pkg}`.chomp
+  def cflags
+    path_flags, other_flags = collect_cflags
+    (other_flags + path_flags).join(" ")
   end
 
-  def libs_only_l(pkg)
-    `#{@@cmd} --libs-only-l #{pkg}`.chomp
+  def cflags_only_I
+    collect_cflags[0].join(" ")
   end
 
-  def cflags(pkg)
-    `#{@@cmd} --cflags #{pkg}`.chomp
+  def libs
+    path_flags, other_flags = collect_libs
+    (other_flags + path_flags).join(" ")
   end
 
-  def cflags_only_I(pkg)
-    `#{@@cmd} --cflags-only-I #{pkg}`.chomp
+  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 cflags_only_other(pkg)
-    `#{@@cmd} --cflags-only-other #{pkg}`.chomp
+  def version
+    declaration("Version")
   end
 
-  def variable(pkg, var)
-    `#{@@cmd} --variable=#{var} #{pkg}`.chomp
+  def variable(name)
+    parse_pc if @variables.nil?
+    expand_value(@override_variables[name] || @variables[name])
   end
 
-  def modversion(pkg)
-    `#{@@cmd} --modversion #{pkg}`.chomp
+  def declaration(name)
+    parse_pc if @declarations.nil?
+    expand_value(@declarations[name])
   end
 
-  def version
-    `#{@@cmd} --version`.chomp
+  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"
+    pkg_config = with_config("pkg-config", ENV["PKG_CONFIG"] || "pkg-config")
+    pkg_config = Pathname.new(pkg_config)
+    unless pkg_config.absolute?
+      require "dl/import"
+      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
+  end
+end
+
+module PKGConfig
+  module_function
+  def msvc?
+    /mswin32/.match(RUBY_PLATFORM) and /^cl\b/.match(Config::CONFIG['CC'])
   end
 
-  def list_all
-    # Returns [pkg, name, description]
-    @@list.keys.collect{|key| [key] + @@list[key]}.sort
+  def package_config(package)
+    PackageConfig.new(package, nil, msvc?)
   end
 
-  def name(pkg)
-    @@list[pkg][0]
+  def exist?(pkg)
+    package_config(pkg).exist?
   end
 
-  def description(pkg)
-    @@list[pkg][1]
+  def libs(pkg)
+    package_config(pkg).libs
   end
 
-  def provides(pkg)
-    `#{@@cmd} --print-provides #{pkg}`.chomp
+  def libs_only_l(pkg)
+    package_config(pkg).libs_only_l
   end
 
-  def requires(pkg)
-    `#{@@cmd} --print-requires #{pkg}`.chomp.gsub("\n", ", ") 
+  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)
@@ -109,7 +252,9 @@ module PKGConfig
       STDOUT.print "yes\n"
       libraries = libs_only_l(pkg)
       dldflags = libs(pkg)
-      dldflags = (Shellwords.shellwords(dldflags) - Shellwords.shellwords(libraries)).map{|s| /\s/ =~ s ? "\"#{s}\"" : s }.join(' ')
+      dldflags = (Shellwords.shellwords(dldflags) -
+                  Shellwords.shellwords(libraries))
+      dldflags = dldflags.map {|s| /\s/ =~ s ? "\"#{s}\"" : s }.join(' ')
       $libs   += ' ' + libraries
       if /mswin32/ =~ RUBY_PLATFORM
 	$DLDFLAGS += ' ' + dldflags

data/samples/pac.rb

@@ -11,14 +11,13 @@ $LOAD_PATH.unshift File.join(src, "lib")
 
 require "cairo"
 
-WIDTH = 841.889763779528
-HEIGHT = 595.275590551181
+paper = Cairo::Paper::A4_LANDSCAPE
 
 def pac(surface)
   cr = Cairo::Context.new(surface)
 
   cr.set_source_color(:black)
-  cr.rectangle(0, 0, WIDTH, HEIGHT).fill
+  cr.paint
 
   # Wall
   cr.set_source_color(:magenta)
@@ -79,15 +78,15 @@ def pac(surface)
   cr.show_page
 end
 
-Cairo::ImageSurface.new(WIDTH, HEIGHT) do |surface|
+Cairo::ImageSurface.new(*paper.size("pt")) do |surface|
   cr = pac(surface)
   cr.target.write_to_png("pac.png")
 end
 
-def scalable_surface_output(surface_class_name, suffix)
+def scalable_surface_output(surface_class_name, paper, suffix)
   if Cairo.const_defined?(surface_class_name)
     surface_class = Cairo.const_get(surface_class_name)
-    surface_class.new("pac.#{suffix}", WIDTH, HEIGHT) do |surface|
+    surface_class.new("pac.#{suffix}", paper) do |surface|
       pac(surface)
     end
   else
@@ -95,6 +94,6 @@ def scalable_surface_output(surface_class_name, suffix)
   end
 end
 
-scalable_surface_output("PSSurface", "ps")
-scalable_surface_output("PDFSurface", "pdf")
-scalable_surface_output("SVGSurface", "svg")
+scalable_surface_output("PSSurface", paper, "ps")
+scalable_surface_output("PDFSurface", paper, "pdf")
+scalable_surface_output("SVGSurface", paper, "svg")