poppler 2.2.4-x64-mingw32

data/ext/poppler/rbpoppler-attachment.c

@@ -0,0 +1,124 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2006  Ruby-GNOME2 Project Team
+ *
+ *  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, or (at your option) any later version.
+ *
+ *  This library 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 this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbpoppler-private.h"
+
+#define RG_TARGET_NAMESPACE cAttachment
+#define SELF(self) (RVAL2POPPLERATTACHMENT(self))
+
+static ID id_call;
+
+static gboolean
+attachment_save_func(const gchar *buf, gsize count, gpointer data,
+                     G_GNUC_UNUSED 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
+rg_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
+rg_name(VALUE self)
+{
+    return CSTR2RVAL(SELF(self)->name);
+}
+
+static VALUE
+rg_description(VALUE self)
+{
+    return CSTR2RVAL(SELF(self)->description);
+}
+
+static VALUE
+rg_size(VALUE self)
+{
+    return INT2NUM(SELF(self)->size);
+}
+
+static VALUE
+rg_mtime(VALUE self)
+{
+    return rb_time_new(SELF(self)->mtime, 0);
+}
+
+static VALUE
+rg_ctime(VALUE self)
+{
+    return rb_time_new(SELF(self)->ctime, 0);
+}
+
+static VALUE
+rg_checksum(VALUE self)
+{
+    GString *checksum;
+    checksum = SELF(self)->checksum;
+    return rb_str_new(checksum->str, checksum->len);
+}
+
+void
+Init_poppler_attachment(VALUE mPoppler)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    id_call = rb_intern("call");
+
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(POPPLER_TYPE_ATTACHMENT, "Attachment", mPoppler);
+
+    RG_DEF_METHOD(save, -1);
+    RG_DEF_METHOD(name, 0);
+    RG_DEF_METHOD(description, 0);
+    RG_DEF_METHOD(size, 0);
+    RG_DEF_METHOD(mtime, 0);
+    RG_DEF_METHOD(ctime, 0);
+    RG_DEF_METHOD(checksum, 0);
+}

data/ext/poppler/rbpoppler-button-field.c

@@ -0,0 +1,56 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2008  Ruby-GNOME2 Project Team
+ *
+ *  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, or (at your option) any later version.
+ *
+ *  This library 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 this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbpoppler-private.h"
+
+#define RG_TARGET_NAMESPACE cButtonField
+#define _SELF(obj) RVAL2POPPLERFORMFIELD(obj)
+
+static VALUE RG_TARGET_NAMESPACE;
+
+static VALUE
+rg_type(VALUE self)
+{
+    return POPPLERFORMBUTTONTYPE2RVAL(poppler_form_field_button_get_button_type(_SELF(self)));
+}
+
+static VALUE
+rg_active_p(VALUE self)
+{
+    return CBOOL2RVAL(poppler_form_field_button_get_state(_SELF(self)));
+}
+
+static VALUE
+rg_set_active(VALUE self, VALUE state)
+{
+    poppler_form_field_button_set_state(_SELF(self), RVAL2CBOOL(state));
+    return Qnil;
+}
+
+void
+Init_poppler_button_field(VALUE mPoppler, VALUE cFormField)
+{
+    RG_TARGET_NAMESPACE = rb_define_class_under(mPoppler, "ButtonField", cFormField);
+
+    RG_DEF_METHOD(type, 0);
+    RG_DEF_METHOD_P(active, 0);
+    RG_DEF_METHOD(set_active, 1);
+}

data/ext/poppler/rbpoppler-choice-field.c

