cairo 1.14.0-x64-mingw32

data/samples/scalable.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+top = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+$LOAD_PATH.unshift File.join(top, "ext", "cairo")
+$LOAD_PATH.unshift File.join(top, "lib")
+
+require 'cairo'
+require 'stringio'
+
+def render(output, surface_class)
+  surface_class.new(output, 200, 200) do |surface|
+    cr = Cairo::Context.new(surface)
+
+    # fill background with white
+    cr.set_source_color("#fffc")
+    cr.paint
+
+    # create shape
+    cr.move_to(50, 50)
+    cr.curve_to(100, 25, 100, 75, 150, 50)
+    cr.line_to(150, 150)
+    cr.line_to(50, 150)
+    cr.close_path
+
+    cr.set_source_color(:black)
+    cr.fill_preserve
+    cr.set_source_color(:red)
+    cr.set_line_join(Cairo::LINE_JOIN_MITER)
+    cr.set_line_width(4)
+    cr.stroke
+
+    cr.show_page
+    surface.finish
+  end
+end
+
+def output(surface_class_name, suffix)
+  if Cairo.const_defined?(surface_class_name)
+    surface_class = Cairo.const_get(surface_class_name)
+    render("test.#{suffix}", surface_class)
+
+    output = StringIO.new
+    render(output, surface_class)
+    output.rewind
+    File.open("test2.#{suffix}", "wb") do |f|
+      f.print(output.read)
+    end
+  else
+    puts("#{surface_class_name} isn't supported.")
+  end
+end
+
+output("PSSurface", "ps")
+output("PDFSurface", "pdf")
+output("SVGSurface", "svg")

data/samples/text-on-path.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+top = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+$LOAD_PATH.unshift File.join(top, "ext", "cairo")
+$LOAD_PATH.unshift File.join(top, "lib")
+
+require 'cairo'
+require 'pango'
+
+def render_background(cr)
+  cr.set_source_color(:white)
+  cr.paint
+end
+
+def make_layout(cr, text)
+  layout = cr.create_pango_layout
+  layout.text = text
+  layout.font_description = Pango::FontDescription.new("Serif 36")
+  cr.update_pango_layout(layout)
+  layout
+end
+
+def render(surface)
+  text = "It was a dream... Oh Just a dream..."
+
+  cr = Cairo::Context.new(surface)
+
+  render_background(cr)
+
+  cr.set_source_color(:red)
+  cr.move_to(25, 350)
+  cr.line_to(150, 375)
+  cr.curve_to(275, 400, 450, 350, 450, 200)
+  cr.curve_to(450, 0, 300, 150, 50, 50)
+  cr.stroke_preserve
+  path = cr.copy_path_flat
+
+  cr.line_width = 1
+  cr.new_path
+  layout = make_layout(cr, text)
+  cr.pango_layout_line_path(layout.get_line(0))
+  cr.map_path_onto(path)
+
+  cr.set_source_rgba(0.3, 0.3, 1.0, 0.3)
+  cr.fill_preserve
+  cr.set_source_rgba(0.1, 0.1, 0.1)
+  cr.stroke
+
+  cr.show_page
+end
+
+def output
+  Cairo::ImageSurface.new(500, 500) do |surface|
+    render(surface)
+    surface.write_to_png("text-on-path.png")
+  end
+end
+
+output

