poppler 0.20.0

data/src/rbpoppler-private.h

@@ -0,0 +1,56 @@
+#ifndef __RBPOPPLER_PRIVATE_H__
+#define __RBPOPPLER_PRIVATE_H__
+
+#include "rbpoppler.h"
+
+#ifdef POPPLER_WITH_GDK
+#  include <rbgdk.h>
+#endif
+
+extern void Init_poppler_document(VALUE mPoppler);
+extern void Init_poppler_page(VALUE mPoppler);
+extern void Init_poppler_attachment(VALUE mPoppler);
+extern void Init_poppler_action(VALUE mPoppler);
+extern void Init_poppler_annotation(VALUE mPoppler);
+extern void Init_poppler_form_field(VALUE mPoppler);
+
+#define DEF_READER(prefix, name, member, self_to_c, member_to_rb)       \
+static VALUE                                                            \
+prefix ## _get_ ## name(VALUE self)                                     \
+{                                                                       \
+    return member_to_rb((self_to_c(self))->member);                     \
+}
+
+#define DEF_WRITER(prefix, name, member, self_to_c, value_to_c) \
+static VALUE                                                    \
+prefix ## _set_ ## name(VALUE self, VALUE value)                \
+{                                                               \
+    (self_to_c(self))->member = value_to_c(value);              \
+    return Qnil;                                                \
+}
+
+#define DEF_WRITER_WITH_SETTER(prefix, name, member,    \
+                               self_to_c, value_setter) \
+static VALUE                                            \
+prefix ## _set_ ## name(VALUE self, VALUE value)        \
+{                                                       \
+    value_setter((self_to_c(self))->member, value);     \
+    return Qnil;                                        \
+}
+
+#define DEF_ACCESSOR(prefix, member, self_to_c, member_to_rb, value_to_c) \
+    DEF_READER(prefix, member, member, self_to_c, member_to_rb)         \
+    DEF_WRITER(prefix, member, member, self_to_c, value_to_c)           \
+
+#define DEF_ACCESSOR_WITH_SETTER(prefix, member, self_to_c,             \
+                                 member_to_rb, value_setter)            \
+    DEF_READER(prefix, member, member, self_to_c, member_to_rb)         \
+    DEF_WRITER_WITH_SETTER(prefix, member, member, self_to_c, value_setter)
+
+#define DEF_ACCESSOR_WITH_NAME(prefix, name, member, self_to_c, \
+                               member_to_rb, value_to_c)        \
+    DEF_READER(prefix, name, member, self_to_c, member_to_rb)   \
+    DEF_WRITER(prefix, name, member, self_to_c, value_to_c)
+
+
+#endif

data/src/rbpoppler.c

@@ -0,0 +1,90 @@
+/* -*- c-file-style: "ruby" -*- */
+/**********************************************************************
+
+  rbpoppler.c -
+
+  Copyright (C) 2006-2008 Ruby-GNOME2 Project Team
+
+**********************************************************************/
+
+#include "rbpoppler-private.h"
+
+static VALUE
+get_backend(VALUE self)
+{
+    return GENUM2RVAL(poppler_get_backend(), POPPLER_TYPE_BACKEND);
+}
+
+static VALUE
+get_version(VALUE self)
+{
+    return CSTR2RVAL(poppler_get_version());
+}
+
+static VALUE
+cairo_available(VALUE self)
+{
+#ifdef RB_POPPLER_CAIRO_AVAILABLE
+    return Qtrue;
+#else
+    return Qfalse;
+#endif
+}
+
+
+void
+Init_poppler(void)
+{
+    VALUE mPoppler;
+
+    mPoppler = rb_define_module("Poppler");
+
+    rb_define_const(mPoppler, "BUILD_VERSION",
+                    rb_ary_new3(3,
+                                INT2FIX(POPPLER_MAJOR_VERSION),
+                                INT2FIX(POPPLER_MINOR_VERSION),
+                                INT2FIX(POPPLER_MICRO_VERSION)));
+
+    G_DEF_CLASS(POPPLER_TYPE_ERROR, "Error", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_ORIENTATION, "Orientation", mPoppler);
+
+    G_DEF_CLASS(POPPLER_TYPE_PAGE_TRANSITION_TYPE,
+                "PageTransitionType", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_PAGE_TRANSITION_ALIGNMENT,
+                "PageTransitionAlignment", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_PAGE_TRANSITION_DIRECTION,
+                "PageTransitionDirection", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_SELECTION_STYLE, "SelectionStyle", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_FORM_BUTTON_TYPE, "FormButtonType", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_FORM_TEXT_TYPE, "FormTextType", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_FORM_CHOICE_TYPE, "FormChoiceType", mPoppler);
+
+    G_RENAME_NICK("3D", "TYPE_3D");
+    G_DEF_CLASS(POPPLER_TYPE_ANNOT_TYPE, "AnnotationType", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_ANNOT_FLAG, "AnnotationFlag", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_ANNOT_MARKUP_REPLY_TYPE,
+		"AnnotationMarkupReplyType", mPoppler);
+    G_RENAME_NICK("3D", "TYPE_3D");
+    G_DEF_CLASS(POPPLER_TYPE_ANNOT_EXTERNAL_DATA_TYPE,
+		"AnnotationExternalDataType", mPoppler);
+#  if !POPPLER_CHECK_VERSION(0, 9, 0)
+    G_DEF_CLASS(POPPLER_TYPE_ANNOT_TEXT_ICON, "AnnotationTextIcon", mPoppler);
+#  endif
+    G_DEF_CLASS(POPPLER_TYPE_ANNOT_TEXT_STATE, "AnnotationTextState", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_ANNOT_FREE_TEXT_QUADDING,
+		"AnnotationFreeTextQuadding", mPoppler);
+
+
+    G_DEF_CLASS(POPPLER_TYPE_BACKEND, "Backend", mPoppler);
+
+    rb_define_module_function(mPoppler, "backend", get_backend, 0);
+    rb_define_module_function(mPoppler, "version", get_version, 0);
+    rb_define_module_function(mPoppler, "cairo_available?", cairo_available, 0);
+
+    Init_poppler_document(mPoppler);
+    Init_poppler_page(mPoppler);
+    Init_poppler_attachment(mPoppler);
+    Init_poppler_action(mPoppler);
+    Init_poppler_annotation(mPoppler);
+    Init_poppler_form_field(mPoppler);
+}