@@ -0,0 +1,131 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2008  Ruby-GNOME2 Project Team
+ *
+ *  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, or (at your option) any later version.
+ *
+ *  This library 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 this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbpoppler-private.h"
+
+#define RG_TARGET_NAMESPACE cChoiceField
+#define _SELF(obj) RVAL2POPPLERFORMFIELD(obj)
+
+static VALUE RG_TARGET_NAMESPACE;
+
+static VALUE
+rg_type(VALUE self)
+{
+    return POPPLERFORMCHOICETYPE2RVAL(poppler_form_field_choice_get_choice_type(_SELF(self)));
+}
+
+static VALUE
+rg_editable_p(VALUE self)
+{
+    return CBOOL2RVAL(poppler_form_field_choice_is_editable(_SELF(self)));
+}
+
+static VALUE
+rg_select_multiple_p(VALUE self)
+{
+    return CBOOL2RVAL(poppler_form_field_choice_can_select_multiple(_SELF(self)));
+}
+
+static VALUE
+rg_spell_check_p(VALUE self)
+{
+    return CBOOL2RVAL(poppler_form_field_choice_do_spell_check(_SELF(self)));
+}
+
+static VALUE
+rg_commit_on_change_p(VALUE self)
+{
+    return CBOOL2RVAL(poppler_form_field_choice_commit_on_change(_SELF(self)));
+}
+
+static VALUE
+rg_n_items(VALUE self)
+{
+    return INT2NUM(poppler_form_field_choice_get_n_items(_SELF(self)));
+}
+
+static VALUE
+rg_operator_choice_field_get_item(VALUE self, VALUE index)
+{
+    return CSTR2RVAL(poppler_form_field_choice_get_item(_SELF(self),
+                                                        NUM2INT(index)));
+}
+
+static VALUE
+rg_selected_p(VALUE self, VALUE index)
+{
+    return CBOOL2RVAL(poppler_form_field_choice_is_item_selected(_SELF(self),
+                                                                 NUM2INT(index)));
+}
+
+static VALUE
+rg_select(VALUE self, VALUE index)
+{
+    poppler_form_field_choice_select_item(_SELF(self), NUM2INT(index));
+    return Qnil;
+}
+
+static VALUE
+rg_unselect_all(VALUE self)
+{
+    poppler_form_field_choice_unselect_all(_SELF(self));
+    return Qnil;
+}
+
+static VALUE
+rg_toggle(VALUE self, VALUE index)
+{
+    poppler_form_field_choice_toggle_item(_SELF(self), NUM2INT(index));
+    return Qnil;
+}
+
+static VALUE
+rg_set_text(VALUE self, VALUE text)
+{
+    poppler_form_field_choice_set_text(_SELF(self), RVAL2CSTR_ACCEPT_NIL(text));
+    return Qnil;
+}
+
+static VALUE
+rg_text(VALUE self)
+{
+    return CSTR2RVAL(poppler_form_field_choice_get_text(_SELF(self)));
+}
+
+void
+Init_poppler_choice_field(VALUE mPoppler, VALUE cFormField)
+{
+    RG_TARGET_NAMESPACE = rb_define_class_under(mPoppler, "ChoiceField", cFormField);
+
+    RG_DEF_METHOD(type, 0);
+    RG_DEF_METHOD_P(editable, 0);
+    RG_DEF_METHOD_P(select_multiple, 0);
+    RG_DEF_METHOD_P(spell_check, 0);
+    RG_DEF_METHOD_P(commit_on_change, 0);
+    RG_DEF_METHOD(n_items, 0);
+    RG_DEF_METHOD_OPERATOR("[]", choice_field_get_item, 1);
+    RG_DEF_METHOD_P(selected, 1);
+    RG_DEF_METHOD(select, 1);
+    RG_DEF_METHOD(unselect_all, 0);
+    RG_DEF_METHOD(toggle, 1);
+    RG_DEF_METHOD(text, 0);
+    RG_DEF_METHOD(set_text, 1);
+}

data/ext/poppler/rbpoppler-color.c

