poppler 0.20.0

data/src/rbpoppler-annotation.c

@@ -0,0 +1,307 @@
+/* -*- c-file-style: "ruby" -*- */
+/**********************************************************************
+
+  rbpoppler-annotation.c -
+
+  Copyright (C) 2008 Ruby-GNOME2 Project Team
+
+**********************************************************************/
+
+#include "rbpoppler-private.h"
+
+#define SELF(self) (POPPLER_ANNOT(RVAL2GOBJ(self)))
+
+#define TYPE2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_ANNOT_TYPE))
+#define FLAG2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_ANNOT_FLAG))
+#define REPLY_TYPE2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_ANNOT_MARKUP_REPLY_TYPE))
+#define DATA_TYPE2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_ANNOT_EXTERNAL_DATA_TYPE))
+#define TEXT_ICON2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_ANNOT_TEXT_ICON))
+#define TEXT_STATE2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_ANNOT_TEXT_STATE))
+#define QUADDING2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_ANNOT_FREE_TEXT_QUADDING))
+#define LINE2RVAL(obj) (BOXED2RVAL(obj, POPPLER_TYPE_ANNOT_CALLOUT_LINE))
+#define RVAL2LINE(obj) ((PopplerAnnotCalloutLine *)RVAL2BOXED(obj, POPPLER_TYPE_ANNOT_CALLOUT_LINE))
+
+static VALUE rb_cDate;
+static ID id_new;
+
+
+static VALUE
+annot_get_annot_type(VALUE self)
+{
+    return TYPE2RVAL(poppler_annot_get_annot_type(SELF(self)));
+}
+
+static VALUE
+annot_get_contents(VALUE self)
+{
+    return CSTR2RVAL_FREE(poppler_annot_get_contents(SELF(self)));
+}
+
+static VALUE
+annot_get_name(VALUE self)
+{
+    return CSTR2RVAL_FREE(poppler_annot_get_name(SELF(self)));
+}
+
+static VALUE
+annot_get_modified(VALUE self)
+{
+    return CSTR2RVAL_FREE(poppler_annot_get_modified(SELF(self)));
+}
+
+static VALUE
+annot_get_flags(VALUE self)
+{
+    return FLAG2RVAL(poppler_annot_get_flags(SELF(self)));
+}
+
+static VALUE
+annot_get_color(VALUE self)
+{
+    return POPPLER_COLOR2RVAL_FREE(poppler_annot_get_color(SELF(self)));
+}
+
+/* PopplerAnnotMarkup */
+#undef SELF
+#define SELF(self) (POPPLER_ANNOT_MARKUP(RVAL2GOBJ(self)))
+
+static VALUE
+annot_markup_get_label(VALUE self)
+{
+    return CSTR2RVAL_FREE(poppler_annot_markup_get_label(SELF(self)));
+}
+
+static VALUE
+annot_markup_get_popup_is_open(VALUE self)
+{
+    return CBOOL2RVAL(poppler_annot_markup_get_popup_is_open(SELF(self)));
+}
+
+static VALUE
+annot_markup_get_opacity(VALUE self)
+{
+    return rb_float_new(poppler_annot_markup_get_opacity(SELF(self)));
+}
+
+static VALUE
+annot_markup_get_date(VALUE self)
+{
+    GDate *date;
+    VALUE rb_date;
+
+    date = poppler_annot_markup_get_date(SELF(self));
+    rb_date = rb_funcall(rb_cDate, id_new, 3,
+                         UINT2NUM(g_date_get_year(date)),
+                         UINT2NUM(g_date_get_month(date)),
+                         UINT2NUM(g_date_get_day(date)));
+    g_date_free(date);
+    return rb_date;
+}
+
+static VALUE
+annot_markup_get_subject(VALUE self)
+{
+    return CSTR2RVAL_FREE(poppler_annot_markup_get_subject(SELF(self)));
+}
+
+static VALUE
+annot_markup_get_reply_to(VALUE self)
+{
+    return REPLY_TYPE2RVAL(poppler_annot_markup_get_reply_to(SELF(self)));
+}
+
+static VALUE
+annot_markup_get_external_data(VALUE self)
+{
+    return DATA_TYPE2RVAL(poppler_annot_markup_get_external_data(SELF(self)));
+}
+
+/* PopplerAnnotText */
+#undef SELF
+#define SELF(self) (POPPLER_ANNOT_TEXT(RVAL2GOBJ(self)))
+
+static VALUE
+annot_text_get_is_open(VALUE self)
+{
+    return CBOOL2RVAL(poppler_annot_text_get_is_open(SELF(self)));
+}
+
+static VALUE
+annot_text_get_icon(VALUE self)
+{
+#if POPPLER_CHECK_VERSION(0, 9, 0)
+    return CSTR2RVAL_FREE(poppler_annot_text_get_icon(SELF(self)));
+#else
+    return TEXT_ICON2RVAL(poppler_annot_text_get_icon(SELF(self)));
+#endif
+}
+
+static VALUE
+annot_text_get_state(VALUE self)
+{
+    return TEXT_STATE2RVAL(poppler_annot_text_get_state(SELF(self)));
+}
+
+/* PopplerAnnotFreeText */
+#undef SELF
+#define SELF(self) (POPPLER_ANNOT_FREE_TEXT(RVAL2GOBJ(self)))
+
+static VALUE
+annot_free_text_get_quadding(VALUE self)
+{
+    return QUADDING2RVAL(poppler_annot_free_text_get_quadding(SELF(self)));
+}
+
+static VALUE
+annot_free_text_get_callout_line(VALUE self)
+{
+    return LINE2RVAL(poppler_annot_free_text_get_callout_line(SELF(self)));
+}
+
+/* PopplerCalloutLine */
+static VALUE
+annot_callout_line_initialize(VALUE self, VALUE multiline, VALUE x1, VALUE y1,
+                              VALUE x2, VALUE y2, VALUE x3, VALUE y3)
+{
+    PopplerAnnotCalloutLine *line;
+
+    line = poppler_annot_callout_line_new();
+    line->multiline = RVAL2CBOOL(multiline);
+    line->x1 = NUM2DBL(x1);
+    line->y1 = NUM2DBL(y1);
+    line->x2 = NUM2DBL(x2);
+    line->y2 = NUM2DBL(y2);
+    line->x3 = NUM2DBL(x3);
+    line->y3 = NUM2DBL(y3);
+
+    G_INITIALIZE(self, line);
+    return Qnil;
+}
+
+DEF_ACCESSOR(annot_callout_line, multiline, RVAL2LINE, CBOOL2RVAL, RVAL2CBOOL)
+DEF_ACCESSOR(annot_callout_line, x1, RVAL2LINE, rb_float_new, NUM2DBL)
+DEF_ACCESSOR(annot_callout_line, y1, RVAL2LINE, rb_float_new, NUM2DBL)
+DEF_ACCESSOR(annot_callout_line, x2, RVAL2LINE, rb_float_new, NUM2DBL)
+DEF_ACCESSOR(annot_callout_line, y2, RVAL2LINE, rb_float_new, NUM2DBL)
+DEF_ACCESSOR(annot_callout_line, x3, RVAL2LINE, rb_float_new, NUM2DBL)
+DEF_ACCESSOR(annot_callout_line, y3, RVAL2LINE, rb_float_new, NUM2DBL)
+
+static VALUE
+annot_callout_line_to_a(VALUE self)
+{
+    PopplerAnnotCalloutLine *line;
+
+    line = RVAL2LINE(self);
+    return rb_ary_new3(7,
+                       CBOOL2RVAL(line->multiline),
+                       rb_float_new(line->x1),
+                       rb_float_new(line->y1),
+                       rb_float_new(line->x2),
+                       rb_float_new(line->y2),
+                       rb_float_new(line->x3),
+                       rb_float_new(line->y3));
+}
+
+static VALUE
+annot_callout_line_inspect(VALUE self)
+{
+    VALUE inspected;
+    gchar *info;
+    PopplerAnnotCalloutLine *line;
+
+    line = RVAL2LINE(self);
+    inspected = rb_call_super(0, NULL);
+    rb_str_resize(inspected, RSTRING_LEN(inspected) - 1);
+    info = g_strdup_printf(": [%s, %g, %g, %g, %g, %g, %g]>",
+                           line->multiline ? "true" : "false",
+                           line->x1, line->y1,
+                           line->x2, line->y2,
+                           line->x3, line->y3);
+    rb_str_cat2(inspected, info);
+    g_free(info);
+    return inspected;
+}
+
+void
+Init_poppler_annotation(VALUE mPoppler)
+{
+    VALUE cAnnotation, cAnnotationMarkup, cAnnotationText;
+    VALUE cAnnotationFreeText, cAnnotationCalloutLine;
+
+    id_new = rb_intern("new");
+    rb_cDate = rb_const_get(rb_cObject, rb_intern("Date"));
+
+    cAnnotation = G_DEF_CLASS(POPPLER_TYPE_ANNOT, "Annotation", mPoppler);
+    rb_define_method(cAnnotation, "type", annot_get_annot_type, 0);
+    rb_define_method(cAnnotation, "contents", annot_get_contents, 0);
+    rb_define_method(cAnnotation, "name", annot_get_name, 0);
+    rb_define_method(cAnnotation, "modified", annot_get_modified, 0);
+    rb_define_method(cAnnotation, "flags", annot_get_flags, 0);
+    rb_define_method(cAnnotation, "color", annot_get_color, 0);
+
+    cAnnotationMarkup = G_DEF_CLASS(POPPLER_TYPE_ANNOT_MARKUP,
+                                    "AnnotationMarkup", mPoppler);
+    rb_define_method(cAnnotationMarkup, "label", annot_markup_get_label, 0);
+    rb_define_method(cAnnotationMarkup, "popup_is_open?",
+                     annot_markup_get_popup_is_open, 0);
+    rb_define_method(cAnnotationMarkup, "opacity", annot_markup_get_opacity, 0);
+    rb_define_method(cAnnotationMarkup, "date", annot_markup_get_date, 0);
+    rb_define_method(cAnnotationMarkup, "subject", annot_markup_get_subject, 0);
+    rb_define_method(cAnnotationMarkup, "reply_to",
+                     annot_markup_get_reply_to, 0);
+    rb_define_method(cAnnotationMarkup, "external_data",
+                     annot_markup_get_external_data, 0);
+
+    cAnnotationText = G_DEF_CLASS(POPPLER_TYPE_ANNOT_TEXT,
+                                  "AnnotationText", mPoppler);
+    rb_define_method(cAnnotationText, "open?", annot_text_get_is_open, 0);
+    rb_define_method(cAnnotationText, "icon", annot_text_get_icon, 0);
+    rb_define_method(cAnnotationText, "state", annot_text_get_state, 0);
+
+    cAnnotationFreeText = G_DEF_CLASS(POPPLER_TYPE_ANNOT_FREE_TEXT,
+                                      "AnnotationFreeText", mPoppler);
+    rb_define_method(cAnnotationFreeText, "quadding",
+                     annot_free_text_get_quadding, 0);
+    rb_define_method(cAnnotationFreeText, "callout_line",
+                     annot_free_text_get_callout_line, 0);
+
+    cAnnotationCalloutLine = G_DEF_CLASS(POPPLER_TYPE_ANNOT_CALLOUT_LINE,
+                                         "AnnotationCalloutLine", mPoppler);
+    rb_define_method(cAnnotationCalloutLine, "initialize",
+                     annot_callout_line_initialize, 7);
+
+    rb_define_method(cAnnotationCalloutLine, "multiline?",
+                     annot_callout_line_get_multiline, 0);
+    rb_define_method(cAnnotationCalloutLine, "set_multiline",
+                     annot_callout_line_set_multiline, 1);
+    rb_define_method(cAnnotationCalloutLine, "x1",
+                     annot_callout_line_get_x1, 0);
+    rb_define_method(cAnnotationCalloutLine, "set_x1",
+                     annot_callout_line_set_x1, 1);
+    rb_define_method(cAnnotationCalloutLine, "y1",
+                     annot_callout_line_get_y1, 0);
+    rb_define_method(cAnnotationCalloutLine, "set_y1",
+                     annot_callout_line_set_y1, 1);
+    rb_define_method(cAnnotationCalloutLine, "x2",
+                     annot_callout_line_get_x2, 0);
+    rb_define_method(cAnnotationCalloutLine, "set_x2",
+                     annot_callout_line_set_x2, 2);
+    rb_define_method(cAnnotationCalloutLine, "y2",
+                     annot_callout_line_get_y2, 0);
+    rb_define_method(cAnnotationCalloutLine, "set_y2",
+                     annot_callout_line_set_y2, 2);
+    rb_define_method(cAnnotationCalloutLine, "x3",
+                     annot_callout_line_get_x3, 0);
+    rb_define_method(cAnnotationCalloutLine, "set_x3",
+                     annot_callout_line_set_x3, 3);
+    rb_define_method(cAnnotationCalloutLine, "y3",
+                     annot_callout_line_get_y3, 0);
+    rb_define_method(cAnnotationCalloutLine, "set_y3",
+                     annot_callout_line_set_y3, 3);
+
+    rb_define_method(cAnnotationCalloutLine, "to_a", annot_callout_line_to_a, 0);
+    rb_define_method(cAnnotationCalloutLine, "inspect",
+                     annot_callout_line_inspect, 0);
+
+    G_DEF_SETTERS(cAnnotationCalloutLine);
+}