data/src/rbpoppler.h

@@ -0,0 +1,60 @@
+#ifndef __RBPOPPLER_H__
+#define __RBPOPPLER_H__
+
+#include "rbpopplerversion.h"
+
+#include <ruby.h>
+
+#include <rbglib.h>
+#include <rbgobject.h>
+
+#include <poppler.h>
+#include "rbglib.h"
+
+#define RBPOPPLER_MAJOR_VERSION RBGLIB_MAJOR_VERSION
+#define RBPOPPLER_MINOR_VERSION RBGLIB_MINOR_VERSION 
+#define RBPOPPLER_MICRO_VERSION RBGLIB_MICRO_VERSION
+
+#ifndef POPPLER_TYPE_INDEX_ITER
+#  define POPPLER_TYPE_INDEX_ITER (poppler_index_iter_get_type ())
+#endif
+#ifndef POPPLER_TYPE_FONTS_ITER
+#  define POPPLER_TYPE_FONTS_ITER (poppler_fonts_iter_get_type ())
+#endif
+
+#ifndef POPPLER_TYPE_DEST
+extern GType poppler_dest_get_type (void) G_GNUC_CONST;
+#  define POPPLER_TYPE_DEST (poppler_dest_get_type ())
+#  define RB_POPPLER_TYPE_DEST_NOT_DEFINED
+#endif
+
+#if defined(HAVE_RB_CAIRO_H) && defined(POPPLER_HAS_CAIRO)
+#  define RB_POPPLER_CAIRO_AVAILABLE 1
+#  include <rb_cairo.h>
+#endif
+
+#define POPPLER_RECT2RVAL(obj) (BOXED2RVAL(obj, POPPLER_TYPE_RECTANGLE))
+#define RVAL2POPPLER_RECT(obj) ((PopplerRectangle *)RVAL2BOXED(obj, POPPLER_TYPE_RECTANGLE))
+
+#ifdef POPPLER_TYPE_COLOR
+extern PopplerColor *rb_poppler_ruby_object_to_color(VALUE color);
+extern VALUE rb_poppler_ruby_object_from_color_with_free(PopplerColor *color);
+#  define RVAL2POPPLER_COLOR(obj) (rb_poppler_ruby_object_to_color(obj))
+#  define POPPLER_COLOR2RVAL(obj) (BOXED2RVAL(obj, POPPLER_TYPE_COLOR))
+#  define POPPLER_COLOR2RVAL_FREE(obj) (rb_poppler_ruby_object_from_color_with_free(obj))
+#endif
+
+
+#define POPPLER_ANNOT2RVAL(obj) (GOBJ2RVAL(obj))
+#define RVAL2POPPLER_ANNOT(obj) (POPPLER_ANNOT(RVAL2GOBJ(obj)))
+
+#define POPPLER_ACTION2RVAL(obj) (rb_poppler_ruby_object_from_action(obj))
+#define RVAL2POPPLER_ACTION(obj) (rb_poppler_action_from_ruby_object(obj))
+#define POPPLER_FORM_FIELD2RVAL(obj) (rb_poppler_ruby_object_from_form_field(obj))
+#define RVAL2POPPLER_FORM_FIELD(obj) (POPPLER_FORM_FIELD(RVAL2GOBJ(obj)))
+
+extern VALUE rb_poppler_ruby_object_from_action(PopplerAction *action);
+extern PopplerAction *rb_poppler_action_from_ruby_object(VALUE action);
+extern VALUE rb_poppler_ruby_object_from_form_field(PopplerFormField *field);
+
+#endif