@@ -0,0 +1,107 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011-2013  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2006-2008 Ruby-GNOME2 Project Team
+ *
+ *  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, or (at your option) any later version.
+ *
+ *  This library 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 this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbpoppler-private.h"
+
+#define RG_TARGET_NAMESPACE rb_cPopplerColor
+
+#ifdef POPPLER_TYPE_COLOR
+VALUE RG_TARGET_NAMESPACE;
+
+PopplerColor *
+rb_poppler_ruby_object_to_color(VALUE color)
+{
+    return RVAL2BOXED(color, POPPLER_TYPE_COLOR);
+}
+
+VALUE
+rb_poppler_ruby_object_from_color_with_free(PopplerColor *color)
+{
+    VALUE rb_color;
+
+    rb_color = POPPLERCOLOR2RVAL(color);
+    g_free(color);
+    return rb_color;
+}
+
+static VALUE
+rg_initialize(VALUE self, VALUE red, VALUE green, VALUE blue)
+{
+    PopplerColor color;
+
+    color.red = NUM2UINT(red);
+    color.green = NUM2UINT(green);
+    color.blue = NUM2UINT(blue);
+
+    G_INITIALIZE(self, g_boxed_copy(POPPLER_TYPE_COLOR, &color));
+    return Qnil;
+}
+
+DEF_ACCESSOR(color, red, RVAL2POPPLERCOLOR, UINT2NUM, NUM2UINT)
+DEF_ACCESSOR(color, green, RVAL2POPPLERCOLOR, UINT2NUM, NUM2UINT)
+DEF_ACCESSOR(color, blue, RVAL2POPPLERCOLOR, UINT2NUM, NUM2UINT)
+
+static VALUE
+rg_to_a(VALUE self)
+{
+    PopplerColor *color;
+    color = RVAL2POPPLERCOLOR(self);
+    return rb_ary_new3(3,
+                       UINT2NUM(color->red),
+                       UINT2NUM(color->green),
+                       UINT2NUM(color->blue));
+}
+
+static VALUE
+rg_inspect(VALUE self)
+{
+    VALUE inspected;
+    gchar *rgb;
+    PopplerColor *color;
+
+    color = RVAL2POPPLERCOLOR(self);
+    inspected = rb_call_super(0, NULL);
+    rb_str_resize(inspected, RSTRING_LEN(inspected) - 1);
+    rgb = g_strdup_printf(": [%u, %u, %u]>",
+                          color->red, color->green, color->blue);
+    rb_str_cat2(inspected, rgb);
+    g_free(rgb);
+    return inspected;
+}
+#endif
+
+void
+Init_poppler_color(VALUE mPoppler)
+{
+#ifdef POPPLER_TYPE_COLOR
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(POPPLER_TYPE_COLOR, "Color", mPoppler);
+
+    RG_DEF_METHOD(initialize, 3);
+    rbg_define_method(RG_TARGET_NAMESPACE, "red", color_get_red, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "green", color_get_green, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "blue", color_get_blue, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "set_red", color_set_red, 1);
+    rbg_define_method(RG_TARGET_NAMESPACE, "set_green", color_set_green, 1);
+    rbg_define_method(RG_TARGET_NAMESPACE, "set_blue", color_set_blue, 1);
+    RG_DEF_METHOD(to_a, 0);
+    RG_DEF_METHOD(inspect, 0);
+#endif
+}

data/ext/poppler/rbpoppler-document.c

