poppler 0.20.0

data/extconf.rb

@@ -0,0 +1,49 @@
+=begin
+extconf.rb for Ruby/Poppler extention library
+=end
+
+PACKAGE_NAME = "poppler"
+PACKAGE_ID = "poppler-glib"
+
+begin
+  require 'mkmf-gnome2'
+  USE_GLIB_GEM = true
+  TOPDIR = File.expand_path(File.dirname(__FILE__) )
+  SRCDIR = TOPDIR + '/src'
+  require 'glib2'
+  require 'gdk_pixbuf2'
+  require 'gtk2/base'
+
+rescue LoadError => e
+  TOPDIR = File.expand_path(File.dirname(__FILE__) + '/..')
+  MKMF_GNOME2_DIR = TOPDIR + '/glib/src/lib'
+  SRCDIR = TOPDIR + '/poppler/src'
+
+  $LOAD_PATH.unshift MKMF_GNOME2_DIR
+
+  require 'mkmf-gnome2'
+end
+
+PKGConfig.have_package(PACKAGE_ID, 0, 8, 0) or exit 1
+setup_win32(PACKAGE_NAME)
+
+check_cairo
+
+if USE_GLIB_GEM
+  path = File.expand_path(ENV['GEM_HOME'] + "/gems/glib2-#{GLib::BINDING_VERSION.join('.')}/src")
+  add_depend_package("glib2", path, '/')
+  path = File.expand_path(ENV['GEM_HOME'] + "/gems/gdkpixbuf-#{GLib::BINDING_VERSION.join('.')}/src")
+  add_depend_package("gdk_pixbuf2", path, '/')
+  path = File.expand_path(ENV['GEM_HOME'] + "/gems/gtk2-#{GLib::BINDING_VERSION.join('.')}/src")
+  add_depend_package("gtk2", path, '/')
+else
+  add_depend_package("glib2", "glib/src", TOPDIR)
+  add_depend_package("gtk2", "gtk/src", TOPDIR)
+  add_depend_package("gdk_pixbuf2", "gdkpixbuf", TOPDIR)
+end
+
+make_version_header("POPPLER", PACKAGE_ID)
+
+create_pkg_config_file("Ruby/Poppler", PACKAGE_ID)
+create_makefile_at_srcdir(PACKAGE_NAME, SRCDIR, "-DRUBY_POPPLER_COMPILATION")
+create_top_makefile

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,107 @@
+#!/usr/bin/env ruby
+
+require 'tempfile'
+require "poppler"
+
+if ARGV.size < 2
+  puts "usage: #{$0} input.pdf output [scale_ratio] [rotate_angle]"
+  exit(-1)
+end
+
+input, output, scale, rotate = ARGV
+scale = (scale || 1.0).to_f
+rotate = (rotate || 0).to_i % 360
+
+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, scale, rotate)
+  doc = Poppler::Document.new(input)
+  page = doc[0]
+  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
+
+def to_pixbuf(input, scale, rotate)
+  doc = Poppler::Document.new(input)
+  page = doc[0]
+  width, height = page.size.collect {|x| x * scale}
+  pixbuf_width, pixbuf_height = compute_size(width, height, rotate)
+  pixbuf = Gdk::Pixbuf.new(Gdk::Pixbuf::COLORSPACE_RGB, true, 8,
+                           pixbuf_width, pixbuf_height)
+  page.render(0, 0, width, height, scale, rotate, pixbuf)
+  pixbuf
+end
+
+if Poppler.cairo_available?
+  puts "using cairo..."
+  pixbuf = to_pixbuf_with_cairo(input, scale, rotate)
+else
+  pixbuf = to_pixbuf(input, scale, rotate)
+end
+
+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/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

data/src/lib/poppler.rb

@@ -0,0 +1,108 @@
+# 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"
+begin
+  require "gtk2/base"
+rescue LoadError
+rescue
+  if defined?(Gtk::InitError) and $!.class == Gtk::InitError
+    # ignore
+  else
+    raise
+  end
+end
+begin
+  require "cairo"
+rescue LoadError
+end
+require "poppler.so"
+
+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/src/rbpoppler-action.c