data/src/rbpopplerversion.h

@@ -0,0 +1,24 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbpopplerversion.h -
+
+  This file was generated by mkmf-gnome2.rb.
+
+************************************************/
+
+#ifndef __RBPOPPLER_VERSION_H__
+#define __RBPOPPLER_VERSION_H__
+
+#define POPPLER_MAJOR_VERSION (0)
+#define POPPLER_MINOR_VERSION (12)
+#define POPPLER_MICRO_VERSION (1)
+
+#define POPPLER_CHECK_VERSION(major,minor,micro)    \
+    (POPPLER_MAJOR_VERSION > (major) || \
+     (POPPLER_MAJOR_VERSION == (major) && POPPLER_MINOR_VERSION > (minor)) || \
+     (POPPLER_MAJOR_VERSION == (major) && POPPLER_MINOR_VERSION == (minor) && \
+      POPPLER_MICRO_VERSION >= (micro)))
+
+
+#endif /* __RBPOPPLER_VERSION_H__ */

data/test/poppler-test-utils.rb

@@ -0,0 +1,47 @@
+require 'open-uri'
+require 'fileutils'
+
+module PopplerTestUtils
+  def ensure_dir(dir)
+    FileUtils.mkdir_p(dir)
+    dir
+  end
+
+  def test_dir
+    File.expand_path(File.dirname(__FILE__))
+  end
+
+  def fixtures_dir
+    ensure_dir(File.join(test_dir, "fixtures"))
+  end
+
+  def tmp_dir
+    ensure_dir(File.join(test_dir, "tmp"))
+  end
+
+  def form_pdf
+    file = File.join(fixtures_dir, "form.pdf")
+    return file if File.exist?(file)
+    pdf = open("http://www.irs.gov/pub/irs-pdf/fw9.pdf").read
+    File.open(file, "wb") do |output|
+      output.print(pdf)
+    end
+    file
+  end
+
+  def image_pdf
+    File.join(fixtures_dir, "image.pdf")
+  end
+
+  def later_version?(major, minor, micro=nil)
+    micro ||= 0
+    (Poppler::BUILD_VERSION <=> [major, minor, micro]) >= 0
+  end
+
+  def only_poppler_version(major, minor, micro=nil)
+    micro ||= 0
+    unless later_version?(major, minor, micro)
+      omit("Require Poppler >= #{major}.#{minor}.#{micro}")
+    end
+  end
+end

data/test/run-test.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+
+if system("which make > /dev/null")
+  system("cd #{base_dir.dump} && make > /dev/null") or exit(1)
+end
+
+glib_dir = File.expand_path(File.join(base_dir, "..", "glib"))
+gtk_dir = File.expand_path(File.join(base_dir, "..", "gtk"))
+
+$LOAD_PATH.unshift(glib_dir)
+require 'test/glib-test-init'
+
+[gtk_dir, glib_dir, base_dir].each do |dir|
+  $LOAD_PATH.unshift(File.join(dir, "src"))
+  $LOAD_PATH.unshift(File.join(dir, "src", "lib"))
+end
+require "poppler"
+
+$LOAD_PATH.unshift(File.join(base_dir, "test"))
+require 'poppler-test-utils'
+class Test::Unit::TestCase
+  include PopplerTestUtils
+end
+
+exit Test::Unit::AutoRunner.run(true)

data/test/test_annotation.rb