@@ -0,0 +1,224 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2006  Ruby-GNOME2 Project Team
+ *
+ *  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, or (at your option) any later version.
+ *
+ *  This library 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 this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbpoppler-private.h"
+
+#define RG_TARGET_NAMESPACE cDocument
+
+static ID id_new, id_pdf_data_p, id_ensure_uri;
+static VALUE cIndexIter;
+static VALUE cFontInfo;
+
+static VALUE
+rg_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 = RVAL2CSTR_ACCEPT_NIL(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
+rg_save(VALUE self, VALUE uri)
+{
+    gboolean result;
+    GError *error = NULL;
+
+    uri = rb_funcall(self, id_ensure_uri, 1, uri);
+    result = poppler_document_save(RVAL2POPPLERDOCUMENT(self), RVAL2CSTR(uri), &error);
+
+    if (error)
+        RAISE_GERROR(error);
+
+    return CBOOL2RVAL(result);
+}
+
+static VALUE
+rg_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(RVAL2POPPLERDOCUMENT(self), RVAL2CSTR(uri),
+                      &error);
+
+    if (error)
+        RAISE_GERROR(error);
+
+    return CBOOL2RVAL(result);
+}
+
+static VALUE
+rg_n_pages(VALUE self)
+{
+    return INT2NUM(poppler_document_get_n_pages(RVAL2POPPLERDOCUMENT(self)));
+}
+
+static VALUE
+rg_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(RVAL2POPPLERDOCUMENT(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(RVAL2POPPLERDOCUMENT(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
+rg_has_attachments_p(VALUE self)
+{
+    return CBOOL2RVAL(poppler_document_has_attachments(RVAL2POPPLERDOCUMENT(self)));
+}
+
+static VALUE
+rg_attachments(VALUE self)
+{
+    return GLIST2ARYF(poppler_document_get_attachments(RVAL2POPPLERDOCUMENT(self)));
+}
+
+static VALUE
+rg_find_dest(VALUE self, VALUE link_name)
+{
+    PopplerDest *dest;
+    dest = poppler_document_find_dest(RVAL2POPPLERDOCUMENT(self), RVAL2CSTR(link_name));
+    return POPPLERDEST2RVAL(dest);
+}
+
+static VALUE
+rg_get_form_field(VALUE self, VALUE id)
+{
+    return GOBJ2RVAL(poppler_document_get_form_field(RVAL2POPPLERDOCUMENT(self),
+                                                     NUM2INT(id)));
+}
+
+static VALUE
+rg_each(VALUE self)
+{
+    PopplerDocument *document;
+    int i, n_pages;
+
+    document = RVAL2POPPLERDOCUMENT(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
+rg_index_iter(VALUE self)
+{
+    return rb_funcall(cIndexIter, id_new, 1, self);
+}
+
+static VALUE
+rg_font_info(VALUE self)
+{
+    return rb_funcall(cFontInfo, id_new, 1, self);
+}
+
+void
+Init_poppler_document(VALUE mPoppler)
+{
+    VALUE RG_TARGET_NAMESPACE;
+    cIndexIter = rb_const_get(mPoppler, rb_intern("IndexIter"));
+    cFontInfo = rb_const_get(mPoppler, rb_intern("FontInfo"));
+
+    id_new = rb_intern("new");
+    id_pdf_data_p = rb_intern("pdf_data?");
+    id_ensure_uri = rb_intern("ensure_uri");
+
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(POPPLER_TYPE_DOCUMENT, "Document", 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(RG_TARGET_NAMESPACE, rb_mEnumerable);
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(save, 1);
+    RG_DEF_METHOD(save_a_copy, 1);
+    RG_DEF_METHOD(n_pages, 0);
+    RG_DEF_ALIAS("size", "n_pages");
+    RG_DEF_METHOD(get_page, 1);
+    RG_DEF_ALIAS("[]", "get_page");
+    RG_DEF_METHOD_P(has_attachments, 0);
+    RG_DEF_ALIAS("have_attachments?", "has_attachments?");
+    RG_DEF_METHOD(attachments, 0);
+    RG_DEF_METHOD(find_dest, 1);
+    RG_DEF_ALIAS("get_destination", "find_dest");
+
+    RG_DEF_METHOD(get_form_field, 1);
+
+    RG_DEF_METHOD(each, 0);
+    RG_DEF_ALIAS("pages", "to_a");
+
+    RG_DEF_METHOD(index_iter, 0);
+    RG_DEF_METHOD(font_info, 0);
+}