data/src/rbpoppler-attachment.c

@@ -0,0 +1,116 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbpoppler-attachment.c -
+
+  $Author: ktou $
+  $Date: 2007/10/13 05:53:10 $
+
+  Copyright (C) 2006 Ruby-GNOME2 Project Team
+
+**********************************************************************/
+
+#include "rbpoppler.h"
+
+#define SELF(self) ((PopplerAttachment *)RVAL2GOBJ(self))
+
+static ID id_call;
+
+static gboolean
+attachment_save_func(const gchar *buf, gsize count, gpointer data,
+                     GError **error)
+{
+    VALUE result;
+    VALUE callback = (VALUE)data;
+
+    result = rb_funcall(callback, id_call, 1, rb_str_new(buf, count));
+    return RVAL2CBOOL(result);
+}
+
+static VALUE
+attachment_save(int argc, VALUE *argv, VALUE self)
+{
+    VALUE filename;
+    gboolean result;
+    GError *error = NULL;
+
+    rb_scan_args(argc, argv, "01", &filename);
+
+    if (NIL_P(filename)) {
+        if (rb_block_given_p()) {
+            gpointer user_data = (gpointer)rb_block_proc();
+            result = poppler_attachment_save_to_callback(SELF(self),
+                                                         attachment_save_func,
+                                                         user_data,
+                                                         &error);
+        } else {
+            rb_raise(rb_eArgError, "must provide filename or block");
+        }
+    } else {
+        result = poppler_attachment_save(SELF(self), RVAL2CSTR(filename),
+                                         &error);
+    }
+
+    if (error)
+        RAISE_GERROR(error);
+
+    return CBOOL2RVAL(result);
+}
+
+static VALUE
+attachment_get_name(VALUE self)
+{
+    return CSTR2RVAL(SELF(self)->name);
+}
+
+static VALUE
+attachment_get_description(VALUE self)
+{
+    return CSTR2RVAL(SELF(self)->description);
+}
+
+static VALUE
+attachment_get_size(VALUE self)
+{
+    return INT2NUM(SELF(self)->size);
+}
+
+static VALUE
+attachment_get_mtime(VALUE self)
+{
+    return rb_time_new(SELF(self)->mtime, 0);
+}
+
+static VALUE
+attachment_get_ctime(VALUE self)
+{
+    return rb_time_new(SELF(self)->ctime, 0);
+}
+
+static VALUE
+attachment_get_checksum(VALUE self)
+{
+    GString *checksum;
+    checksum = SELF(self)->checksum;
+    return rb_str_new(checksum->str, checksum->len);
+}
+
+void
+Init_poppler_attachment(VALUE mPoppler)
+{
+    VALUE cAttachment;
+
+    id_call = rb_intern("call");
+
+    cAttachment = G_DEF_CLASS(POPPLER_TYPE_ATTACHMENT, "Attachment", mPoppler);
+
+    rb_define_method(cAttachment, "save", attachment_save, -1);
+    rb_define_method(cAttachment, "name", attachment_get_name, 0);
+    rb_define_method(cAttachment, "description", attachment_get_description, 0);
+    rb_define_method(cAttachment, "size", attachment_get_size, 0);
+    rb_define_method(cAttachment, "mtime", attachment_get_mtime, 0);
+    rb_define_method(cAttachment, "ctime", attachment_get_ctime, 0);
+    rb_define_method(cAttachment, "checksum", attachment_get_checksum, 0);
+
+    G_DEF_SETTERS(cAttachment);
+}