@@ -0,0 +1,84 @@
+class TestAnnotation < Test::Unit::TestCase
+  def test_type
+    only_poppler_version(0, 7, 2)
+    assert_kind_of(Poppler::AnnotationType, annotation.type)
+  end
+
+  def test_contents
+    only_poppler_version(0, 7, 2)
+    assert_nil(annotation.contents)
+  end
+
+  def test_name
+    only_poppler_version(0, 7, 2)
+    assert_nil(annotation.name)
+  end
+
+  def test_modified
+    only_poppler_version(0, 7, 2)
+    assert_nil(annotation.modified)
+  end
+
+  def test_flags
+    only_poppler_version(0, 7, 2)
+    assert_kind_of(Poppler::AnnotationFlag, annotation.flags)
+  end
+
+  def test_color
+    only_poppler_version(0, 7, 2)
+    assert_nil(annotation.color)
+  end
+
+  def test_markup
+    only_poppler_version(0, 7, 2)
+    # We don't have a PDF that has annotation markup...
+    assert_method_defined(Poppler::AnnotationMarkup, :label)
+    assert_method_defined(Poppler::AnnotationMarkup, :popup_is_open?)
+    assert_method_defined(Poppler::AnnotationMarkup, :opacity)
+    assert_method_defined(Poppler::AnnotationMarkup, :date)
+    assert_method_defined(Poppler::AnnotationMarkup, :subject)
+    assert_method_defined(Poppler::AnnotationMarkup, :reply_to)
+    assert_method_defined(Poppler::AnnotationMarkup, :external_data)
+  end
+
+  def test_text
+    only_poppler_version(0, 7, 2)
+    # We don't have a PDF that has annotation text...
+    assert_method_defined(Poppler::AnnotationText, :open?)
+    assert_method_defined(Poppler::AnnotationText, :icon)
+    assert_method_defined(Poppler::AnnotationText, :state)
+  end
+
+  def test_free_text
+    only_poppler_version(0, 7, 2)
+    # We don't have a PDF that has annotation free text...
+    assert_method_defined(Poppler::AnnotationFreeText, :quadding)
+    assert_method_defined(Poppler::AnnotationFreeText, :callout_line)
+  end
+
+  def test_callout_line
+    only_poppler_version(0, 7, 2)
+    callout_line = Poppler::AnnotationCalloutLine.new(true,
+                                                      1.1, 2.2, 3.3,
+                                                      4.4, 5.5, 6.6)
+    assert(callout_line.multiline?)
+    assert_equal(1.1, callout_line.x1)
+    assert_equal(2.2, callout_line.y1)
+    assert_equal(3.3, callout_line.x2)
+    assert_equal(4.4, callout_line.y2)
+    assert_equal(5.5, callout_line.x3)
+    assert_equal(6.6, callout_line.y3)
+    assert_equal([true, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6], callout_line.to_a)
+  end
+
+  private
+  def annotation
+    document = Poppler::Document.new(form_pdf)
+    page = document[0]
+    page.annotation_mapping[0].annotation
+  end
+
+  def assert_method_defined(object, method)
+    assert_send([object, :method_defined?, method])
+  end
+end

data/test/test_color.rb

@@ -0,0 +1,26 @@
+class TestColor < Test::Unit::TestCase
+  def test_initialize
+    only_poppler_version(0, 7, 2)
+    rose = Poppler::Color.new(65535, 0, 32639)
+    assert_equal([65535, 0, 32639], [rose.red, rose.green, rose.blue])
+    assert_equal([65535, 0, 32639], rose.to_a)
+  end
+
+  def test_accessor
+    only_poppler_version(0, 7, 2)
+    white = Poppler::Color.new(65535, 65535, 65535)
+    red = white.dup
+    red.green = 0
+    red.blue = 0
+    assert_equal([65535, 65535, 65535], [white.red, white.green, white.blue])
+    assert_equal([65535, 0, 0], [red.red, red.green, red.blue])
+  end
+
+  def test_inspect
+    only_poppler_version(0, 7, 2)
+    color = Poppler::Color.new(0, 32767, 65535)
+    rgb = '[0, 32767, 65535]'
+    assert_match(/\A#<Poppler::Color:.*: #{Regexp.escape(rgb)}>\z/,
+                 color.inspect)
+  end
+end

data/test/test_constants.rb

@@ -0,0 +1,30 @@
+class TestConstants < Test::Unit::TestCase
+  def test_annotation
+    if later_version?(0, 7, 2)
+      assertion = :assert_const_defined
+    else
+      assertion = :assert_not_const_defined
+    end
+    send(assertion, Poppler, :AnnotationType)
+    if assertion == :assert_const_defined
+      assert_equal("3d", Poppler::AnnotationType::TYPE_3D.nick)
+    end
+    send(assertion, Poppler, :AnnotationFlag)
+    send(assertion, Poppler, :AnnotationMarkupReplyType)
+    send(assertion, Poppler, :AnnotationExternalDataType)
+    if assertion == :assert_const_defined
+      assert_equal("3d", Poppler::AnnotationExternalDataType::TYPE_3D.nick)
+    end
+    if later_version?(0, 9, 0)
+      assert_not_const_defined(Poppler, :AnnotationTextIcon)
+    else
+      send(assertion, Poppler, :AnnotationTextIcon)
+    end
+    send(assertion, Poppler, :AnnotationTextState)
+    send(assertion, Poppler, :AnnotationFreeTextQuadding)
+  end
+
+  def test_permissions
+    assert_const_defined(Poppler, :Permissions)
+  end
+end