poppler 2.2.4-x64-mingw32

data/extconf.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require 'mkmf'
+require 'rbconfig'
+require 'fileutils'
+
+package = "poppler"
+
+base_dir = Pathname(__FILE__).dirname.expand_path
+ext_dir = base_dir + "ext" + package
+mkmf_gnome2_dir = base_dir + 'lib'
+
+ruby = File.join(RbConfig::CONFIG['bindir'],
+                 RbConfig::CONFIG['ruby_install_name'] +
+                 RbConfig::CONFIG["EXEEXT"])
+
+build_dir = Pathname("ext") + package
+FileUtils.mkdir_p(build_dir.to_s) unless build_dir.exist?
+extconf_rb_path = ext_dir + "extconf.rb"
+system(ruby, "-C", build_dir.to_s, extconf_rb_path.to_s, *ARGV) || exit(false)
+
+create_makefile(package)
+FileUtils.mv("Makefile", "Makefile.lib")
+
+File.open("Makefile", "w") do |makefile|
+  makefile.puts(<<-EOM)
+all:
+	(cd ext/#{package} && $(MAKE))
+	$(MAKE) -f Makefile.lib
+
+install:
+	(cd ext/#{package} && $(MAKE) install)
+	$(MAKE) -f Makefile.lib install
+
+site-install:
+	(cd ext/#{package} && $(MAKE) site-install)
+	$(MAKE) -f Makefile.lib site-install
+
+clean:
+	(cd ext/#{package} && $(MAKE) clean)
+	$(MAKE) -f Makefile.lib clean
+
+distclean:
+	(cd ext/#{package} && $(MAKE) distclean)
+	$(MAKE) -f Makefile.lib distclean
+	@rm -f Makefile.lib
+EOM
+end

data/lib/poppler.rb

@@ -0,0 +1,105 @@
+# Copyright(C) 2006-2009 Ruby-GNOME2 Project.
+#
+# This library is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 2.1 of the License.
+#
+# Foobar is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+
+require "tempfile"
+require "date"
+require "glib2"
+require "gdk_pixbuf2"
+require "cairo"
+
+base_dir = Pathname.new(__FILE__).dirname.dirname.expand_path
+vendor_dir = base_dir + "vendor" + "local"
+vendor_bin_dir = vendor_dir + "bin"
+GLib.prepend_dll_path(vendor_bin_dir)
+begin
+  major, minor, = RUBY_VERSION.split(/\./)
+  require "#{major}.#{minor}/poppler.so"
+rescue LoadError
+  require "poppler.so"
+end
+
+module Poppler
+  LOG_DOMAIN = "Poppler"
+
+  VERSION = version.split(".").collect {|x| x.to_i}
+
+  class Document
+    private
+    def pdf_data?(data)
+      /\A%PDF-1\.\d/ =~ data
+    end
+
+    def ensure_uri(uri)
+      if pdf_data?(uri)
+        @pdf = Tempfile.new("ruby-poppler-pdf")
+        @pdf.binmode
+        @pdf.print(uri)
+        @pdf.close
+        uri = @pdf.path
+      end
+
+      if GLib.path_is_absolute?(uri)
+        GLib.filename_to_uri(uri)
+      elsif /\A[a-zA-Z][a-zA-Z\d\-+.]*:/.match(uri)
+        uri
+      else
+        GLib.filename_to_uri(File.expand_path(uri))
+      end
+    end
+  end
+
+  if defined?(TextField)
+    class TextField
+      def multiline?
+        type == FormTextType::MULTILINE
+      end
+
+      def file_select?
+        type == FormTextType::FILE_SELECT
+      end
+
+      def normal?
+        type == FormTextType::NORMAL
+      end
+    end
+  end
+
+  if defined?(ChoiceField)
+    class ChoiceField
+      def combo?
+        type == FormChioceType::COMBO
+      end
+
+      def list?
+        type == FormChoiceType::LIST
+      end
+    end
+  end
+end
+
+if Poppler.cairo_available?
+  module Cairo
+    class Context
+      def render_poppler_page(page, *args, &block)
+        page.render(self, *args, &block)
+      end
+
+      def render_poppler_page_selection(page, *args, &block)
+        page.render_selection(self, *args, &block)
+      end
+    end
+  end
+end
+
+GLib::Log.set_log_domain(Poppler::LOG_DOMAIN)

data/sample/number-pdf.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'poppler'
+
+input = ARGV.first
+output = input.sub(/\.pdf$/, "-numbered.pdf")
+
+doc = Poppler::Document.new(input)
+first_page = doc[0]
+
+Cairo::PDFSurface.new(output, *first_page.size) do |surface|
+  context = Cairo::Context.new(surface)
+
+  doc.each_with_index do |page, i|
+    width, height = page.size
+    surface.set_size(width, height)
+    context.save do
+      context.render_poppler_page(page)
+    end
+    context.save do
+      layout = context.create_pango_layout
+      layout.text = i.to_s
+      layout.width = width * Pango::SCALE
+      layout.alignment = Pango::Layout::ALIGN_CENTER
+      layout.font_description = Pango::FontDescription.new("Sans 288")
+      context.move_to(0, (height - layout.pixel_size[1]) / 2.0)
+      context.set_source_rgba(0.1, 0.1, 0.1, 0.5)
+      context.show_pango_layout(layout)
+    end
+    context.show_page
+  end
+end

data/sample/pdf2.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+
+require "tempfile"
+require "optparse"
+require "poppler"
+require "gdk_pixbuf2"
+
+page = 0
+scale = 1.0
+rotate = 0
+
+parser = OptionParser.new
+parser.banner = <<-BANNER
+Usage: #{parser.program_name} INPUT.PDF OUTPUT [options]
+
+#{parser.program_name} coverts the target page in INPUT.PDF to an image file.
+Many popular image formats such as PNG and JPEG are supported.
+You can specify output image format by OUTPUT file extension.
+For example, the following comand generates PNG file:
+
+  % #{$0} INPUT.PDF OUTPUT.png
+
+BANNER
+
+parser.on("--page=PAGE", Integer,
+          "Use PAGE as the target page",
+          "(0-origin)",
+          "[#{page}]") do |value|
+  page = value.to_i
+end
+
+parser.on("--scale=RATIO", Float,
+          "Scale the target page in INPUT.PDF RATIO times larger in OUTPUT",
+          "[#{scale}]") do |value|
+  scale = value.to_f
+end
+
+parser.on("--rotate=DEGREE", Integer,
+          "Rotate the target page in INPUT.PDF DEGREE degrees clockwise in OUTPUT",
+          "(available values: 0...360)",
+          "[#{rotate}]") do |value|
+  rotate = value.to_i % 360
+end
+
+rest_args = parser.parse!
+if rest_args.size != 2
+  puts(parser.help)
+  exit(false)
+end
+input, output = rest_args
+
+ext_name = File.extname(output)[1..-1]
+if ext_name
+  output_type = ext_name.downcase
+  output_type = "jpeg" if /jpg/ =~ output_type
+else
+  output_type = "png"
+end
+
+def compute_size(width, height, rotate)
+  width = width.to_f
+  height = height.to_f
+  radius = 0
+  unless rotate.zero?
+    radius = rotate / 180.0 * Math::PI
+    if (90 < rotate and rotate < 180) or
+        (270 < rotate and rotate < 360)
+      radius -= Math::PI / 2
+    end
+  end
+  inner_angle1 = Math.atan(width / height)
+  inner_angle2 = Math.atan(height / width)
+  diagonal = Math.sqrt(width ** 2 + height ** 2)
+
+  angle1 = radius + inner_angle1
+  angle2 = radius + inner_angle2
+
+  bottom1 = diagonal * Math.cos(angle1)
+  length1 = (bottom1 * Math.tan(angle1)).abs.to_i
+  bottom2 = diagonal * Math.cos(angle2)
+  length2 = (bottom2 * Math.tan(angle2)).abs.to_i
+
+  if (0 <= rotate and rotate <= 90) or
+      (180 <= rotate and rotate <= 270)
+    [length1, length2]
+  else
+    [length2, length1]
+  end
+end
+
+def to_pixbuf_with_cairo(input, page_number, scale, rotate)
+  doc = Poppler::Document.new(input)
+  page = doc[page_number]
+  width, height = page.size.collect {|x| x * scale}
+  surface_width, surface_height = compute_size(width, height, rotate)
+
+  surface = Cairo::ImageSurface.new(Cairo::FORMAT_ARGB32,
+                                    surface_width, surface_height)
+  cr = Cairo::Context.new(surface)
+
+  half_width = surface_width / 2.0
+  half_height = surface_height / 2.0
+  cr.translate(half_width, half_height)
+  cr.rotate(rotate / 180.0 * Math::PI)
+  cr.translate(-half_width, -half_height)
+
+  cr.translate((surface_width - width) / 2.0,
+               (surface_height - height) / 2.0)
+  cr.set_source_rgb(1, 1, 1)
+  cr.rectangle(0, 0, width, height)
+  cr.fill
+
+  cr.scale(scale, scale)
+  cr.render_poppler_page(page)
+  temp = Tempfile.new("pdf2")
+  cr.target.write_to_png(temp.path)
+  cr.target.finish
+  Gdk::Pixbuf.new(temp.path)
+end
+
+unless Poppler.cairo_available?
+  puts "cairo isn't available."
+  exit(false)
+end
+pixbuf = to_pixbuf_with_cairo(input, page, scale, rotate)
+
+if pixbuf.nil?
+  puts "Is it a PDF file?: #{input}"
+  exit(-1)
+end
+puts "saving to #{output}(#{pixbuf.width}x#{pixbuf.height})..."
+pixbuf.save(output, output_type)

data/sample/pdf2svg.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require "poppler"
+
+if ARGV.size < 1
+  puts "usage: #{$0} input.pdf"
+  exit(-1)
+end
+
+input, = ARGV
+
+output = input.sub(/\..+$/, ".svg")
+output = "#{output}.svg" if input == output
+
+doc = Poppler::Document.new(input)
+
+width, height = doc.pages[0].size
+Cairo::SVGSurface.new(output, width, height) do |surface|
+  surface.restrict_to_version("1_2")
+
+  context = Cairo::Context.new(surface)
+  doc.each do |page|
+    page.render(context)
+    context.show_page
+  end
+end

data/sample/pdf2text.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "poppler"
+
+if ARGV.size < 1
+  puts "usage: #{$0} input.pdf"
+  exit(-1)
+end
+
+input = ARGV.shift
+input_uri = "file://#{File.expand_path(input)}"
+
+doc = Poppler::Document.new(input_uri)
+doc.each do |page|
+  puts page.get_text
+end

data/sample/pdfcrop.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require "poppler"
+
+if ARGV.size != 2
+  puts "usage: #{$0} input.pdf output.pdf"
+  exit(-1)
+end
+
+input, output = ARGV
+
+doc = Poppler::Document.new(input)
+
+width, height = doc.pages[0].size
+x_margin = width * 0.1
+y_margin = height * 0.1
+croped_width = width - (2 * x_margin)
+croped_height = height - (2 * y_margin)
+Cairo::PDFSurface.new(output, croped_width, croped_height) do |surface|
+  context = Cairo::Context.new(surface)
+
+  doc.each do |page|
+    width, height = page.size
+    context.save do
+      context.translate(-x_margin, -y_margin)
+      context.rectangle(x_margin, y_margin, croped_width, croped_height)
+      context.clip
+      page.render(context)
+      context.show_page
+    end
+  end
+end

data/sample/pdfdiv.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require "poppler"
+
+if ARGV.size != 2
+  puts "usage: #{$0} input.pdf output.pdf"
+  exit(-1)
+end
+
+input, output = ARGV
+
+doc = Poppler::Document.new(input)
+
+width, height = doc.pages[0].size
+Cairo::PDFSurface.new(output, width / 2, height) do |surface|
+  context = Cairo::Context.new(surface)
+
+  doc.each do |page|
+    width, height = page.size
+    half_width = width / 2
+    context.save do
+      context.rectangle(0, 0, half_width, height)
+      context.clip
+      page.render(context)
+      context.show_page
+    end
+
+    context.save do
+      context.translate(-half_width, 0)
+      context.rectangle(half_width, 0, half_width, height)
+      context.clip
+      page.render(context)
+      context.show_page
+    end
+  end
+end