poppler 1.0.3 → 1.1.0

data/ext/poppler/rbpoppler-formfieldmapping.c

@@ -0,0 +1,47 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  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 cFormFieldMapping
+
+DEF_ACCESSOR_WITH_SETTER(form_field_mapping, area,
+                         RVAL2POPPLERFORMFIELDMAPPING, RECT_ENTITY2RVAL, RECT_ENTITY_SET)
+DEF_ACCESSOR(form_field_mapping, field, RVAL2POPPLERFORMFIELDMAPPING,
+             POPPLERFORMFIELD2RVAL, RVAL2POPPLERFORMFIELD)
+
+void
+Init_poppler_formfieldmapping(VALUE mPoppler)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(POPPLER_TYPE_FORM_FIELD_MAPPING,
+                                    "FormFieldMapping", mPoppler);
+
+    rb_define_method(RG_TARGET_NAMESPACE, "area", form_field_mapping_get_area, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "field", form_field_mapping_get_field,
+                     0);
+
+    rb_define_method(RG_TARGET_NAMESPACE, "set_area",
+                     form_field_mapping_set_area, 1);
+    rb_define_method(RG_TARGET_NAMESPACE, "set_field",
+                     form_field_mapping_set_field, 1);
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
+}

data/ext/poppler/rbpoppler-imagemapping.c

@@ -0,0 +1,55 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  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 cImageMapping
+
+DEF_ACCESSOR_WITH_SETTER(image_mapping, area,
+                         RVAL2POPPLERIMAGEMAPPING, RECT_ENTITY2RVAL, RECT_ENTITY_SET)
+DEF_ACCESSOR(image_mapping, image_id, RVAL2POPPLERIMAGEMAPPING, INT2NUM, NUM2INT)
+#ifdef RB_POPPLER_CAIRO_AVAILABLE
+static VALUE
+rg_image(VALUE self)
+{
+    return rb_funcall(rb_iv_get(self, "@page"), rb_intern("get_image"),
+                        1, INT2NUM(RVAL2POPPLERIMAGEMAPPING(self)->image_id));
+}
+#endif
+
+void
+Init_poppler_imagemapping(VALUE mPoppler)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(POPPLER_TYPE_IMAGE_MAPPING,
+                                "ImageMapping", mPoppler);
+
+    rb_define_method(RG_TARGET_NAMESPACE, "area", image_mapping_get_area, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "image_id", image_mapping_get_image_id, 0);
+#ifdef RB_POPPLER_CAIRO_AVAILABLE
+    RG_DEF_METHOD(image, 0);
+#endif
+
+    rb_define_method(RG_TARGET_NAMESPACE, "set_area", image_mapping_set_area, 1);
+    rb_define_method(RG_TARGET_NAMESPACE, "set_image_id",
+                     image_mapping_set_image_id, 1);
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
+}

data/ext/poppler/rbpoppler-indexiter.c

@@ -0,0 +1,130 @@
+/* -*- 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 cIndexIter
+
+static VALUE RG_TARGET_NAMESPACE;
+
+static ID id_valid;
+
+/* Interface for getting the Index of a poppler_document */
+#define CHECK_IITER_IS_VALID(iter) do {         \
+    if (!RVAL2CBOOL(rg_valid_p(iter)))       \
+        return Qnil;                            \
+} while (0)
+
+static VALUE
+rg_valid_p(VALUE self)
+{
+    return rb_ivar_get(self, id_valid);
+}
+
+static VALUE
+rg_initialize(VALUE self, VALUE document)
+{
+    PopplerIndexIter *iter;
+    iter = poppler_index_iter_new(RVAL2POPPLERDOCUMENT(document));
+    G_INITIALIZE(self, iter);
+    poppler_index_iter_free(iter);
+    rb_ivar_set(self, id_valid, CBOOL2RVAL(iter));
+    return Qnil;
+}
+
+static VALUE
+rg_child(VALUE self)
+{
+    PopplerIndexIter *child;
+    VALUE rb_child;
+
+    CHECK_IITER_IS_VALID(self);
+    child = poppler_index_iter_get_child(RVAL2POPPLERINDEXITER(self));
+    rb_child = POPPLERINDEXITER2RVAL(child);
+    poppler_index_iter_free(child);
+    return rb_child;
+}
+
+static VALUE
+rg_open_p(VALUE self)
+{
+    CHECK_IITER_IS_VALID(self);
+    return CBOOL2RVAL(poppler_index_iter_is_open(RVAL2POPPLERINDEXITER(self)));
+}
+
+#ifndef HAVE_TYPE_POPPLERACTIONANY
+static VALUE
+rg_action(VALUE self)
+{
+    CHECK_IITER_IS_VALID(self);
+    return POPPLERACTION2RVAL(poppler_index_iter_get_action(RVAL2POPPLERINDEXITER(self)));
+}
+#endif
+
+static VALUE
+rg_next(VALUE self)
+{
+    if (poppler_index_iter_next(RVAL2POPPLERINDEXITER(self))) {
+        return Qtrue;
+    } else {
+        rb_ivar_set(self, id_valid, Qfalse);
+        return Qfalse;
+    }
+}
+
+static VALUE
+rg_each(VALUE self)
+{
+    PopplerIndexIter *iter;
+
+    CHECK_IITER_IS_VALID(self);
+    iter = RVAL2POPPLERINDEXITER(self);
+    do {
+        rb_yield(self);
+    } while (poppler_index_iter_next(iter));
+    rb_ivar_set(self, id_valid, Qfalse);
+
+    return self;
+}
+
+void
+Init_poppler_indexiter(VALUE mPoppler)
+{
+    id_valid = rb_intern("valid?");
+
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(POPPLER_TYPE_INDEX_ITER, "IndexIter", mPoppler);
+
+/* Interface for getting the Index of a poppler_document */
+    rb_include_module(RG_TARGET_NAMESPACE, rb_mEnumerable);
+
+    RG_DEF_METHOD(initialize, 1);
+    RG_DEF_METHOD(child, 0);
+    RG_DEF_METHOD_P(open, 0);
+#ifndef HAVE_TYPE_POPPLERACTIONANY
+    RG_DEF_METHOD(action, 0);
+#endif
+    RG_DEF_METHOD(next, 0);
+
+    RG_DEF_METHOD_P(valid, 0);
+    RG_DEF_METHOD(each, 0);
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
+}