data/samples/text2.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+top = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+$LOAD_PATH.unshift File.join(top, "ext", "cairo")
+$LOAD_PATH.unshift File.join(top, "lib")
+
+require 'optparse'
+require 'ostruct'
+
+require 'cairo'
+require 'pango'
+
+def parse(args=ARGV)
+  options = OpenStruct.new
+  options.width = 595.275590551181.round
+  options.height = 841.889763779528.round
+  options.font_description = "Monospace 12"
+  options.fade_out = false
+
+  opts = OptionParser.new do |opts|
+    opts.on("--width=WIDTH", Integer, "paper width") do |width|
+      options.width = width
+    end
+    opts.on("--height=HEIGHT", Integer, "paper height") do |height|
+      options.height = height
+    end
+    opts.on("--font-description=DESCRIPTION",
+            "font description (e.g. 'Monospace 14')") do |desc|
+      options.font_description = desc
+    end
+    opts.on("--[no-]fade-out",
+            "fade-out one-third of page") do |fade_out|
+      options.fade_out = fade_out
+    end
+  end
+
+  opts.parse!(args)
+
+  options
+end
+
+def render_background(cr)
+  cr.set_source_color(:white)
+  cr.paint
+end
+
+def make_layout(cr, text, width, font_description)
+  layout = cr.create_pango_layout
+  layout.text = text
+  layout.width = width * Pango::SCALE
+  layout.font_description = Pango::FontDescription.new(font_description)
+  cr.update_pango_layout(layout)
+  layout
+end
+
+def setup_fade_out(cr, width)
+  fade_out = Cairo::LinearPattern.new(0, 0, width, 0)
+  fade_out.add_color_stop(0, "#000f")
+  fade_out.add_color_stop(0.66, "#000f")
+  fade_out.add_color_stop(1, "#0000")
+
+  cr.set_source(fade_out)
+end
+
+def render_layout(cr, layout, margin_left, margin_top, body_height)
+  x = margin_left
+  y = margin_top
+  limit_y = margin_top + body_height
+
+  iter = layout.iter
+  prev_baseline = iter.baseline / Pango::SCALE
+  begin
+    line = iter.line
+    ink_rect, logical_rect = iter.line_extents
+    y_begin, y_end = iter.line_yrange
+    if limit_y < (y + y_end / Pango::SCALE)
+      cr.show_page
+      y = margin_top - prev_baseline
+    end
+    baseline = iter.baseline / Pango::SCALE
+    cr.move_to(x + logical_rect.x / Pango::SCALE, y + baseline)
+    cr.show_pango_layout_line(line)
+    prev_baseline = baseline
+  end while iter.next_line!
+end
+
+def render(options, output, surface_class)
+  text = options.text
+  width = options.width
+  height = options.height
+  font_description = options.font_description
+  fade_out = options.fade_out
+
+  margin_left = (width * 0.05).ceil
+  margin_right = (width * 0.05).ceil
+  margin_top = (height * 0.05).ceil
+  margin_bottom = (height * 0.05).ceil
+  body_width = width - margin_left - margin_right
+  body_height = height - margin_top - margin_bottom
+
+  surface_class.new(output, width, height) do |surface|
+    cr = Cairo::Context.new(surface)
+
+    render_background(cr)
+    layout = make_layout(cr, text, body_width, font_description)
+    if fade_out
+      setup_fade_out(cr, body_width)
+    else
+      cr.set_source_color(:black)
+    end
+    render_layout(cr, layout, margin_left, margin_top, body_height)
+
+    cr.show_page
+  end
+end
+
+def output(options, surface_class_name, suffix)
+  if Cairo.const_defined?(surface_class_name)
+    surface_class = Cairo.const_get(surface_class_name)
+    render(options, "text2.#{suffix}", surface_class)
+  else
+    puts("#{surface_class_name} isn't supported.")
+  end
+end
+
+options = parse
+options.text = ARGF.read
+output(options, "PSSurface", "ps")
+output(options, "PDFSurface", "pdf")
+output(options, "SVGSurface", "svg")

data/test/cairo-test-utils.rb

@@ -0,0 +1,44 @@
+require 'cairo'
+require 'stringio'
+require 'test/unit/notify'
+
+module CairoTestUtils
+  private
+  def only_cairo_version(major, minor, micro=nil)
+    unless Cairo.satisfied_version?(major, minor, micro)
+      omit("Require cairo >= #{major}.#{minor}.#{micro}")
+    end
+  end
+
+  def only_win32
+    omit("Only for Win32 platform") unless win32
+  end
+
+  def win32?
+    /cygwin|mingw|mswin32|bccwin32/.match(RUBY_PLATFORM) ? true : false
+  end
+
+  def quartz?
+    Cairo::FontFace.quartz_supported?
+  end
+
+  def only_device(name)
+    only_cairo_version(1, 10)
+
+    unless Cairo::Device.supported?(name)
+      omit("Only for #{name} device available")
+    end
+  end
+
+  def only_surface(name)
+    unless Cairo::Surface.supported?(name)
+      omit("Only for #{name} device available")
+    end
+  end
+
+  def only_pattern(name)
+    unless Cairo::Pattern.supported?(name)
+      omit("Only for #{name} device available")
+    end
+  end
+end

data/test/run-test.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+ext_dir = File.join(base_dir, "ext", "cairo")
+lib_dir = File.join(base_dir, "lib")
+test_dir = File.join(base_dir, "test")
+
+if system("which make >/dev/null 2>&1")
+  Dir.chdir(base_dir) do
+    system("make > /dev/null") or exit(1)
+  end
+end
+
+require 'rubygems'
+require 'bundler/setup'
+require 'test-unit'
+
+$LOAD_PATH.unshift(base_dir)
+$LOAD_PATH.unshift(ext_dir)
+$LOAD_PATH.unshift(lib_dir)
+
+$LOAD_PATH.unshift(test_dir)
+require 'cairo-test-utils'
+
+Dir.glob("test/**/test_*.rb") do |file|
+  require file.sub(/\.rb$/, '')
+end
+
+exit Test::Unit::AutoRunner.run(false)

data/test/test_color.rb