@@ -0,0 +1,222 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbpoppler-action.c -
+
+  Copyright (C) 2006-2008 Ruby-GNOME2 Project Team
+
+**********************************************************************/
+
+#include "rbpoppler-private.h"
+
+#define RVAL2DEST(obj) ((PopplerDest *)RVAL2BOXED(obj, POPPLER_TYPE_DEST))
+#define DEST2RVAL(obj) (BOXED2RVAL(obj, POPPLER_TYPE_DEST))
+
+#define DEST_TYPE2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_DEST_TYPE))
+#define ACTION_TYPE2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_ACTION_TYPE))
+#define RVAL2ACTION_TYPE(obj) (RVAL2GENUM(obj, POPPLER_TYPE_ACTION_TYPE))
+
+
+/* PopplerAction */
+static VALUE actions[POPPLER_ACTION_MOVIE + 1];
+
+VALUE
+rb_poppler_ruby_object_from_action(PopplerAction *action)
+{
+    VALUE obj;
+
+    if (!action)
+        return Qnil;
+
+    obj = BOXED2RVAL(action, POPPLER_TYPE_ACTION);
+    RBASIC(obj)->klass = actions[action->type];
+    return obj;
+}
+
+PopplerAction *
+rb_poppler_action_from_ruby_object(VALUE action)
+{
+    return NIL_P(action) ? NULL : RVAL2BOXED(action, POPPLER_TYPE_ACTION);
+}
+
+#define ACTION_ATTR_STR(type, name)				\
+static VALUE							\
+action_ ## type ## _ ## name (VALUE self)			\
+{								\
+    return CSTR2RVAL(RVAL2POPPLER_ACTION(self)->type.name);     \
+}
+
+#define ACTION_ATTR_DEST(type, name)				\
+static VALUE							\
+action_ ## type ## _ ## name (VALUE self)			\
+{								\
+    return DEST2RVAL(RVAL2POPPLER_ACTION(self)->type.name);     \
+}
+
+#define DEFINE_ACCESSOR(prefix, target, name) \
+    rb_define_method(target, G_STRINGIFY(name), prefix ## _ ## name, 0);
+
+#define DEFINE_ACTION_ACCESSOR(target, type, name) \
+    DEFINE_ACCESSOR(action_ ## type, target, name)
+
+/* PopplerActionAny */
+static VALUE
+action_any_type(VALUE self)
+{
+    return ACTION_TYPE2RVAL(RVAL2POPPLER_ACTION(self)->type);
+}
+ACTION_ATTR_STR(any, title);
+
+/* PopplerActionGotoDest */
+ACTION_ATTR_DEST(goto_dest, dest);
+
+/* PopplerActionGotoRemote */
+ACTION_ATTR_STR(goto_remote, file_name);
+ACTION_ATTR_DEST(goto_remote, dest);
+
+/* PopplerActionLaunch */
+ACTION_ATTR_STR(launch, file_name);
+ACTION_ATTR_STR(launch, params);
+
+/* PopplerActionUri */
+ACTION_ATTR_STR(uri, uri);
+
+/* PopplerActionNamed */
+ACTION_ATTR_STR(named, named_dest);
+
+/* PopplerActionMovie */
+
+
+/* PopplerDest */
+#ifdef RB_POPPLER_TYPE_DEST_NOT_DEFINED
+GType
+poppler_dest_get_type (void)
+{
+  static GType our_type = 0;
+
+  if (our_type == 0)
+    our_type = g_boxed_type_register_static ("PopplerDest",
+					     (GBoxedCopyFunc) poppler_dest_copy,
+					     (GBoxedFreeFunc) poppler_dest_free);
+
+  return our_type;
+}
+#endif
+
+static VALUE
+dest_get_type(VALUE self)
+{
+    return DEST_TYPE2RVAL(RVAL2DEST(self)->type);
+}
+
+#define DEST_ATTR_INT(name)                     \
+static VALUE                                    \
+dest_ ## name (VALUE self)                      \
+{                                               \
+    return INT2NUM(RVAL2DEST(self)->name);      \
+}
+
+#define DEST_ATTR_UINT(name)                    \
+static VALUE                                    \
+dest_ ## name (VALUE self)                      \
+{                                               \
+    return UINT2NUM(RVAL2DEST(self)->name);     \
+}
+
+#define DEST_ATTR_DOUBLE(name)                  \
+static VALUE                                    \
+dest_ ## name (VALUE self)                      \
+{                                               \
+    return rb_float_new(RVAL2DEST(self)->name); \
+}
+
+#define DEST_ATTR_STR(name)                     \
+static VALUE                                    \
+dest_ ## name (VALUE self)                      \
+{                                               \
+    return CSTR2RVAL(RVAL2DEST(self)->name);    \
+}
+
+#define DEFINE_DEST_ACCESSOR(target, name) \
+    DEFINE_ACCESSOR(dest, target, name)
+
+
+DEST_ATTR_INT(page_num)
+DEST_ATTR_DOUBLE(left)
+DEST_ATTR_DOUBLE(bottom)
+DEST_ATTR_DOUBLE(right)
+DEST_ATTR_DOUBLE(top)
+DEST_ATTR_DOUBLE(zoom)
+DEST_ATTR_STR(named_dest)
+DEST_ATTR_UINT(change_left)
+DEST_ATTR_UINT(change_top)
+DEST_ATTR_UINT(change_zoom)
+
+void
+Init_poppler_action(VALUE mPoppler)
+{
+    VALUE cDest,  cAction, cActionAny, cActionGotoDest, cActionGotoRemote;
+    VALUE cActionLaunch, cActionUri, cActionNamed, cActionMovie;
+
+    cAction = G_DEF_CLASS(POPPLER_TYPE_ACTION, "Action", mPoppler);
+
+    cActionAny = rb_define_class_under(mPoppler, "ActionAny", cAction);
+    rb_define_method(cActionAny, "type", action_any_type, 0);
+    DEFINE_ACTION_ACCESSOR(cActionAny, any, title);
+
+    cActionGotoDest = rb_define_class_under(mPoppler, "ActionGotoDest",
+                                            cActionAny);
+    DEFINE_ACTION_ACCESSOR(cActionGotoDest, goto_dest, dest);
+
+    cActionGotoRemote = rb_define_class_under(mPoppler, "ActionGotoRemote",
+                                              cActionAny);
+    DEFINE_ACTION_ACCESSOR(cActionGotoRemote, goto_remote, file_name);
+    DEFINE_ACTION_ACCESSOR(cActionGotoRemote, goto_remote, dest);
+
+    cActionLaunch = rb_define_class_under(mPoppler, "ActionLaunch", cActionAny);
+    DEFINE_ACTION_ACCESSOR(cActionLaunch, launch, file_name);
+    DEFINE_ACTION_ACCESSOR(cActionLaunch, launch, params);
+
+    cActionUri = rb_define_class_under(mPoppler, "ActionUri", cActionAny);
+    DEFINE_ACTION_ACCESSOR(cActionUri, uri, uri);
+
+    cActionNamed = rb_define_class_under(mPoppler, "ActionNamed", cActionAny);
+    DEFINE_ACTION_ACCESSOR(cActionNamed, named, named_dest);
+
+    cActionMovie = rb_define_class_under(mPoppler, "ActionMovie", cActionAny);
+
+    actions[POPPLER_ACTION_UNKNOWN] = cActionAny;
+    actions[POPPLER_ACTION_GOTO_DEST] = cActionGotoDest;
+    actions[POPPLER_ACTION_GOTO_REMOTE] = cActionGotoRemote;
+    actions[POPPLER_ACTION_LAUNCH] = cActionLaunch;
+    actions[POPPLER_ACTION_URI] = cActionUri;
+    actions[POPPLER_ACTION_NAMED] = cActionNamed;
+    actions[POPPLER_ACTION_MOVIE] = cActionMovie;
+
+    G_DEF_SETTERS(cAction);
+    G_DEF_SETTERS(cActionAny);
+    G_DEF_SETTERS(cActionGotoDest);
+    G_DEF_SETTERS(cActionGotoRemote);
+    G_DEF_SETTERS(cActionLaunch);
+    G_DEF_SETTERS(cActionUri);
+    G_DEF_SETTERS(cActionNamed);
+    G_DEF_SETTERS(cActionMovie);
+
+    G_DEF_CLASS(POPPLER_TYPE_ACTION_TYPE, "ActionType", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_DEST_TYPE, "DestType", mPoppler);
+
+    cDest = G_DEF_CLASS(POPPLER_TYPE_DEST, "Dest", mPoppler);
+
+    rb_define_method(cDest, "type", dest_get_type, 0);
+    DEFINE_DEST_ACCESSOR(cDest, page_num);
+    DEFINE_DEST_ACCESSOR(cDest, left);
+    DEFINE_DEST_ACCESSOR(cDest, bottom);
+    DEFINE_DEST_ACCESSOR(cDest, right);
+    DEFINE_DEST_ACCESSOR(cDest, top);
+    DEFINE_DEST_ACCESSOR(cDest, zoom);
+    DEFINE_DEST_ACCESSOR(cDest, named_dest);
+    DEFINE_DEST_ACCESSOR(cDest, change_left);
+    DEFINE_DEST_ACCESSOR(cDest, change_top);
+    DEFINE_DEST_ACCESSOR(cDest, change_zoom);
+    G_DEF_SETTERS(cDest);
+}