data/ext/poppler/rbpoppler-linkmapping.c

@@ -0,0 +1,50 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  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 cLinkMapping
+
+void
+rectangle_set(PopplerRectangle *rect, VALUE rb_rect)
+{
+    *rect = *(RVAL2POPPLERRECTANGLE(rb_rect));
+}
+
+DEF_ACCESSOR_WITH_SETTER(link_mapping, area,
+                         RVAL2POPPLERLINKMAPPING, RECT_ENTITY2RVAL, RECT_ENTITY_SET)
+DEF_ACCESSOR(link_mapping, action, RVAL2POPPLERLINKMAPPING,
+             POPPLERACTION2RVAL, RVAL2POPPLERACTION)
+
+void
+Init_poppler_linkmapping(VALUE mPoppler)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(POPPLER_TYPE_LINK_MAPPING, "LinkMapping",
+                               mPoppler);
+
+    rb_define_method(RG_TARGET_NAMESPACE, "area", link_mapping_get_area, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "action", link_mapping_get_action, 0);
+
+    rb_define_method(RG_TARGET_NAMESPACE, "set_area", link_mapping_set_area, 1);
+    rb_define_method(RG_TARGET_NAMESPACE, "set_action", link_mapping_set_action, 1);
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
+}

data/ext/poppler/rbpoppler-page.c

@@ -1,76 +1,36 @@
-/* -*- c-file-style: "ruby" -*- */
-/**********************************************************************
-
-  rbpoppler-page.c -
-
-  Copyright (C) 2006-2008 Ruby-GNOME2 Project Team
-
-**********************************************************************/
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  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 SELF(self) (POPPLER_PAGE(RVAL2GOBJ(self)))
+#define RG_TARGET_NAMESPACE cPage
+#define SELF(self) (RVAL2POPPLERPAGE(self))
 
 #ifndef GDK_TYPE_REGION
 extern GType gdk_region_get_type(void);
 #  define GDK_TYPE_REGION (gdk_region_get_type())
 #endif
 
-#define GDK_REGION2RVAL(obj) (BOXED2RVAL(obj, GDK_TYPE_REGION))
-#define RVAL2GDK_PIXBUF(pixbuf) (GDK_PIXBUF(RVAL2GOBJ(pixbuf)))
-
-
-#define SEL_STYLE2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_SELECTION_STYLE))
-#define RVAL2SEL_STYLE(obj) (RVAL2GENUM(obj, POPPLER_TYPE_SELECTION_STYLE))
-
-#define RVAL2TRANS(obj) ((PopplerPageTransition *)RVAL2BOXED(obj, POPPLER_TYPE_PAGE_TRANSITION))
-#define TRANS2RVAL(obj) (BOXED2RVAL(obj, POPPLER_TYPE_PAGE_TRANSITION))
-#define RVAL2LM(obj) ((PopplerLinkMapping *)RVAL2BOXED(obj, POPPLER_TYPE_LINK_MAPPING))
-#define RVAL2IM(obj) ((PopplerImageMapping *)RVAL2BOXED(obj, POPPLER_TYPE_IMAGE_MAPPING))
-#define RVAL2FFM(obj) ((PopplerFormFieldMapping *)RVAL2BOXED(obj, POPPLER_TYPE_FORM_FIELD_MAPPING))
-#define RVAL2AM(obj) ((PopplerAnnotMapping *)RVAL2BOXED(obj, POPPLER_TYPE_ANNOT_MAPPING))
-
-#define TT2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_PAGE_TRANSITION_TYPE))
-#define RVAL2TT(obj) (RVAL2GENUM(obj, POPPLER_TYPE_PAGE_TRANSITION_TYPE))
-#define TA2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_PAGE_TRANSITION_ALIGNMENT))
-#define RVAL2TA(obj) (RVAL2GENUM(obj, POPPLER_TYPE_PAGE_TRANSITION_ALIGNMENT))
-#define TD2RVAL(obj) (GENUM2RVAL(obj, POPPLER_TYPE_PAGE_TRANSITION_DIRECTION))
-#define RVAL2TD(obj) (RVAL2GENUM(obj, POPPLER_TYPE_PAGE_TRANSITION_DIRECTION))
-
-static VALUE cPSFile, cRectangle;
-
-#ifdef POPPLER_TYPE_COLOR
-VALUE rb_cPopplerColor;
-
-PopplerColor *
-rb_poppler_ruby_object_to_color(VALUE color)
-{
-#ifdef POPPLER_WITH_GDK
-    if (RTEST(rb_obj_is_kind_of(color, rb_cGdkColor))) {
-	GdkColor *gdk_color;
-
-	gdk_color = RVAL2GDKCOLOR(color);
-	color = rb_funcall(rb_cPopplerColor, rb_intern("new"),
-			   3,
-			   UINT2NUM(gdk_color->red),
-			   UINT2NUM(gdk_color->green),
-			   UINT2NUM(gdk_color->blue));
-    }
-#endif
-
-    return RVAL2BOXED(color, POPPLER_TYPE_COLOR);
-}
-
-VALUE
-rb_poppler_ruby_object_from_color_with_free(PopplerColor *color)
-{
-    VALUE rb_color;
-
-    rb_color = POPPLER_COLOR2RVAL(color);
-    g_free(color);
-    return rb_color;
-}
-#endif
+static VALUE cRectangle;
+static VALUE cPSFile;
 
 #ifdef POPPLER_WITH_GDK
 static VALUE