@@ -0,0 +1,17 @@
+require 'cairo'
+
+class ColorTest < Test::Unit::TestCase
+  def test_rgb_to_hsv
+    color = rgb(0.3, 0.5, 0.75)
+    assert_equal(color, color.to_hsv.to_rgb)
+  end
+
+  private
+  def rgb(r, g, b)
+    Cairo::Color::RGB.new(r, g, b)
+  end
+
+  def hsv(h, s, v)
+    Cairo::Color::HSV.new(h, s, v)
+  end
+end

data/test/test_constants.rb

@@ -0,0 +1,27 @@
+require 'cairo'
+
+class ConstantsTest < Test::Unit::TestCase
+  def test_text_cluster_flags
+    constant_name = "TextClusterFlag"
+    unless Cairo.satisfied_version?(1, 7, 6)
+      assert_false(Cairo.const_defined?(constant_name))
+      return
+    end
+
+    assert_true(Cairo.const_defined?(constant_name))
+    assert_equal((0..1).to_a,
+                 [0,
+                  Cairo::TextClusterFlag::BACKWARD])
+  end
+
+  def test_new_constants_since_1_14_0
+    if Cairo.satisfied_version?(1, 14, 0)
+      assertion = :assert_const_defined
+    else
+      assertion = :assert_not_const_defined
+    end
+    send(assertion, Cairo::MimeType, :JBIG2)
+    send(assertion, Cairo::MimeType, :JBIG2_GLOBAL)
+    send(assertion, Cairo::MimeType, :JBIG2_GLOBAL_ID)
+  end
+end

data/test/test_context.rb

@@ -0,0 +1,105 @@
+require 'cairo'
+require 'stringio'
+
+class ContextTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def setup
+    @output = StringIO.new
+    @surface = Cairo::PDFSurface.new(@output, 10, 10)
+  end
+
+  def test_new_and_destroy
+    context = Cairo::Context.new(@surface)
+    @surface.destroy
+    assert_not_equal("%%EOF\n", @output.string[-6..-1])
+    context.destroy
+    assert_equal("%%EOF\n", @output.string[-6..-1])
+  end
+
+  def test_new_with_block
+    Cairo::Context.new(@surface) do |context|
+      @surface.destroy
+      assert_not_equal("%%EOF\n", @output.string[-6..-1])
+    end
+    assert_equal("%%EOF\n", @output.string[-6..-1])
+  end
+
+  def test_new_with_block_and_destroy
+    assert_nothing_raised do
+      Cairo::Context.new(@surface) do |context|
+        context.destroy
+      end
+    end
+  end
+
+  def test_font_face
+    only_cairo_version(1, 7, 2)
+
+    context = Cairo::Context.new(@surface)
+
+    assert_kind_of(Cairo::FontFace, context.font_face)
+
+    face = Cairo::ToyFontFace.new("serif")
+    context.font_face = face
+    assert_equal("serif", context.font_face.family)
+
+    face = Cairo::ToyFontFace.new("sans")
+    context.font_face = face
+    assert_equal("sans", context.font_face.family)
+  end
+
+  def test_text_to_glyphs
+    only_cairo_version(1, 7, 2)
+
+    surface = Cairo::PDFSurface.new(StringIO.new, 10, 10)
+    context = Cairo::Context.new(surface)
+    scaled_font = Cairo::ScaledFont.new(context.font_face,
+                                        Cairo::Matrix.identity,
+                                        Cairo::Matrix.identity,
+                                        Cairo::FontOptions.new)
+
+    utf8 = "text"
+    glyphs, clusters, backward = scaled_font.text_to_glyphs(0, 0, utf8)
+    assert_nothing_raised do
+      context.show_text_glyphs(utf8, glyphs, clusters, backward)
+    end
+  end
+
+  def test_select_font_face
+    only_cairo_version(1, 7, 2)
+
+    context = Cairo::Context.new(@surface)
+
+    face = context.font_face
+    default_font_family = ""
+    default_font_family = "Helvetica" if quartz?
+    default_font_family = "Arial" if win32?
+    assert_equal([default_font_family,
+                  Cairo::FONT_SLANT_NORMAL,
+                  Cairo::FONT_WEIGHT_NORMAL],
+                 [face.family, face.slant, face.weight])
+
+    context.select_font_face
+    face = context.font_face
+    assert_equal([default_font_family,
+                  Cairo::FONT_SLANT_NORMAL,
+                  Cairo::FONT_WEIGHT_NORMAL],
+                 [face.family, face.slant, face.weight])
+
+    context.select_font_face(:serif, :italic, :bold)
+    face = context.font_face
+    assert_equal(["serif", Cairo::FONT_SLANT_ITALIC, Cairo::FONT_WEIGHT_BOLD],
+                 [face.family, face.slant, face.weight])
+  end
+
+  def test_select_font_face_with_invalid_family_name
+    context = Cairo::Context.new(@surface)
+
+    exception = assert_raise(ArgumentError) do
+      context.select_font_face([999])
+    end
+    assert_equal("family name should be nil, String or Symbol: [999]",
+                 exception.message)
+  end
+end