data/src/rbpoppler-document.c

@@ -0,0 +1,492 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbpoppler-document.c -
+
+  $Author: ktou $
+  $Date: 2007/10/13 05:56:39 $
+
+  Copyright (C) 2006 Ruby-GNOME2 Project Team
+
+**********************************************************************/
+
+#include "rbpoppler.h"
+
+#define RVAL2DOC(obj) (POPPLER_DOCUMENT(RVAL2GOBJ(obj)))
+
+#define IITER2RVAL(obj) (BOXED2RVAL(obj, POPPLER_TYPE_INDEX_ITER))
+#define RVAL2IITER(obj) (RVAL2BOXED(obj, POPPLER_TYPE_INDEX_ITER))
+#define FITER2RVAL(obj) (BOXED2RVAL(obj, POPPLER_TYPE_FONTS_ITER))
+#define RVAL2FITER(obj) (RVAL2BOXED(obj, POPPLER_TYPE_FONTS_ITER))
+
+static ID id_new, id_valid, id_pdf_data_p, id_ensure_uri;
+static VALUE cIndexIter;
+static VALUE cFontInfo;
+
+
+static VALUE
+doc_initialize(int argc, VALUE *argv, VALUE self)
+{
+    PopplerDocument *document = NULL;
+    GError *error = NULL;
+    VALUE uri_or_data, rb_password;
+    const char *password;
+
+    rb_scan_args(argc, argv, "11", &uri_or_data, &rb_password);
+
+    password = NIL_P(rb_password) ? NULL : RVAL2CSTR(rb_password);
+
+    if (RVAL2CBOOL(rb_funcall(self, id_pdf_data_p, 1, uri_or_data))) {
+        document = poppler_document_new_from_data(RSTRING_PTR(uri_or_data),
+                                                  RSTRING_LEN(uri_or_data),
+                                                  password, &error);
+    }
+
+    if (!document && !error) {
+        uri_or_data = rb_funcall(self, id_ensure_uri, 1, uri_or_data);
+        document = poppler_document_new_from_file(RVAL2CSTR(uri_or_data),
+                                                  password, &error);
+    }
+
+    if (error)
+        RAISE_GERROR(error);
+
+    G_INITIALIZE(self, document);
+    return Qnil;
+}
+
+static VALUE
+doc_save(VALUE self, VALUE uri)
+{
+    gboolean result;
+    GError *error = NULL;
+
+    uri = rb_funcall(self, id_ensure_uri, 1, uri);
+    result = poppler_document_save(RVAL2DOC(self), RVAL2CSTR(uri), &error);
+
+    if (error)
+        RAISE_GERROR(error);
+
+    return CBOOL2RVAL(result);
+}
+
+static VALUE
+doc_save_a_copy(VALUE self, VALUE uri)
+{
+    gboolean result;
+    GError *error = NULL;
+
+    uri = rb_funcall(self, id_ensure_uri, 1, uri);
+    result = poppler_document_save_a_copy(RVAL2DOC(self), RVAL2CSTR(uri),
+					  &error);
+
+    if (error)
+        RAISE_GERROR(error);
+
+    return CBOOL2RVAL(result);
+}
+
+static VALUE
+doc_get_n_pages(VALUE self)
+{
+    return INT2NUM(poppler_document_get_n_pages(RVAL2DOC(self)));
+}
+
+static VALUE
+doc_get_page(VALUE self, VALUE index_or_label)
+{
+    VALUE rb_page;
+    PopplerPage *page;
+
+    if (RVAL2CBOOL(rb_obj_is_kind_of(index_or_label, rb_cInteger))) {
+        page = poppler_document_get_page(RVAL2DOC(self),
+                                         NUM2INT(index_or_label));
+    } else if (RVAL2CBOOL(rb_obj_is_kind_of(index_or_label, rb_cString))) {
+        page = poppler_document_get_page_by_label(RVAL2DOC(self),
+                                                  RVAL2CSTR(index_or_label));
+    } else {
+        VALUE inspect;
+        inspect = rb_inspect(index_or_label);
+        rb_raise(rb_eArgError, "%s must be Integer or String",
+                 RVAL2CSTR(inspect));
+    }
+
+    rb_page = GOBJ2RVAL(page);
+    if (page)
+        g_object_unref(page);
+    return rb_page;
+}
+
+static VALUE
+doc_has_attachments(VALUE self)
+{
+    return CBOOL2RVAL(poppler_document_has_attachments(RVAL2DOC(self)));
+}
+
+static VALUE
+doc_get_attachments(VALUE self)
+{
+    return GLIST2ARYF(poppler_document_get_attachments(RVAL2DOC(self)));
+}
+
+static VALUE
+doc_find_dest(VALUE self, VALUE link_name)
+{
+    return GOBJ2RVAL(poppler_document_find_dest(RVAL2DOC(self),
+                                                RVAL2CSTR(link_name)));
+}
+
+static VALUE
+doc_get_form_field(VALUE self, VALUE id)
+{
+    return GOBJ2RVAL(poppler_document_get_form_field(RVAL2DOC(self),
+                                                     NUM2INT(id)));
+}
+
+static VALUE
+doc_each(VALUE self)
+{
+    PopplerDocument *document;
+    int i, n_pages;
+
+    document = RVAL2DOC(self);
+    n_pages = poppler_document_get_n_pages(document);
+    for (i = 0; i < n_pages; i++) {
+        PopplerPage *page;
+        VALUE rb_page;
+
+        page = poppler_document_get_page(document, i);
+        rb_page = GOBJ2RVAL(page);
+        if (page)
+            g_object_unref(page);
+        rb_yield(rb_page);
+    }
+    return self;
+}
+
+static VALUE
+doc_get_index_iter(VALUE self)
+{
+    return rb_funcall(cIndexIter, id_new, 1, self);
+}
+
+static VALUE
+doc_get_font_info(VALUE self)
+{
+    return rb_funcall(cFontInfo, id_new, 1, self);
+}
+
+
+
+/* Interface for getting the Index of a poppler_document */
+#define CHECK_IITER_IS_VALID(iter) do {         \
+    if (!RVAL2CBOOL(index_iter_valid_p(iter)))       \
+        return Qnil;                            \
+} while (0)
+
+static VALUE
+index_iter_valid_p(VALUE self)
+{
+    return rb_ivar_get(self, id_valid);
+}
+
+static VALUE
+index_iter_initialize(VALUE self, VALUE document)
+{
+    PopplerIndexIter *iter;
+    iter = poppler_index_iter_new(RVAL2GOBJ(document));
+    G_INITIALIZE(self, iter);
+    poppler_index_iter_free(iter);
+    rb_ivar_set(self, id_valid, CBOOL2RVAL(iter));
+    return Qnil;
+}
+
+static VALUE
+index_iter_get_child(VALUE self)
+{
+    PopplerIndexIter *child;
+    VALUE rb_child;
+
+    CHECK_IITER_IS_VALID(self);
+    child = poppler_index_iter_get_child(RVAL2IITER(self));
+    rb_child = IITER2RVAL(child);
+    poppler_index_iter_free(child);
+    return rb_child;
+}
+
+static VALUE
+index_iter_is_open(VALUE self)
+{
+    CHECK_IITER_IS_VALID(self);
+    return CBOOL2RVAL(poppler_index_iter_is_open(RVAL2IITER(self)));
+}
+
+#ifndef HAVE_TYPE_POPPLERACTIONANY
+static VALUE
+index_iter_get_action(VALUE self)
+{
+    CHECK_IITER_IS_VALID(self);
+    return POPPLER_ACTION2RVAL(poppler_index_iter_get_action(RVAL2IITER(self)));
+}
+#endif
+
+static VALUE
+index_iter_next(VALUE self)
+{
+    if (poppler_index_iter_next(RVAL2IITER(self))) {
+        return Qtrue;
+    } else {
+        rb_ivar_set(self, id_valid, Qfalse);
+        return Qfalse;
+    }
+}
+
+static VALUE
+index_iter_each(VALUE self)
+{
+    PopplerIndexIter *iter;
+
+    CHECK_IITER_IS_VALID(self);
+    iter = RVAL2IITER(self);
+    do {
+        rb_yield(self);
+    } while (poppler_index_iter_next(iter));
+    rb_ivar_set(self, id_valid, Qfalse);
+
+    return self;
+}
+
+
+#if POPPLER_CHECK_VERSION(0, 6, 0)
+
+static VALUE
+font_info_initialize(VALUE self, VALUE document)
+{
+    G_INITIALIZE(self, poppler_font_info_new(RVAL2GOBJ(document)));
+    return Qnil;
+}
+
+static VALUE
+font_info_scan(VALUE self, VALUE n_pages)
+{
+    VALUE rb_iter = Qnil;
+    PopplerFontsIter *iter;
+
+    if (poppler_font_info_scan(RVAL2GOBJ(self), NUM2INT(n_pages), &iter)) {
+        rb_iter = FITER2RVAL(iter);
+        rb_ivar_set(rb_iter, id_valid, Qtrue);
+        poppler_fonts_iter_free(iter);
+    }
+    return rb_iter;
+}
+#endif
+
+
+#define CHECK_FITER_IS_VALID(iter) do {         \
+    if (!RVAL2CBOOL(fonts_iter_valid_p(iter)))       \
+        return Qnil;                            \
+} while (0)
+
+static VALUE
+fonts_iter_valid_p(VALUE self)
+{
+    return rb_ivar_get(self, id_valid);
+}
+
+static VALUE
+fonts_iter_get_name(VALUE self)
+{
+    CHECK_FITER_IS_VALID(self);
+    return CSTR2RVAL(poppler_fonts_iter_get_name(RVAL2FITER(self)));
+}
+
+static VALUE
+fonts_iter_get_full_name(VALUE self)
+{
+    CHECK_FITER_IS_VALID(self);
+    return CSTR2RVAL(poppler_fonts_iter_get_full_name(RVAL2FITER(self)));
+}
+
+static VALUE
+fonts_iter_get_file_name(VALUE self)
+{
+    CHECK_FITER_IS_VALID(self);
+    return CSTR2RVAL(poppler_fonts_iter_get_file_name(RVAL2FITER(self)));
+}
+
+static VALUE
+fonts_iter_get_font_type(VALUE self)
+{
+    CHECK_FITER_IS_VALID(self);
+    return GENUM2RVAL(poppler_fonts_iter_get_font_type(RVAL2FITER(self)),
+                      POPPLER_TYPE_FONT_TYPE);
+}
+
+static VALUE
+fonts_iter_is_embedded(VALUE self)
+{
+    CHECK_FITER_IS_VALID(self);
+    return CBOOL2RVAL(poppler_fonts_iter_is_embedded(RVAL2FITER(self)));
+}
+
+static VALUE
+fonts_iter_is_subset(VALUE self)
+{
+    CHECK_FITER_IS_VALID(self);
+    return CBOOL2RVAL(poppler_fonts_iter_is_subset(RVAL2FITER(self)));
+}
+
+static VALUE
+fonts_iter_next(VALUE self)
+{
+    if (poppler_fonts_iter_next(RVAL2FITER(self))) {
+        return Qtrue;
+    } else {
+        rb_ivar_set(self, id_valid, Qfalse);
+        return Qfalse;
+    }
+}
+
+static VALUE
+fonts_iter_each(VALUE self)
+{
+    PopplerFontsIter *iter;
+
+    CHECK_FITER_IS_VALID(self);
+    iter = RVAL2FITER(self);
+    do {
+        rb_yield(self);
+    } while (poppler_fonts_iter_next(iter));
+    rb_ivar_set(self, id_valid, Qfalse);
+
+    return self;
+}
+
+
+/* Export to ps */
+static VALUE
+ps_file_initialize(VALUE self, VALUE document, VALUE filename,
+                   VALUE first_page, VALUE n_pages)
+{
+    PopplerPSFile *ps_file;
+
+    ps_file = poppler_ps_file_new(RVAL2GOBJ(document), RVAL2CSTR(filename),
+                                  NUM2INT(first_page), NUM2INT(n_pages));
+
+    if (!ps_file)
+        rb_raise(rb_eRuntimeError, "can't create Poppler::PSFile");
+
+    G_INITIALIZE(self, ps_file);
+    return Qnil;
+}
+
+static VALUE
+ps_file_set_paper_size(VALUE self, VALUE width, VALUE height)
+{
+    poppler_ps_file_set_paper_size(RVAL2GOBJ(self),
+                                   NUM2DBL(width), NUM2DBL(height));
+    return Qnil;
+}
+
+static VALUE
+ps_file_set_duplex(VALUE self, VALUE duplex)
+{
+    poppler_ps_file_set_duplex(RVAL2GOBJ(self), RVAL2CBOOL(duplex));
+    return Qnil;
+}
+
+void
+Init_poppler_document(VALUE mPoppler)
+{
+    VALUE cDocument, cFontsIter, cPSFile;
+
+    id_new = rb_intern("new");
+    id_valid = rb_intern("valid?");
+    id_pdf_data_p = rb_intern("pdf_data?");
+    id_ensure_uri = rb_intern("ensure_uri");
+
+    cDocument = G_DEF_CLASS(POPPLER_TYPE_DOCUMENT, "Document", mPoppler);
+    cIndexIter = G_DEF_CLASS(POPPLER_TYPE_INDEX_ITER, "IndexIter", mPoppler);
+    cFontInfo = G_DEF_CLASS(POPPLER_TYPE_FONT_INFO, "FontInfo", mPoppler);
+    cFontsIter = G_DEF_CLASS(POPPLER_TYPE_FONTS_ITER, "FontsIter", mPoppler);
+    cPSFile = G_DEF_CLASS(POPPLER_TYPE_PS_FILE, "PSFile", mPoppler);
+
+    G_DEF_CLASS(POPPLER_TYPE_PAGE_LAYOUT, "PageLayout", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_PAGE_MODE, "PageMode", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_FONT_TYPE, "FontType", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_VIEWER_PREFERENCES, "ViewerPreferences", mPoppler);
+    G_DEF_CLASS(POPPLER_TYPE_PERMISSIONS, "Permissions", mPoppler);
+
+    rb_include_module(cDocument, rb_mEnumerable);
+
+    rb_define_method(cDocument, "initialize", doc_initialize, -1);
+    rb_define_method(cDocument, "save", doc_save, 1);
+    rb_define_method(cDocument, "save_a_copy", doc_save_a_copy, 1);
+    rb_define_method(cDocument, "n_pages", doc_get_n_pages, 0);
+    rb_define_alias(cDocument, "size", "n_pages");
+    rb_define_method(cDocument, "get_page", doc_get_page, 1);
+    rb_define_alias(cDocument, "[]", "get_page");
+    rb_define_method(cDocument, "has_attachments?", doc_has_attachments, 0);
+    rb_define_alias(cDocument, "have_attachments?", "has_attachments?");
+    rb_define_method(cDocument, "attachments", doc_get_attachments, 0);
+    rb_define_method(cDocument, "find_dest", doc_find_dest, 1);
+    rb_define_alias(cDocument, "get_destination", "find_dest");
+
+    rb_define_method(cDocument, "get_form_field", doc_get_form_field, 1);
+
+    rb_define_method(cDocument, "each", doc_each, 0);
+    rb_define_alias(cDocument, "pages", "to_a");
+
+    rb_define_method(cDocument, "index_iter", doc_get_index_iter, 0);
+    rb_define_method(cDocument, "font_info", doc_get_font_info, 0);
+
+    G_DEF_SETTERS(cDocument);
+
+
+/* Interface for getting the Index of a poppler_document */
+    rb_include_module(cIndexIter, rb_mEnumerable);
+
+    rb_define_method(cIndexIter, "initialize", index_iter_initialize, 1);
+    rb_define_method(cIndexIter, "child", index_iter_get_child, 0);
+    rb_define_method(cIndexIter, "open?", index_iter_is_open, 0);
+#ifndef HAVE_TYPE_POPPLERACTIONANY
+    rb_define_method(cIndexIter, "action", index_iter_get_action, 0);
+#endif
+    rb_define_method(cIndexIter, "next", index_iter_next, 0);
+
+    rb_define_method(cIndexIter, "valid?", index_iter_valid_p, 0);
+    rb_define_method(cIndexIter, "each", index_iter_each, 0);
+
+    G_DEF_SETTERS(cIndexIter);
+
+
+#if POPPLER_CHECK_VERSION(0, 6, 0)
+    rb_define_method(cFontInfo, "initialize", font_info_initialize, 1);
+    rb_define_method(cFontInfo, "scan", font_info_scan, 1);
+    G_DEF_SETTERS(cFontInfo);
+#endif
+
+    rb_include_module(cFontsIter, rb_mEnumerable);
+
+    rb_define_method(cFontsIter, "name", fonts_iter_get_name, 0);
+    rb_define_method(cFontsIter, "full_name", fonts_iter_get_full_name, 0);
+#if POPPLER_CHECK_VERSION(0, 6, 0)
+    rb_define_method(cFontsIter, "file_name", fonts_iter_get_file_name, 0);
+#endif
+    rb_define_method(cFontsIter, "font_type", fonts_iter_get_font_type, 0);
+    rb_define_method(cFontsIter, "embedded?", fonts_iter_is_embedded, 0);
+    rb_define_method(cFontsIter, "subset?", fonts_iter_is_subset, 0);
+    rb_define_method(cFontsIter, "next", fonts_iter_next, 0);
+
+    rb_define_method(cFontsIter, "valid?", fonts_iter_valid_p, 0);
+    rb_define_method(cFontsIter, "each", fonts_iter_each, 0);
+
+    G_DEF_SETTERS(cFontsIter);
+
+/* Export to ps */
+    rb_define_method(cPSFile, "initialize", ps_file_initialize, 4);
+    rb_define_method(cPSFile, "set_paper_size", ps_file_set_paper_size, 2);
+    rb_define_method(cPSFile, "set_duplex", ps_file_set_duplex, 1);
+
+    G_DEF_SETTERS(cPSFile);
+}