@@ -81,7 +41,7 @@ page_render_to_pixbuf(VALUE self, VALUE src_x, VALUE src_y, VALUE src_width,
     poppler_page_render_to_pixbuf(SELF(self), NUM2INT(src_x),
                                   NUM2INT(src_y), NUM2INT(src_width),
                                   NUM2INT(src_height), NUM2DBL(scale),
-                                  NUM2INT(rotation), RVAL2GOBJ(pixbuf));
+                                  NUM2INT(rotation), RVAL2GDKPIXBUF(pixbuf));
     return Qnil;
 }
 #endif
@@ -98,12 +58,12 @@ page_render(VALUE self, VALUE cairo)
 static VALUE
 page_render_to_ps(VALUE self, VALUE ps_file)
 {
-    poppler_page_render_to_ps(SELF(self), RVAL2GOBJ(ps_file));
+    poppler_page_render_to_ps(SELF(self), RVAL2POPPLERPSFILE(ps_file));
     return Qnil;
 }
 
 static VALUE
-page_render_generic(int argc, VALUE *argv, VALUE self)
+rg_render(int argc, VALUE *argv, VALUE self)
 {
     if (argc == 1) {
         if (RVAL2CBOOL(rb_obj_is_kind_of(argv[0], cPSFile))) {
@@ -120,28 +80,28 @@ page_render_generic(int argc, VALUE *argv, VALUE self)
         return page_render_to_pixbuf(self, argv[0], argv[1], argv[2], argv[3],
                                      argv[4], argv[5], argv[6]);
 #else
-	rb_raise(rb_eArgError, "GDK is not available");
+        rb_raise(rb_eArgError, "GDK is not available");
 #endif
     } else {
         rb_raise(rb_eArgError,
                  "wrong number of arguments (%d for 1 or 7)",
-		 argc);
+                 argc);
     }
 }
 
 #ifdef POPPLER_WITH_GDK
 static VALUE
 page_render_to_pixbuf_for_printing(VALUE self, VALUE src_x, VALUE src_y,
-				   VALUE src_width, VALUE src_height,
-				   VALUE scale, VALUE rotation, VALUE pixbuf)
+                                   VALUE src_width, VALUE src_height,
+                                   VALUE scale, VALUE rotation, VALUE pixbuf)
 {
     poppler_page_render_to_pixbuf_for_printing(SELF(self), NUM2INT(src_x),
-					       NUM2INT(src_y),
-					       NUM2INT(src_width),
-					       NUM2INT(src_height),
-					       NUM2DBL(scale),
-					       NUM2INT(rotation),
-					       RVAL2GOBJ(pixbuf));
+                                               NUM2INT(src_y),
+                                               NUM2INT(src_width),
+                                               NUM2INT(src_height),
+                                               NUM2DBL(scale),
+                                               NUM2INT(rotation),
+                                               RVAL2GDKPIXBUF(pixbuf));
     return Qnil;
 }
 #endif
@@ -156,21 +116,21 @@ page_render_for_printing(VALUE self, VALUE cairo)
 #endif
 
 static VALUE
-page_render_for_printing_generic(int argc, VALUE *argv, VALUE self)
+rg_render_for_printing(int argc, VALUE *argv, VALUE self)
 {
     if (argc == 1) {
 #ifdef RB_POPPLER_CAIRO_AVAILABLE
-	return page_render_for_printing(self, argv[0]);
+        return page_render_for_printing(self, argv[0]);
 #else
-	rb_raise(rb_eArgError, "cairo is not available");
+        rb_raise(rb_eArgError, "cairo is not available");
 #endif
     } else if (argc == 7) {
 #ifdef POPPLER_WITH_GDK
         return page_render_to_pixbuf_for_printing(self, argv[0], argv[1],
-						  argv[2], argv[3],
-						  argv[4], argv[5], argv[6]);
+                                                  argv[2], argv[3],
+                                                  argv[4], argv[5], argv[6]);
 #else
-	rb_raise(rb_eArgError, "GDK is not available");
+        rb_raise(rb_eArgError, "GDK is not available");
 #endif
     } else {
         rb_raise(rb_eArgError,
@@ -187,13 +147,13 @@ page_render_selection(VALUE self, VALUE cairo,
     PopplerRectangle *old_selection = NULL;
 
     if (!NIL_P(rb_old_selection))
-        old_selection = RVAL2POPPLER_RECT(rb_old_selection);
+        old_selection = RVAL2POPPLERRECTANGLE(rb_old_selection);
     poppler_page_render_selection(SELF(self), RVAL2CRCONTEXT(cairo),
-                                  RVAL2POPPLER_RECT(selection),
+                                  RVAL2POPPLERRECTANGLE(selection),
                                   old_selection,
-                                  RVAL2SEL_STYLE(style),
-                                  RVAL2POPPLER_COLOR(glyph_color),
-                                  RVAL2POPPLER_COLOR(background_color));
+                                  RVAL2POPPLERSELECTIONSTYLE(style),
+                                  RVAL2POPPLERCOLOR(glyph_color),
+                                  RVAL2POPPLERCOLOR(background_color));
     return Qnil;
 }
 #endif
@@ -209,14 +169,14 @@ page_render_selection_to_pixbuf(VALUE self, VALUE scale, VALUE rotation,
     PopplerRectangle *old_selection = NULL;
 
     if (!NIL_P(rb_old_selection))
-        old_selection = RVAL2POPPLER_RECT(rb_old_selection);
+        old_selection = RVAL2POPPLERRECTANGLE(rb_old_selection);
     poppler_page_render_selection_to_pixbuf(SELF(self),
                                             NUM2DBL(scale),
                                             NUM2INT(rotation),
-                                            RVAL2GOBJ(pixbuf),
-                                            RVAL2POPPLER_RECT(selection),
+                                            RVAL2GDKPIXBUF(pixbuf),
+                                            RVAL2POPPLERRECTANGLE(selection),
                                             old_selection,
-                                            RVAL2SEL_STYLE(style),
+                                            RVAL2POPPLERSELECTIONSTYLE(style),
                                             RVAL2GDKCOLOR(glyph_color),
                                             RVAL2GDKCOLOR(background_color));
     return Qnil;
@@ -224,7 +184,7 @@ page_render_selection_to_pixbuf(VALUE self, VALUE scale, VALUE rotation,
 #endif
 
 static VALUE
-page_render_selection_generic(int argc, VALUE *argv, VALUE self)
+rg_render_selection(int argc, VALUE *argv, VALUE self)
 {
     if (argc == 6) {
 #ifdef RB_POPPLER_CAIRO_AVAILABLE
@@ -248,7 +208,7 @@ page_render_selection_generic(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-page_get_size(VALUE self)
+rg_size(VALUE self)
 {
     double width, height;
     poppler_page_get_size(SELF(self), &width, &height);
@@ -256,26 +216,26 @@ page_get_size(VALUE self)
 }
 
 static VALUE
-page_get_index(VALUE self)
+rg_index(VALUE self)
 {
     return INT2NUM(poppler_page_get_index(SELF(self)));
 }
 
 static VALUE
-page_get_duration(VALUE self)
+rg_duration(VALUE self)
 {
     return rb_float_new(poppler_page_get_duration(SELF(self)));
 }
 
 static VALUE
-page_get_transition(VALUE self)
+rg_transition(VALUE self)
 {
-    return TRANS2RVAL(poppler_page_get_transition(SELF(self)));
+    return POPPLERPAGETRANSITION2RVAL(poppler_page_get_transition(SELF(self)));
 }
 
 #if RB_POPPLER_CAIRO_AVAILABLE
 static VALUE
-page_get_thumbnail(VALUE self)
+rg_thumbnail(VALUE self)
 {
     return CRSURFACE2RVAL(poppler_page_get_thumbnail(SELF(self)));
 }
@@ -283,14 +243,14 @@ page_get_thumbnail(VALUE self)
 
 #ifdef POPPLER_WITH_GDK
 static VALUE
-page_get_thumbnail_pixbuf(VALUE self)
+rg_thumbnail_pixbuf(VALUE self)
 {
     return GOBJ2RVAL(poppler_page_get_thumbnail_pixbuf(SELF(self)));
 }
 #endif
 
 static VALUE
-page_get_thumbnail_size(VALUE self)
+rg_thumbnail_size(VALUE self)
 {
     int width, height;
 
@@ -301,14 +261,14 @@ page_get_thumbnail_size(VALUE self)
 }
 
 static VALUE
-page_find_text(VALUE self, VALUE text)
+rg_find_text(VALUE self, VALUE text)
 {
     return GLIST2ARY2F(poppler_page_find_text(SELF(self), RVAL2CSTR(text)),
                        POPPLER_TYPE_RECTANGLE);
 }
 
 static VALUE
-page_get_text(int argc, VALUE *argv, VALUE self)
+rg_get_text(int argc, VALUE *argv, VALUE self)
 {
     gchar *text;
     PopplerSelectionStyle style = POPPLER_SELECTION_GLYPH;
@@ -326,7 +286,7 @@ page_get_text(int argc, VALUE *argv, VALUE self)
         } else {
             rb_rect = Qnil;
             if (!NIL_P(arg2)) {
-                style = RVAL2SEL_STYLE(arg2);
+                style = RVAL2POPPLERSELECTIONSTYLE(arg2);
             }
         }
     }
@@ -350,7 +310,7 @@ page_get_text(int argc, VALUE *argv, VALUE self)
     } else {
         PopplerRectangle *rect;
 
-	rect = RVAL2POPPLER_RECT(rb_rect);
+        rect = RVAL2POPPLERRECTANGLE(rb_rect);
 #if POPPLER_CHECK_VERSION(0, 15, 0)
         text = poppler_page_get_selected_text(page, style, rect);
 #else
@@ -364,24 +324,24 @@ page_get_text(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-page_get_selection_region(VALUE self, VALUE scale, VALUE style, VALUE selection)
+rg_get_selection_region(VALUE self, VALUE scale, VALUE style, VALUE selection)
 {
     return GLIST2ARY2F(poppler_page_get_selection_region(SELF(self),
-							 NUM2DBL(scale),
-							 RVAL2SEL_STYLE(style),
-							 RVAL2POPPLER_RECT(selection)),
-                       POPPLER_TYPE_RECTANGLE);
+                                                         NUM2DBL(scale),
+                                                         RVAL2POPPLERSELECTIONSTYLE(style),
+                                                         RVAL2POPPLERRECTANGLE(selection)),
+                                                         POPPLER_TYPE_RECTANGLE);
 }
 
 static VALUE
-page_get_link_mapping(VALUE self)
+rg_link_mapping(VALUE self)
 {
     return GLIST2ARY2F(poppler_page_get_link_mapping(SELF(self)),
                        POPPLER_TYPE_LINK_MAPPING);
 }
 
 static VALUE
-page_get_image_mapping(VALUE self)
+rg_image_mapping(VALUE self)
 {
     VALUE mappings;
     GList *image_mapping, *node;
@@ -389,15 +349,15 @@ page_get_image_mapping(VALUE self)
     mappings = rb_ary_new();
     image_mapping = poppler_page_get_image_mapping(SELF(self));
     for (node = image_mapping; node; node = g_list_next(node)) {
-	PopplerImageMapping *image_mapping;
-	VALUE mapping;
+        PopplerImageMapping *image_mapping;
+        VALUE mapping;
 
-	image_mapping = node->data;
-	mapping = BOXED2RVAL(image_mapping, POPPLER_TYPE_IMAGE_MAPPING);
+        image_mapping = node->data;
+        mapping = POPPLERIMAGEMAPPING2RVAL(image_mapping);
 #ifdef RB_POPPLER_CAIRO_AVAILABLE
-	rb_iv_set(mapping, "@page", self);
+        rb_iv_set(mapping, "@page", self);
 #endif
-	rb_ary_push(mappings, mapping);
+        rb_ary_push(mappings, mapping);
     }
     poppler_page_free_image_mapping(image_mapping);
 
@@ -406,377 +366,69 @@ page_get_image_mapping(VALUE self)
 
 #ifdef RB_POPPLER_CAIRO_AVAILABLE
 static VALUE
-_page_get_image(VALUE self, gint image_id)
+rg_get_image(VALUE self, VALUE image_id)
 {
-    return CRSURFACE2RVAL(poppler_page_get_image(SELF(self), image_id));
-}
-
-static VALUE
-page_get_image(VALUE self, VALUE image_id)
-{
-    return _page_get_image(self, NUM2INT(image_id));
+    return CRSURFACE2RVAL(poppler_page_get_image(SELF(self), NUM2INT(image_id)));
 }
 #endif
 
 static VALUE
-page_get_form_field_mapping(VALUE self)
+rg_form_field_mapping(VALUE self)
 {
     return GLIST2ARY2F(poppler_page_get_form_field_mapping(SELF(self)),
                        POPPLER_TYPE_FORM_FIELD_MAPPING);
 }
 
 static VALUE
-page_get_annot_mapping(VALUE self)
+rg_annotation_mapping(VALUE self)
 {
     return GLIST2ARY2F(poppler_page_get_annot_mapping(SELF(self)),
                        POPPLER_TYPE_ANNOT_MAPPING);
 }
 
 static VALUE
-page_get_crop_box(VALUE self)
+rg_crop_box(VALUE self)
 {
     PopplerRectangle rect;
 
     poppler_page_get_crop_box(SELF(self), &rect);
-    return POPPLER_RECT2RVAL(&rect);
-}
-
-
-/* A rectangle on a page, with coordinates in PDF points. */
-static VALUE
-rectangle_initialize(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2)
-{
-    PopplerRectangle rectangle;
-
-    rectangle.x1 = NUM2DBL(x1);
-    rectangle.y1 = NUM2DBL(y1);
-    rectangle.x2 = NUM2DBL(x2);
-    rectangle.y2 = NUM2DBL(y2);
-
-    G_INITIALIZE(self, &rectangle);
-    return Qnil;
-}
-
-DEF_ACCESSOR(rectangle, x1, RVAL2POPPLER_RECT, rb_float_new, NUM2DBL)
-DEF_ACCESSOR(rectangle, y1, RVAL2POPPLER_RECT, rb_float_new, NUM2DBL)
-DEF_ACCESSOR(rectangle, x2, RVAL2POPPLER_RECT, rb_float_new, NUM2DBL)
-DEF_ACCESSOR(rectangle, y2, RVAL2POPPLER_RECT, rb_float_new, NUM2DBL)
-
-static VALUE
-rectangle_to_a(VALUE self)
-{
-    PopplerRectangle *rectangle = RVAL2POPPLER_RECT(self);
-    return rb_ary_new3(4,
-                       rb_float_new(rectangle->x1),
-                       rb_float_new(rectangle->y1),
-                       rb_float_new(rectangle->x2),
-                       rb_float_new(rectangle->y2));
-}
-
-static VALUE
-rectangle_inspect(VALUE self)
-{
-    VALUE inspected;
-    gchar *points;
-    PopplerRectangle *rectangle;
-
-    rectangle = RVAL2POPPLER_RECT(self);
-    inspected = rb_call_super(0, NULL);
-    rb_str_resize(inspected, RSTRING_LEN(inspected) - 1);
-    points = g_strdup_printf(": [%g, %g, %g, %g]>",
-			     rectangle->x1, rectangle->y1,
-			     rectangle->x2, rectangle->y2);
-    rb_str_cat2(inspected, points);
-    g_free(points);
-    return inspected;
-}
-
-
-#ifdef POPPLER_TYPE_COLOR
-/* A color in RGB */
-static VALUE
-color_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, &color);
-    return Qnil;
-}
-
-DEF_ACCESSOR(color, red, RVAL2POPPLER_COLOR, UINT2NUM, NUM2UINT)
-DEF_ACCESSOR(color, green, RVAL2POPPLER_COLOR, UINT2NUM, NUM2UINT)
-DEF_ACCESSOR(color, blue, RVAL2POPPLER_COLOR, UINT2NUM, NUM2UINT)
-
-static VALUE
-color_to_a(VALUE self)
-{
-    PopplerColor *color;
-    color = RVAL2POPPLER_COLOR(self);
-    return rb_ary_new3(3,
-                       UINT2NUM(color->red),
-                       UINT2NUM(color->green),
-                       UINT2NUM(color->blue));
-}
-
-static VALUE
-color_inspect(VALUE self)
-{
-    VALUE inspected;
-    gchar *rgb;
-    PopplerColor *color;
-
-    color = RVAL2POPPLER_COLOR(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
-
-
-/* Mapping between areas on the current page and PopplerActions */
-#define RECT_ENTITY2RVAL(rect) POPPLER_RECT2RVAL(&(rect))
-#define RECT_ENTITY_SET(rect, rb_rect) rectangle_set(&(rect), rb_rect)
-static void
-rectangle_set(PopplerRectangle *rect, VALUE rb_rect)
-{
-    *rect = *(RVAL2POPPLER_RECT(rb_rect));
-}
-
-DEF_ACCESSOR_WITH_SETTER(link_mapping, area,
-                         RVAL2LM, RECT_ENTITY2RVAL, RECT_ENTITY_SET)
-DEF_ACCESSOR(link_mapping, action, RVAL2LM,
-	     POPPLER_ACTION2RVAL, RVAL2POPPLER_ACTION)
-
-
-/* Page Transition */
-DEF_ACCESSOR(page_trans, type, RVAL2TRANS, RVAL2TT, TT2RVAL)
-DEF_ACCESSOR(page_trans, alignment, RVAL2TRANS, RVAL2TA, TA2RVAL)
-DEF_ACCESSOR(page_trans, direction, RVAL2TRANS, RVAL2TD, TD2RVAL)
-DEF_ACCESSOR(page_trans, duration, RVAL2TRANS, NUM2INT, INT2NUM)
-DEF_ACCESSOR(page_trans, angle, RVAL2TRANS, NUM2INT, INT2NUM)
-DEF_ACCESSOR(page_trans, scale, RVAL2TRANS, NUM2DBL, rb_float_new)
-DEF_ACCESSOR(page_trans, rectangular, RVAL2TRANS, RVAL2CBOOL, CBOOL2RVAL)
-
-
-/* Mapping between areas on the current page and images */
-DEF_ACCESSOR_WITH_SETTER(image_mapping, area,
-                         RVAL2IM, RECT_ENTITY2RVAL, RECT_ENTITY_SET)
-DEF_ACCESSOR(image_mapping, image_id, RVAL2IM, INT2NUM, NUM2INT)
-#ifdef RB_POPPLER_CAIRO_AVAILABLE
-static VALUE
-image_mapping_get_image(VALUE self)
-{
-    return _page_get_image(rb_iv_get(self, "@page"), RVAL2IM(self)->image_id);
-}
-#endif
-
-
-/* Mapping between areas on the current page and form fields */
-DEF_ACCESSOR_WITH_SETTER(form_field_mapping, area,
-                         RVAL2FFM, RECT_ENTITY2RVAL, RECT_ENTITY_SET)
-DEF_ACCESSOR(form_field_mapping, field, RVAL2FFM,
-	     POPPLER_FORM_FIELD2RVAL, RVAL2POPPLER_FORM_FIELD)
-
-static VALUE
-annot_mapping_initialize(int argc, VALUE *argv, VALUE self)
-{
-    VALUE area, annotation;
-    PopplerAnnotMapping *mapping;
-
-    rb_scan_args(argc, argv, "02", &area, &annotation);
-
-    mapping = poppler_annot_mapping_new();
-    mapping->area = *RVAL2POPPLER_RECT(area);
-    mapping->annot = RVAL2POPPLER_ANNOT(annotation);
-    G_INITIALIZE(self, mapping);
-
-    return Qnil;
-}
-
-DEF_ACCESSOR_WITH_SETTER(annot_mapping, area,
-                         RVAL2AM, RECT_ENTITY2RVAL, RECT_ENTITY_SET)
-DEF_READER(annot_mapping, annotation, annot, RVAL2AM, POPPLER_ANNOT2RVAL)
-
-static VALUE
-annot_mapping_set_annotation(VALUE self, VALUE annotation)
-{
-    PopplerAnnotMapping *mapping;
-
-    mapping = RVAL2AM(self);
-    if (mapping->annot)
-	g_object_unref(mapping->annot);
-
-    mapping->annot = RVAL2POPPLER_ANNOT(annotation);
-    return Qnil;
+    return POPPLERRECTANGLE2RVAL(&rect);
 }
 
 void
 Init_poppler_page(VALUE mPoppler)
 {
-    VALUE cPage, cLinkMapping;
-    VALUE cPageTransition, cImageMapping, cFormFieldMapping;
-    VALUE cAnnotationMapping;
-
-    cPage = G_DEF_CLASS(POPPLER_TYPE_PAGE, "Page", mPoppler);
-    cRectangle = G_DEF_CLASS(POPPLER_TYPE_RECTANGLE, "Rectangle", mPoppler);
-#ifdef POPPLER_TYPE_COLOR
-    rb_cPopplerColor = G_DEF_CLASS(POPPLER_TYPE_COLOR, "Color", mPoppler);
-#endif
-    cLinkMapping = G_DEF_CLASS(POPPLER_TYPE_LINK_MAPPING, "LinkMapping",
-                               mPoppler);
-    cPageTransition = G_DEF_CLASS(POPPLER_TYPE_PAGE_TRANSITION,
-                                  "PageTransition", mPoppler);
-    cImageMapping = G_DEF_CLASS(POPPLER_TYPE_IMAGE_MAPPING,
-                                "ImageMapping", mPoppler);
-    cFormFieldMapping = G_DEF_CLASS(POPPLER_TYPE_FORM_FIELD_MAPPING,
-                                    "FormFieldMapping", mPoppler);
-    cAnnotationMapping = G_DEF_CLASS(POPPLER_TYPE_ANNOT_MAPPING,
-				     "AnnotationMapping", mPoppler);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(POPPLER_TYPE_PAGE, "Page", mPoppler);
+    cRectangle = rb_const_get(mPoppler, rb_intern("Rectangle"));
     cPSFile = rb_const_get(mPoppler, rb_intern("PSFile"));
 
-    rb_define_method(cPage, "render", page_render_generic, -1);
-    rb_define_method(cPage, "render_for_printing",
-		     page_render_for_printing_generic, -1);
-    rb_define_method(cPage, "size", page_get_size, 0);
-    rb_define_method(cPage, "index", page_get_index, 0);
-    rb_define_method(cPage, "duration", page_get_duration, 0);
-    rb_define_method(cPage, "transition", page_get_transition, 0);
+    RG_DEF_METHOD(render, -1);
+    RG_DEF_METHOD(render_for_printing, -1);
+    RG_DEF_METHOD(size, 0);
+    RG_DEF_METHOD(index, 0);
+    RG_DEF_METHOD(duration, 0);
+    RG_DEF_METHOD(transition, 0);
 
 #if RB_POPPLER_CAIRO_AVAILABLE
-    rb_define_method(cPage, "thumbnail", page_get_thumbnail, 0);
+    RG_DEF_METHOD(thumbnail, 0);
 #endif
 #if POPPLER_WITH_GDK
-    rb_define_method(cPage, "thumbnail_pixbuf", page_get_thumbnail_pixbuf, 0);
+    RG_DEF_METHOD(thumbnail_pixbuf, 0);
 #endif
-    rb_define_method(cPage, "thumbnail_size", page_get_thumbnail_size, 0);
-    rb_define_method(cPage, "find_text", page_find_text, 1);
-    rb_define_method(cPage, "get_text", page_get_text, -1);
-    rb_define_method(cPage, "get_selection_region",
-		     page_get_selection_region, 3);
-    rb_define_method(cPage, "link_mapping", page_get_link_mapping, 0);
-    rb_define_method(cPage, "image_mapping", page_get_image_mapping, 0);
+    RG_DEF_METHOD(thumbnail_size, 0);
+    RG_DEF_METHOD(find_text, 1);
+    RG_DEF_METHOD(get_text, -1);
+    RG_DEF_METHOD(get_selection_region, 3);
+    RG_DEF_METHOD(link_mapping, 0);
+    RG_DEF_METHOD(image_mapping, 0);
 #if RB_POPPLER_CAIRO_AVAILABLE
-    rb_define_method(cPage, "get_image", page_get_image, 1);
+    RG_DEF_METHOD(get_image, 1);
 #endif
 
-    rb_define_method(cPage, "form_field_mapping",
-                     page_get_form_field_mapping, 0);
-    rb_define_method(cPage, "annotation_mapping",
-                     page_get_annot_mapping, 0);
-    rb_define_method(cPage, "render_selection",
-                     page_render_selection_generic, -1);
-    rb_define_method(cPage, "crop_box", page_get_crop_box, 0);
-
-    G_DEF_SETTERS(cPage);
-
-/* A rectangle on a page, with coordinates in PDF points. */
-    rb_define_method(cRectangle, "initialize", rectangle_initialize, 4);
-    rb_define_method(cRectangle, "x1", rectangle_get_x1, 0);
-    rb_define_method(cRectangle, "y1", rectangle_get_y1, 0);
-    rb_define_method(cRectangle, "x2", rectangle_get_x2, 0);
-    rb_define_method(cRectangle, "y2", rectangle_get_y2, 0);
-    rb_define_method(cRectangle, "set_x1", rectangle_set_x1, 1);
-    rb_define_method(cRectangle, "set_y1", rectangle_set_y1, 1);
-    rb_define_method(cRectangle, "set_x2", rectangle_set_x2, 1);
-    rb_define_method(cRectangle, "set_y2", rectangle_set_y2, 1);
-    rb_define_method(cRectangle, "to_a", rectangle_to_a, 0);
-    rb_define_method(cRectangle, "inspect", rectangle_inspect, 0);
-
-    G_DEF_SETTERS(cRectangle);
-
-#ifdef POPPLER_TYPE_COLOR
-/* A color in RGB */
-    rb_define_method(rb_cPopplerColor, "initialize", color_initialize, 3);
-    rb_define_method(rb_cPopplerColor, "red", color_get_red, 0);
-    rb_define_method(rb_cPopplerColor, "green", color_get_green, 0);
-    rb_define_method(rb_cPopplerColor, "blue", color_get_blue, 0);
-    rb_define_method(rb_cPopplerColor, "set_red", color_set_red, 1);
-    rb_define_method(rb_cPopplerColor, "set_green", color_set_green, 1);
-    rb_define_method(rb_cPopplerColor, "set_blue", color_set_blue, 1);
-    rb_define_method(rb_cPopplerColor, "to_a", color_to_a, 0);
-    rb_define_method(rb_cPopplerColor, "inspect", color_inspect, 0);
-
-    G_DEF_SETTERS(rb_cPopplerColor);
-#endif
-
-/* Mapping between areas on the current page and PopplerActions */
-    rb_define_method(cLinkMapping, "area", link_mapping_get_area, 0);
-    rb_define_method(cLinkMapping, "action", link_mapping_get_action, 0);
-
-    rb_define_method(cLinkMapping, "set_area", link_mapping_set_area, 1);
-    rb_define_method(cLinkMapping, "set_action", link_mapping_set_action, 1);
-
-    G_DEF_SETTERS(cLinkMapping);
-
-/* Page Transition */
-    rb_define_method(cPageTransition, "type", page_trans_get_type, 0);
-    rb_define_method(cPageTransition, "alignment", page_trans_get_alignment, 0);
-    rb_define_method(cPageTransition, "direction", page_trans_get_direction, 0);
-    rb_define_method(cPageTransition, "duration", page_trans_get_duration, 0);
-    rb_define_method(cPageTransition, "angle", page_trans_get_angle, 0);
-    rb_define_method(cPageTransition, "scale", page_trans_get_scale, 0);
-    rb_define_method(cPageTransition, "rectangular",
-                     page_trans_get_rectangular, 0);
-
-    rb_define_method(cPageTransition, "set_type", page_trans_set_type, 1);
-    rb_define_method(cPageTransition, "set_alignment",
-                     page_trans_set_alignment, 1);
-    rb_define_method(cPageTransition, "set_direction",
-                     page_trans_set_direction, 1);
-    rb_define_method(cPageTransition, "set_duration",
-                     page_trans_set_duration, 1);
-    rb_define_method(cPageTransition, "set_angle", page_trans_set_angle, 1);
-    rb_define_method(cPageTransition, "set_scale", page_trans_set_scale, 1);
-    rb_define_method(cPageTransition, "set_rectangular",
-                     page_trans_set_rectangular, 1);
-
-    G_DEF_SETTERS(cPageTransition);
-
-
-/* Mapping between areas on the current page and images */
-    rb_define_method(cImageMapping, "area", image_mapping_get_area, 0);
-    rb_define_method(cImageMapping, "image_id", image_mapping_get_image_id, 0);
-#ifdef RB_POPPLER_CAIRO_AVAILABLE
-    rb_define_method(cImageMapping, "image", image_mapping_get_image, 0);
-#endif
-
-    rb_define_method(cImageMapping, "set_area", image_mapping_set_area, 1);
-    rb_define_method(cImageMapping, "set_image_id",
-		     image_mapping_set_image_id, 1);
-
-    G_DEF_SETTERS(cImageMapping);
-
-
-/* Mapping between areas on the current page and form fields */
-    rb_define_method(cFormFieldMapping, "area", form_field_mapping_get_area, 0);
-    rb_define_method(cFormFieldMapping, "field", form_field_mapping_get_field,
-                     0);
-
-    rb_define_method(cFormFieldMapping, "set_area",
-                     form_field_mapping_set_area, 1);
-    rb_define_method(cFormFieldMapping, "set_field",
-                     form_field_mapping_set_field, 1);
-
-    G_DEF_SETTERS(cFormFieldMapping);
-
-    rb_define_method(cAnnotationMapping, "initialize",
-		     annot_mapping_initialize, -1);
-
-    rb_define_method(cAnnotationMapping, "area", annot_mapping_get_area, 0);
-    rb_define_method(cAnnotationMapping, "annotation",
-		     annot_mapping_get_annotation, 0);
-
-    rb_define_method(cAnnotationMapping, "set_area", annot_mapping_set_area, 1);
-    rb_define_method(cAnnotationMapping, "set_annotation",
-		     annot_mapping_set_annotation, 1);
+    RG_DEF_METHOD(form_field_mapping, 0);
+    RG_DEF_METHOD(annotation_mapping, 0);
+    RG_DEF_METHOD(render_selection, -1);
+    RG_DEF_METHOD(crop_box, 0);
 
-    G_DEF_SETTERS(cAnnotationMapping);
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 }