gdk_pixbuf2 1.0.3-x86-mingw32 → 1.1.0-x86-mingw32

data/ext/gdk_pixbuf2/rbgdk-pixbuf-format.c

@@ -1,23 +1,33 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgdk-pixbuf-format.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:28 $
-
-  Copyright (C) 2004 Masao Mutoh
-************************************************/
-
-#include "rbgdk-pixbuf.h"
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004  Masao Mutoh
+ *
+ *  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 "rbgdk-pixbuf2private.h"
 #if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
 
 #ifdef HAVE_GDK_PIXBUF_GDK_PIXBUF_IO_H
 #include <gdk-pixbuf/gdk-pixbuf-io.h>
 #endif
 
-#define _SELF(r) ((GdkPixbufFormat*)RVAL2BOXED(r, GDK_TYPE_PIXBUF_FORMAT))
-
+#define RG_TARGET_NAMESPACE cPixbufFormat
+#define _SELF(r) (RVAL2GDKPIXBUFFORMAT(r))
 
 /**********************************/
 static GdkPixbufFormat*
@@ -51,19 +61,19 @@ GSList*     gdk_pixbuf_get_formats          (void);
 */
 
 static VALUE
-get_name(VALUE self)
+rg_name(VALUE self)
 {
     return CSTR2RVAL_FREE(gdk_pixbuf_format_get_name(_SELF(self)));
 }
 
 static VALUE
-get_description(VALUE self)
+rg_description(VALUE self)
 {
     return CSTR2RVAL_FREE(gdk_pixbuf_format_get_description(_SELF(self)));
 }
-    
+
 static VALUE
-get_mime_types(VALUE self)
+rg_mime_types(VALUE self)
 {
     gint i = 0;
     gchar** mime_types = gdk_pixbuf_format_get_mime_types(_SELF(self));
@@ -77,7 +87,7 @@ get_mime_types(VALUE self)
 }
 
 static VALUE
-get_extensions(VALUE self)
+rg_extensions(VALUE self)
 {
     gint i = 0;
     gchar** extensions = gdk_pixbuf_format_get_extensions(_SELF(self));
@@ -92,20 +102,20 @@ get_extensions(VALUE self)
 }
 
 static VALUE
-is_writable(VALUE self)
+rg_writable_p(VALUE self)
 {
     return CBOOL2RVAL(gdk_pixbuf_format_is_writable(_SELF(self)));
 }
 
 /* Structure */
 static VALUE
-get_domain(VALUE self)
+rg_domain(VALUE self)
 {
     return CSTR2RVAL(_SELF(self)->domain);
 }
 
 static VALUE
-get_signature(VALUE self)
+rg_signature(VALUE self)
 {
     GdkPixbufModulePattern* signature = _SELF(self)->signature;
 
@@ -123,23 +133,23 @@ get_signature(VALUE self)
 
 #if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
 static VALUE
-is_scalable(VALUE self)
+rg_scalable_p(VALUE self)
 {
     return CBOOL2RVAL(gdk_pixbuf_format_is_scalable(_SELF(self)));
 }
 static VALUE
-is_disabled(VALUE self)
+rg_disabled_p(VALUE self)
 {
     return CBOOL2RVAL(gdk_pixbuf_format_is_disabled(_SELF(self)));
 }
 static VALUE
-set_disabled(VALUE self, VALUE disabled)
+rg_set_disabled(VALUE self, VALUE disabled)
 {
     gdk_pixbuf_format_set_disabled(_SELF(self), RVAL2CBOOL(disabled));
     return self;
 }
 static VALUE
-get_license(VALUE self)
+rg_license(VALUE self)
 {
     return CSTR2RVAL(gdk_pixbuf_format_get_license(_SELF(self)));
 }
@@ -149,23 +159,22 @@ void
 Init_gdk_pixbuf_format(VALUE mGdk)
 {
 #if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
-    VALUE format = G_DEF_CLASS(GDK_TYPE_PIXBUF_FORMAT, "PixbufFormat", mGdk);
-
-    rb_define_method(format, "name", get_name, 0);
-    rb_define_method(format, "description", get_description, 0);
-    rb_define_method(format, "mime_types", get_mime_types, 0);
-    rb_define_method(format, "extensions", get_extensions, 0);
-    rb_define_method(format, "writable?", is_writable, 0);
-    rb_define_method(format, "domain", get_domain, 0);
-    rb_define_method(format, "signature", get_signature, 0);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_PIXBUF_FORMAT, "PixbufFormat", mGdk);
+
+    RG_DEF_METHOD(name, 0);
+    RG_DEF_METHOD(description, 0);
+    RG_DEF_METHOD(mime_types, 0);
+    RG_DEF_METHOD(extensions, 0);
+    RG_DEF_METHOD_P(writable, 0);
+    RG_DEF_METHOD(domain, 0);
+    RG_DEF_METHOD(signature, 0);
 #if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
-    rb_define_method(format, "scalable?", is_scalable, 0);
-    rb_define_method(format, "disabled?", is_disabled, 0);
-    rb_define_method(format, "set_disabled", set_disabled, 1);
-    rb_define_method(format, "license", get_license, 0);
+    RG_DEF_METHOD_P(scalable, 0);
+    RG_DEF_METHOD_P(disabled, 0);
+    RG_DEF_METHOD(set_disabled, 1);
+    RG_DEF_METHOD(license, 0);
 
 #endif
-    G_DEF_SETTERS(format);
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 #endif
 }
-

data/ext/gdk_pixbuf2/rbgdk-pixbuf-loader.c

@@ -1,24 +1,35 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgdk-pixbuf-loader.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 14:27:06 $
-
-  Copyright (C) 2004 Masao Mutoh
-  Copyright (C) 2003 Geoff Youngs
-************************************************/
-
-#include "rbgdk-pixbuf.h"
-
-#define _SELF(s) GDK_PIXBUF_LOADER(RVAL2GOBJ(s))
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004  Masao Mutoh
+ *  Copyright (C) 2003  Geoff Youngs
+ *
+ *  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 "rbgdk-pixbuf2private.h"
+
+#define RG_TARGET_NAMESPACE cPixbufLoader
+#define _SELF(s) RVAL2GDKPIXBUFLOADER(s)
 
 /****************************************************/
 /* File opening */
 /* Image Data in Memory */
 static VALUE
-initialize_loader(int argc, VALUE *argv, VALUE self)
+rg_initialize(int argc, VALUE *argv, VALUE self)
 {
     GdkPixbufLoader* loader;
     GError* error = NULL;
@@ -42,25 +53,25 @@ initialize_loader(int argc, VALUE *argv, VALUE self)
         }
         if(error) RAISE_GERROR(error);
     }
-    
+
     G_INITIALIZE(self, loader);
     return Qnil;
 }
 
 #if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
 static VALUE
-loader_get_format(VALUE self)
+rg_format(VALUE self)
 {
     GdkPixbufFormat* format = gdk_pixbuf_loader_get_format(_SELF(self));
-    return BOXED2RVAL(format, GDK_TYPE_PIXBUF_FORMAT);
+    return GDKPIXBUFFORMAT2RVAL(format);
 }
 #endif
 
 static VALUE
-loader_write(VALUE self, VALUE data)
+rg_write(VALUE self, VALUE data)
 {
     GError *error = NULL;
-  
+
     StringValue(data);
     if (!gdk_pixbuf_loader_write(_SELF(self),
                                  (const guchar *)RSTRING_PTR(data),
@@ -72,7 +83,7 @@ loader_write(VALUE self, VALUE data)
 }
 
 static VALUE
-last_write(VALUE self, VALUE data)
+rg_last_write(VALUE self, VALUE data)
 {
     GError *error = NULL;
 
@@ -91,7 +102,7 @@ last_write(VALUE self, VALUE data)
 
 #if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
 static VALUE
-loader_set_size(VALUE self, VALUE width, VALUE height)
+rg_set_size(VALUE self, VALUE width, VALUE height)
 {
     gdk_pixbuf_loader_set_size(_SELF(self), NUM2INT(width), NUM2INT(height));
     return self;
@@ -99,56 +110,55 @@ loader_set_size(VALUE self, VALUE width, VALUE height)
 #endif
 
 static VALUE
-loader_close(VALUE self)
+rg_close(VALUE self)
 {
     GError *error = NULL;
     gboolean res;
-	
+
     res = gdk_pixbuf_loader_close(_SELF(self), &error);
     if(error)
         RAISE_GERROR(error);
-	
+
     return CBOOL2RVAL(res);
 }
 
 /****************************************************/
 /* Creating image */
 static VALUE
-get_pixbuf(VALUE self)
+rg_pixbuf(VALUE self)
 {
     return GOBJ2RVAL(gdk_pixbuf_loader_get_pixbuf(_SELF(self)));
 }
 
 /* Creating animation */
 static VALUE
-get_animation(VALUE self)
+rg_animation(VALUE self)
 {
     return GOBJ2RVAL(gdk_pixbuf_loader_get_animation(_SELF(self)));
 }
 
-
 void 
 Init_gdk_pixbuf_loader(VALUE mGdk)
 {
-    VALUE gdkPixbufLoader;
+    VALUE RG_TARGET_NAMESPACE;
     /* initialize it */
-    gdkPixbufLoader = G_DEF_CLASS(GDK_TYPE_PIXBUF_LOADER, "PixbufLoader", mGdk);    
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_PIXBUF_LOADER, "PixbufLoader", mGdk);    
 
     /* 
      * File Loading, Image Data in Memory
      */
-    rb_define_method(gdkPixbufLoader, "initialize", initialize_loader, -1);
+    RG_DEF_METHOD(initialize, -1);
 
-    rb_undef_method(gdkPixbufLoader, "dup");
+    rb_undef_method(RG_TARGET_NAMESPACE, "dup");
 #if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
-    rb_define_method(gdkPixbufLoader, "format", loader_get_format, 0);
+    RG_DEF_METHOD(format, 0);
 #endif
-    rb_define_method(gdkPixbufLoader, "write", loader_write, 1);
-    rb_define_method(gdkPixbufLoader, "last_write", last_write, 1);
+    RG_DEF_METHOD(write, 1);
+    RG_DEF_METHOD(last_write, 1);
 #if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
-    rb_define_method(gdkPixbufLoader, "set_size", loader_set_size, 2);
+    RG_DEF_METHOD(set_size, 2);
 #endif
-    rb_define_method(gdkPixbufLoader, "close", loader_close, 0);
-    rb_define_method(gdkPixbufLoader, "pixbuf", get_pixbuf, 0);
-    rb_define_method(gdkPixbufLoader, "animation", get_animation, 0);
-}
+    RG_DEF_METHOD(close, 0);
+    RG_DEF_METHOD(pixbuf, 0);
+    RG_DEF_METHOD(animation, 0);
+}

data/ext/gdk_pixbuf2/rbgdk-pixbuf.c

@@ -1,16 +1,26 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgdk-pixbuf.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:28 $
-
-  Copyright (C) 2002-2004 Masao Mutoh
-  Copyright (C) 2000 Yasushi Shoji
-************************************************/
-
-#include "rbgdk-pixbuf.h"
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2004 Masao Mutoh
+ *  Copyright (C) 2000  Yasushi Shoji
+ *
+ *  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 "rbgdk-pixbuf2private.h"
 #include <string.h>
 
 #ifdef HAVE_GDK_PIXBUF_GDK_PIXBUF_IO_H
@@ -18,7 +28,8 @@
 #include <gdk-pixbuf/gdk-pixbuf-io.h>
 #endif
 
-#define _SELF(s) GDK_PIXBUF(RVAL2GOBJ(s)) 
+#define RG_TARGET_NAMESPACE cPixbuf
+#define _SELF(s) RVAL2GDKPIXBUF(s) 
 
 #define NOMEM_ERROR(error) g_set_error(error,\
                              GDK_PIXBUF_ERROR,\
@@ -55,7 +66,7 @@ get_pixels(VALUE self)
 }
 
 static VALUE
-set_pixels(VALUE self, VALUE pixels)
+rg_operator_set_pixels(VALUE self, VALUE pixels)
 {
     GdkPixbuf *pixbuf = _SELF(self);
     int size;
@@ -79,7 +90,7 @@ set_pixels(VALUE self, VALUE pixels)
 }
 
 static VALUE
-get_option(VALUE self, VALUE key)
+rg_get_option(VALUE self, VALUE key)
 {
     const gchar* ret = gdk_pixbuf_get_option(_SELF(self), RVAL2CSTR(key));
     return ret ? CSTR2RVAL(ret) : Qnil;
@@ -88,30 +99,125 @@ get_option(VALUE self, VALUE key)
 /****************************************************/
 /* File opening */
 /* Image Data in Memory */
-static VALUE
-initialize(int argc, VALUE *argv, VALUE self)
+static GdkPixbuf *
+pixbuf_initialize_by_hash(VALUE self, VALUE arg, GError **error)
 {
-    GdkPixbuf* buf;
-    GError* error = NULL;
-    VALUE arg1, arg2, arg3, arg4, arg5, arg6, arg7;
+    GdkPixbuf *buf = NULL;
+
+    VALUE rb_colorspace, rb_has_alpha, rb_bits_per_sample, rb_width, rb_height,
+          rb_data, rb_rowstride, rb_xpm, rb_inline, rb_copy_pixels,
+          rb_src_pixbuf, rb_src_x, rb_src_y,
+          rb_file, rb_scale_width, rb_scale_height, rb_preserve_aspect_ratio;
+    rbg_scan_options(arg,
+                     "colorspace", &rb_colorspace,
+                     "has_alpha", &rb_has_alpha,
+                     "bits_per_sample", &rb_bits_per_sample,
+                     "width", &rb_width,
+                     "height", &rb_height,
+                     "data", &rb_data,
+                     "rowstride", &rb_rowstride,
+                     "xpm", &rb_xpm,
+                     "inline", &rb_inline,
+                     "copy_pixels", &rb_copy_pixels,
+                     "src_pixbuf", &rb_src_pixbuf,
+                     "src_x", &rb_src_x,
+                     "src_y", &rb_src_y,
+                     "file", &rb_file,
+                     "scale_width", &rb_scale_width,
+                     "scale_height", &rb_scale_height,
+                     "preserve_aspect_ratio", &rb_preserve_aspect_ratio,
+                     NULL);
+
+    if (!NIL_P(rb_data)) {
+        buf = gdk_pixbuf_new_from_data((const guchar*)RVAL2CSTR(rb_data),
+                                       NIL_P(rb_colorspace) ? GDK_COLORSPACE_RGB : RVAL2GDKCOLORSPACE(rb_colorspace),
+                                       RVAL2CBOOL(rb_has_alpha),
+                                       NIL_P(rb_bits_per_sample) ? 8 : NUM2INT(rb_bits_per_sample),
+                                       NUM2INT(rb_width),
+                                       NUM2INT(rb_height),
+                                       NUM2INT(rb_rowstride),
+                                       NULL, NULL);
+        if (buf == NULL)
+            NOMEM_ERROR(error);
+        // Save a reference to the string because the pixbuf doesn't copy it.
+        G_RELATIVE(self, rb_data);
+    } else if (!NIL_P(rb_xpm)) {
+        const gchar **data = RVAL2STRV(rb_xpm);
+        buf = gdk_pixbuf_new_from_xpm_data(data);
+        g_free(data);
+        if (buf == NULL)
+            NOMEM_ERROR(error);
+    } else if (!NIL_P(rb_inline)) {
+        /* TODO: Is this really up to the caller to decide? */
+        long n;
+        guint8 *data = RVAL2GUINT8S(rb_inline, n);
+        buf = gdk_pixbuf_new_from_inline(n, data, RVAL2CBOOL(rb_copy_pixels), error);
+        /* need to manage the returned value */
+        rb_ivar_set(self, id_pixdata, Data_Wrap_Struct(rb_cData, NULL, g_free, data));
+    } else if (!NIL_P(rb_src_pixbuf)) {
+        buf = gdk_pixbuf_new_subpixbuf(_SELF(rb_src_pixbuf),
+                                       NUM2INT(rb_src_x),
+                                       NUM2INT(rb_src_y),
+                                       NUM2INT(rb_width),
+                                       NUM2INT(rb_height));
+        if (buf == NULL)
+            NOMEM_ERROR(error);
+    } else if (!NIL_P(rb_file)) {
+        if (!NIL_P(rb_width)) {
+#if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
+            buf = gdk_pixbuf_new_from_file_at_size(RVAL2CSTR(rb_file),
+                                                   NUM2INT(rb_width),
+                                                   NUM2INT(rb_height),
+                                                   error);
+#else
+            rb_warning("Sizing on load not supported in GTK+ < 2.4.0");
+            buf = gdk_pixbuf_new_from_file(RVAL2CSTR(rb_file), error);
+#endif
+        } else if (!NIL_P(rb_scale_width)) {
+#if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
+            int width = NUM2INT(rb_scale_width);
+            int height = NUM2INT(rb_scale_height);
+#if !RBGDK_PIXBUF_CHECK_VERSION(2,8,0)
+            if (width < 0 || height < 0)
+                rb_warning("For scaling on load, a negative value for width or height are not supported in GTK+ < 2.8.0");
+#endif
+            buf = gdk_pixbuf_new_from_file_at_scale(RVAL2CSTR(rb_file),
+                                                    width, height,
+                                                    NIL_P(rb_preserve_aspect_ratio) ? TRUE : RVAL2CBOOL(rb_preserve_aspect_ratio),
+                                                    error);
+#else
+            rb_warning("Scaling on load not supported in GTK+ < 2.6.0");
+            buf = gdk_pixbuf_new_from_file(RVAL2CSTR(rb_file), error);
+#endif
+        } else {
+            buf = gdk_pixbuf_new_from_file(RVAL2CSTR(rb_file), error);
+        }
+    } else {
+        buf = gdk_pixbuf_new(NIL_P(rb_colorspace) ? GDK_COLORSPACE_RGB : RVAL2GDKCOLORSPACE(rb_colorspace),
+                             RVAL2CBOOL(rb_has_alpha),
+                             NIL_P(rb_bits_per_sample) ? 8 : NUM2INT(rb_bits_per_sample),
+                             NUM2INT(rb_width),
+                             NUM2INT(rb_height));
+        if (buf == NULL)
+            NOMEM_ERROR(error);
+    }
 
-    rb_scan_args(argc, argv, "16", &arg1, &arg2, &arg3, &arg4, &arg5, &arg6, &arg7);
+    return buf;
+}
+
+/* TODO: make deprecated */
+static GdkPixbuf *
+pixbuf_initialize(VALUE self, int argc, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7, GError **error)
+{
+    GdkPixbuf* buf;
 
     if (argc == 7){
         buf = gdk_pixbuf_new_from_data((const guchar*)RVAL2CSTR(arg1), 
-                                       RVAL2GENUM(arg2, GDK_TYPE_COLORSPACE),
+                                       RVAL2GDKCOLORSPACE(arg2),
                                        RVAL2CBOOL(arg3),   NUM2INT(arg4),
                                        NUM2INT(arg5), NUM2INT(arg6),
                                        NUM2INT(arg7), NULL, NULL);
-        if (buf == NULL){
-            rb_gc();
-            buf = gdk_pixbuf_new_from_data((const guchar*)RVAL2CSTR(arg1), 
-                                           RVAL2GENUM(arg2, GDK_TYPE_COLORSPACE),
-                                           RVAL2CBOOL(arg3),   NUM2INT(arg4),
-                                           NUM2INT(arg5), NUM2INT(arg6),
-                                           NUM2INT(arg7), NULL, NULL);
-            if (buf == NULL) NOMEM_ERROR(&error);
-        }
+        if (buf == NULL) NOMEM_ERROR(error);
         // Save a reference to the string because the pixbuf doesn't copy it.
         G_RELATIVE(self, arg1);
     } else if (argc == 5){
@@ -119,24 +225,12 @@ initialize(int argc, VALUE *argv, VALUE self)
             buf = gdk_pixbuf_new_subpixbuf(_SELF(arg1), 
                                            NUM2INT(arg2), NUM2INT(arg3), 
                                            NUM2INT(arg4), NUM2INT(arg5));
-            if (buf == NULL){
-                rb_gc();
-                buf = gdk_pixbuf_new_subpixbuf(_SELF(arg1), 
-                                               NUM2INT(arg2), NUM2INT(arg3), 
-                                               NUM2INT(arg4), NUM2INT(arg5));
-                if (buf == NULL) NOMEM_ERROR(&error);
-            }
+            if (buf == NULL) NOMEM_ERROR(error);
         } else if (rb_obj_is_kind_of(arg1, GTYPE2CLASS(GDK_TYPE_COLORSPACE))){
-            buf = gdk_pixbuf_new(RVAL2GENUM(arg1, GDK_TYPE_COLORSPACE),
+            buf = gdk_pixbuf_new(RVAL2GDKCOLORSPACE(arg1),
                                  RVAL2CBOOL(arg2), NUM2INT(arg3),
                                  NUM2INT(arg4), NUM2INT(arg5));
-            if (buf == NULL){
-                rb_gc();
-                buf = gdk_pixbuf_new(RVAL2GENUM(arg1, GDK_TYPE_COLORSPACE),
-                                     RVAL2CBOOL(arg2), NUM2INT(arg3),
-                                     NUM2INT(arg4), NUM2INT(arg5));
-                if (buf == NULL) NOMEM_ERROR(&error);
-            }
+            if (buf == NULL) NOMEM_ERROR(error);
         } else {
             rb_raise(rb_eArgError, "Wrong type of 1st argument or wrong number of arguments");
         }
@@ -150,75 +244,38 @@ initialize(int argc, VALUE *argv, VALUE self)
 #endif
         buf = gdk_pixbuf_new_from_file_at_scale(RVAL2CSTR(arg1),
                                                 width, height,
-                                                RVAL2CBOOL(arg4), &error);
-        if (buf == NULL){
-            rb_gc();
-            error = NULL;
-            buf = gdk_pixbuf_new_from_file_at_scale(RVAL2CSTR(arg1),
-                                                    NUM2INT(arg2), NUM2INT(arg3), 
-                                                    RVAL2CBOOL(arg4), &error);
-        }
+                                                RVAL2CBOOL(arg4), error);
 #else
         rb_warning("Scaling on load not supported in GTK+ < 2.6.0");
-        buf = gdk_pixbuf_new_from_file(RVAL2CSTR(arg1), &error);
-        if (buf == NULL){
-            error = NULL;
-            rb_gc();
-            buf = gdk_pixbuf_new_from_file(RVAL2CSTR(arg1), &error);
-        }
+        buf = gdk_pixbuf_new_from_file(RVAL2CSTR(arg1), error);
 #endif
     } else if (argc == 3) {
 #if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
         buf = gdk_pixbuf_new_from_file_at_size(RVAL2CSTR(arg1),
-                                               NUM2INT(arg2), NUM2INT(arg3), &error);
-        if (buf == NULL){
-            rb_gc();
-            error = NULL;
-            buf = gdk_pixbuf_new_from_file_at_size(RVAL2CSTR(arg1),
-                                                   NUM2INT(arg2), NUM2INT(arg3), &error);
-        }
+                                               NUM2INT(arg2), NUM2INT(arg3), error);
 #else
         rb_warning("Sizing on load not supported in GTK+ < 2.4.0");
-        buf = gdk_pixbuf_new_from_file(RVAL2CSTR(arg1), &error);
-        if (buf == NULL){
-            error = NULL;
-            rb_gc();
-            buf = gdk_pixbuf_new_from_file(RVAL2CSTR(arg1), &error);
-        }
+        buf = gdk_pixbuf_new_from_file(RVAL2CSTR(arg1), error);
 #endif
-    } else if (argc == 2){
-        int i;
-        int len = RARRAY_LEN(arg1); 
-        guint8 *gstream = g_new(guint8, len);
-        for (i = 0; i < len; i++){
-            gstream[i] = (guint8)NUM2UINT(RARRAY_PTR(arg1)[i]);
-        }      
-        buf = gdk_pixbuf_new_from_inline(len, gstream, RVAL2CBOOL(arg2), &error);
-        if (buf == NULL){
-            rb_gc();
-            error = NULL;
-            buf = gdk_pixbuf_new_from_inline(len, gstream, RVAL2CBOOL(arg2), &error);
-        }
+    } else if (argc == 2) {
+        /* TODO: Is this really up to the caller to decide? */
+        gboolean copy_pixels = RVAL2CBOOL(arg2);
+        long n;
+        guint8 *data = RVAL2GUINT8S(arg1, n);
+        buf = gdk_pixbuf_new_from_inline(n, data, copy_pixels, error);
         /* need to manage the returned value */
-        rb_ivar_set(self, id_pixdata, Data_Wrap_Struct(rb_cData, NULL, g_free, gstream));
+        rb_ivar_set(self, id_pixdata, Data_Wrap_Struct(rb_cData, NULL, g_free, data));
     } else if (argc == 1){
         if (TYPE(arg1) == T_STRING) {
-            buf = gdk_pixbuf_new_from_file(RVAL2CSTR(arg1), &error);
-            if (buf == NULL){
-                rb_gc();
-                error = NULL;
-                buf = gdk_pixbuf_new_from_file(RVAL2CSTR(arg1), &error);
-            }
+            buf = gdk_pixbuf_new_from_file(RVAL2CSTR(arg1), error);
         } else if (TYPE(arg1) == T_ARRAY) {
             const gchar **data = RVAL2STRV(arg1);
             buf = gdk_pixbuf_new_from_xpm_data(data);
-            if (buf == NULL) {
-                rb_gc();
-                buf = gdk_pixbuf_new_from_xpm_data(data);
-            }
             g_free(data);
             if (buf == NULL)
-                NOMEM_ERROR(&error);
+                NOMEM_ERROR(error);
+        } else if (TYPE(arg1) == T_HASH) {
+            buf = pixbuf_initialize_by_hash(self, arg1, error);
         } else {
             rb_raise(rb_eArgError, "Wrong type of 1st argument or wrong number of arguments");
         }
@@ -226,14 +283,33 @@ initialize(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "Wrong number of arguments");
     }
 
-    if (error || ! buf) RAISE_GERROR(error);
-    
+    return buf;
+}
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE arg1, arg2, arg3, arg4, arg5, arg6, arg7;
+    GdkPixbuf *buf;
+    GError *error = NULL;
+
+    rb_scan_args(argc, argv, "16", &arg1, &arg2, &arg3, &arg4, &arg5, &arg6, &arg7);
+    buf = pixbuf_initialize(self, argc, arg1, arg2, arg3, arg4, arg5, arg6, arg7, &error);
+    if (buf == NULL) {
+        rb_gc();
+        g_error_free(error);
+        error = NULL;
+        buf = pixbuf_initialize(self, argc, arg1, arg2, arg3, arg4, arg5, arg6, arg7, &error);
+    }
+    if (error || !buf)
+        RAISE_GERROR(error);
+
     G_INITIALIZE(self, buf);
     return Qnil;
 }
 
 static VALUE
-copy(VALUE self)
+rg_dup(VALUE self)
 {
     VALUE ret;
     GdkPixbuf* dest = gdk_pixbuf_copy(_SELF(self));
@@ -246,13 +322,13 @@ copy(VALUE self)
 
 #if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
 static VALUE
-get_file_info(VALUE self, VALUE filename)
+rg_s_get_file_info(G_GNUC_UNUSED VALUE self, VALUE filename)
 {
     gint width, height;
 
     GdkPixbufFormat* format = gdk_pixbuf_get_file_info(RVAL2CSTR(filename), 
                                                        &width, &height);
-    return format ? rb_ary_new3(3, BOXED2RVAL(format, GDK_TYPE_PIXBUF_FORMAT), INT2NUM(width), INT2NUM(height)) : Qnil;
+    return format ? rb_ary_new3(3, GDKPIXBUFFORMAT2RVAL(format), INT2NUM(width), INT2NUM(height)) : Qnil;
 }
 
 #endif
@@ -315,7 +391,7 @@ save_to(VALUE self, const gchar *filename, const gchar *type, VALUE options)
 /****************************************************/
 /* File saving */
 static VALUE
-save(int argc, VALUE *argv, VALUE self)
+rg_save(int argc, VALUE *argv, VALUE self)
 {
     VALUE filename, type, options;
 
@@ -336,7 +412,7 @@ gboolean    gdk_pixbuf_save_to_callbackv    (GdkPixbuf *pixbuf,
 */
 
 static VALUE
-save_to_buffer(int argc, VALUE *argv, VALUE self)
+rg_save_to_buffer(int argc, VALUE *argv, VALUE self)
 {
     VALUE type, options;
 
@@ -349,7 +425,7 @@ save_to_buffer(int argc, VALUE *argv, VALUE self)
 /****************************************************/
 /* Scaling */
 static VALUE
-scale_simple(int argc, VALUE *argv, VALUE self)
+rg_scale(int argc, VALUE *argv, VALUE self)
 {
     GdkPixbuf* dest;
     VALUE dest_width, dest_height, interp_type, ret;
@@ -359,8 +435,8 @@ scale_simple(int argc, VALUE *argv, VALUE self)
                  &interp_type);
 
     if (!NIL_P(interp_type))
-        type = RVAL2GENUM(interp_type, GDK_TYPE_INTERP_TYPE);
-    
+        type = RVAL2GDKINTERPTYPE(interp_type);
+
     dest = gdk_pixbuf_scale_simple(_SELF(self),
                                    NUM2INT(dest_width),
                                    NUM2INT(dest_height),
@@ -374,7 +450,7 @@ scale_simple(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-scale(int argc, VALUE *argv, VALUE self)
+rg_scale_bang(int argc, VALUE *argv, VALUE self)
 {
     GdkInterpType type = GDK_INTERP_BILINEAR;
 
@@ -386,7 +462,7 @@ scale(int argc, VALUE *argv, VALUE self)
                  &scale_x, &scale_y, &interp_type);
 
     if (!NIL_P(interp_type))
-        type = RVAL2GENUM(interp_type, GDK_TYPE_INTERP_TYPE);
+        type = RVAL2GDKINTERPTYPE(interp_type);
 
     gdk_pixbuf_scale(_SELF(src), _SELF(self), 
                      NUM2INT(src_x), NUM2INT(src_y), 
@@ -397,14 +473,14 @@ scale(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-composite_simple(VALUE self, VALUE dest_width, VALUE dest_height, VALUE interp_type, VALUE overall_alpha, VALUE check_size, VALUE color1, VALUE color2)
+rg_composite(VALUE self, VALUE dest_width, VALUE dest_height, VALUE interp_type, VALUE overall_alpha, VALUE check_size, VALUE color1, VALUE color2)
 {
     GdkPixbuf* dest;
     VALUE ret;
     GdkInterpType type = GDK_INTERP_BILINEAR;
 
     if (!NIL_P(interp_type))
-        type = RVAL2GENUM(interp_type, GDK_TYPE_INTERP_TYPE);
+        type = RVAL2GDKINTERPTYPE(interp_type);
 
     dest = gdk_pixbuf_composite_color_simple(
         _SELF(self), NUM2INT(dest_width), NUM2INT(dest_height), 
@@ -420,7 +496,7 @@ composite_simple(VALUE self, VALUE dest_width, VALUE dest_height, VALUE interp_t
 }
 
 static VALUE
-composite(int argc, VALUE *argv, VALUE self)
+rg_composite_bang(int argc, VALUE *argv, VALUE self)
 {
     VALUE ret;
     VALUE args[16];
@@ -434,8 +510,8 @@ composite(int argc, VALUE *argv, VALUE self)
 
     switch (argc) {
       case 11:
-	if (!NIL_P(args[9]))
-	    interp_type = RVAL2GENUM(args[9], GDK_TYPE_INTERP_TYPE);
+        if (!NIL_P(args[9]))
+            interp_type = RVAL2GDKINTERPTYPE(args[9]);
 
         gdk_pixbuf_composite(_SELF(args[0]), _SELF(self), 
                              NUM2INT(args[1]), NUM2INT(args[2]),
@@ -446,8 +522,8 @@ composite(int argc, VALUE *argv, VALUE self)
         ret = self;
         break;
       case 16:
-	if (!NIL_P(args[9]))
-	    interp_type = RVAL2GENUM(args[9], GDK_TYPE_INTERP_TYPE);
+        if (!NIL_P(args[9]))
+            interp_type = RVAL2GDKINTERPTYPE(args[9]);
 
         gdk_pixbuf_composite_color(_SELF(args[0]), _SELF(self),
                                    NUM2INT(args[1]), NUM2INT(args[2]),
@@ -461,18 +537,18 @@ composite(int argc, VALUE *argv, VALUE self)
         ret = self;
         break;
       default:
-	rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
-	break;
+        rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
+        break;
     }
     return ret;
 }
 
 #if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
 static VALUE
-rotate_simple(VALUE self, VALUE angle)
+rg_rotate(VALUE self, VALUE angle)
 {
     VALUE ret;
-    GdkPixbuf* dest = gdk_pixbuf_rotate_simple(_SELF(self), RVAL2GENUM(angle, GDK_TYPE_PIXBUF_ROTATION));
+    GdkPixbuf* dest = gdk_pixbuf_rotate_simple(_SELF(self), RVAL2GDKPIXBUFROTATION(angle));
     if (dest == NULL)
         return Qnil;
     ret = GOBJ2RVAL(dest);
@@ -481,7 +557,7 @@ rotate_simple(VALUE self, VALUE angle)
 }
 
 static VALUE
-flip(VALUE self, VALUE horizontal)
+rg_flip(VALUE self, VALUE horizontal)
 {
     VALUE ret;
     GdkPixbuf* dest = gdk_pixbuf_flip(_SELF(self), RVAL2CBOOL(horizontal));
@@ -494,7 +570,7 @@ flip(VALUE self, VALUE horizontal)
 #endif
 
 static VALUE
-add_alpha(VALUE self, VALUE substitute_color, VALUE r, VALUE g, VALUE b)
+rg_add_alpha(VALUE self, VALUE substitute_color, VALUE r, VALUE g, VALUE b)
 {
     VALUE ret;
     GdkPixbuf* dest = gdk_pixbuf_add_alpha(_SELF(self),
@@ -508,7 +584,7 @@ add_alpha(VALUE self, VALUE substitute_color, VALUE r, VALUE g, VALUE b)
 }
 
 static VALUE
-copy_area(VALUE self, VALUE src_x, VALUE src_y, VALUE width, VALUE height, VALUE dest, VALUE dest_x, VALUE dest_y)
+rg_copy_area(VALUE self, VALUE src_x, VALUE src_y, VALUE width, VALUE height, VALUE dest, VALUE dest_x, VALUE dest_y)
 {
     gdk_pixbuf_copy_area(_SELF(self), NUM2INT(src_x), NUM2INT(src_y),
                          NUM2INT(width), NUM2INT(height),
@@ -517,7 +593,7 @@ copy_area(VALUE self, VALUE src_x, VALUE src_y, VALUE width, VALUE height, VALUE
 }
 
 static VALUE
-saturate_and_pixelate(VALUE self, VALUE staturation, VALUE pixelate)
+rg_saturate_and_pixelate(VALUE self, VALUE staturation, VALUE pixelate)
 {
     GdkPixbuf* dest = gdk_pixbuf_copy(_SELF(self));
     gdk_pixbuf_saturate_and_pixelate(_SELF(self), dest, 
@@ -526,7 +602,7 @@ saturate_and_pixelate(VALUE self, VALUE staturation, VALUE pixelate)
 }
 
 static VALUE
-fill(VALUE self, VALUE pixel)
+rg_fill_bang(VALUE self, VALUE pixel)
 {
     gdk_pixbuf_fill(_SELF(self), NUM2UINT(pixel));
     return self;
@@ -535,35 +611,40 @@ fill(VALUE self, VALUE pixel)
 /* From Module Interface */
 #if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
 static VALUE
-get_formats(VALUE self)
+rg_s_formats(G_GNUC_UNUSED VALUE self)
 {
     return GSLIST2ARY2(gdk_pixbuf_get_formats(), GDK_TYPE_PIXBUF_FORMAT);
 }
 
+#ifdef HAVE_GDK_PIXBUF_SET_OPTION
 static VALUE
-set_option(VALUE self, VALUE key, VALUE value)
+rg_set_option(VALUE self, VALUE key, VALUE value)
 {
-#if HAVE_GDK_PIXBUF_SET_OPTION
-    return CBOOL2RVAL(gdk_pixbuf_set_option(_SELF(self), 
+    return CBOOL2RVAL(gdk_pixbuf_set_option(_SELF(self),
                                             RVAL2CSTR(key), RVAL2CSTR(value)));
+}
 #else
+static VALUE
+set_option(G_GNUC_UNUSED VALUE self, G_GNUC_UNUSED VALUE key, G_GNUC_UNUSED VALUE value)
+{
     rb_warning("not supported in this version of GTK+");
     return Qfalse;
-#endif
 }
 #endif
+#endif
+
+extern void Init_gdk_pixbuf2(void);
 
-void 
-Init_gdk_pixbuf2()
+void
+Init_gdk_pixbuf2(void)
 {
     VALUE mGdk = rb_define_module("Gdk");
-    VALUE gdkPixbuf = G_DEF_CLASS(GDK_TYPE_PIXBUF, "Pixbuf", mGdk);    
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_PIXBUF, "Pixbuf", mGdk);    
 
     id_pixdata = rb_intern("pixdata");
-   
+
     /*
     gdk_rgb_init();*/ /* initialize it anyway */
-    
 
     /*
      * Initialization and Versions 
@@ -571,86 +652,87 @@ Init_gdk_pixbuf2()
 /* Removed. This crashes Ruby/GTK on Windows + GTK+-2.4.x.
    Pointed out by Laurent.
 #ifdef HAVE_GDK_PIXBUF_VERSION
-    rb_define_const(gdkPixbuf, "VERSION", CSTR2RVAL(gdk_pixbuf_version));
+    rb_define_const(RG_TARGET_NAMESPACE, "VERSION", CSTR2RVAL(gdk_pixbuf_version));
 #endif
 */
-    rb_define_const(gdkPixbuf, "MAJOR", INT2FIX(GDK_PIXBUF_MAJOR));
-    rb_define_const(gdkPixbuf, "MINOR", INT2FIX(GDK_PIXBUF_MINOR));
-    rb_define_const(gdkPixbuf, "MICRO", INT2FIX(GDK_PIXBUF_MICRO));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAJOR", INT2FIX(GDK_PIXBUF_MAJOR));
+    rb_define_const(RG_TARGET_NAMESPACE, "MINOR", INT2FIX(GDK_PIXBUF_MINOR));
+    rb_define_const(RG_TARGET_NAMESPACE, "MICRO", INT2FIX(GDK_PIXBUF_MICRO));
 
     /* 
      * The GdkPixbuf Structure 
      */
-    G_REPLACE_GET_PROPERTY(gdkPixbuf, "pixels", get_pixels, 0);
-    rb_define_method(gdkPixbuf, "pixels=", set_pixels, 1);
-    rb_define_method(gdkPixbuf, "get_option", get_option, 1);
+    G_REPLACE_GET_PROPERTY(RG_TARGET_NAMESPACE, "pixels", get_pixels, 0);
+    RG_DEF_METHOD_OPERATOR("pixels=", set_pixels, 1);
+    RG_DEF_METHOD(get_option, 1);
 
     /* GdkPixbufError */
     G_DEF_ERROR(GDK_PIXBUF_ERROR, "PixbufError", mGdk, rb_eRuntimeError, GDK_TYPE_PIXBUF_ERROR);
 
     /* GdkColorspace */
-    G_DEF_CLASS(GDK_TYPE_COLORSPACE, "ColorSpace", gdkPixbuf);
-    G_DEF_CONSTANTS(gdkPixbuf, GDK_TYPE_COLORSPACE, "GDK_");
+    G_DEF_CLASS(GDK_TYPE_COLORSPACE, "ColorSpace", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_COLORSPACE, "GDK_");
 
     /* GdkPixbufAlphaMode */
-    G_DEF_CLASS(GDK_TYPE_PIXBUF_ALPHA_MODE, "AlphaMode", gdkPixbuf);
-    G_DEF_CONSTANTS(gdkPixbuf, GDK_TYPE_PIXBUF_ALPHA_MODE, "GDK_PIXBUF_");
+    G_DEF_CLASS(GDK_TYPE_PIXBUF_ALPHA_MODE, "AlphaMode", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_PIXBUF_ALPHA_MODE, "GDK_PIXBUF_");
 
     /* 
      * File Loading, Image Data in Memory
      */
-    rb_define_method(gdkPixbuf, "initialize", initialize, -1);
-    rb_define_method(gdkPixbuf, "dup", copy, 0);
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(dup, 0);
 #if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
-    rb_define_singleton_method(gdkPixbuf, "get_file_info", get_file_info, 1);
+    RG_DEF_SMETHOD(get_file_info, 1);
 #endif
 
     /*
      * File saving
      */
-    rb_define_method(gdkPixbuf, "save", save, -1);
+    RG_DEF_METHOD(save, -1);
 #if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
-    rb_define_method(gdkPixbuf, "save_to_buffer", save_to_buffer, -1);
+    RG_DEF_METHOD(save_to_buffer, -1);
 #endif
 
     /*
      * Scaling
      */
-    rb_define_method(gdkPixbuf, "scale", scale_simple, -1);
-    rb_define_method(gdkPixbuf, "scale!", scale, -1);
-    rb_define_method(gdkPixbuf, "composite", composite_simple, 7);
-    rb_define_method(gdkPixbuf, "composite!", composite, -1);
+    RG_DEF_METHOD(scale, -1);
+    RG_DEF_METHOD_BANG(scale, -1);
+    RG_DEF_METHOD(composite, 7);
+    RG_DEF_METHOD_BANG(composite, -1);
 #if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
-    rb_define_method(gdkPixbuf, "rotate", rotate_simple, 1);
-    rb_define_method(gdkPixbuf, "flip", flip, 1);
+    RG_DEF_METHOD(rotate, 1);
+    RG_DEF_METHOD(flip, 1);
 #endif
 
     /* GdkInterpType */
-    G_DEF_CLASS(GDK_TYPE_INTERP_TYPE, "InterpType", gdkPixbuf);
-    G_DEF_CONSTANTS(gdkPixbuf, GDK_TYPE_INTERP_TYPE, "GDK_");
+    G_DEF_CLASS(GDK_TYPE_INTERP_TYPE, "InterpType", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_INTERP_TYPE, "GDK_");
 
 #if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
     /* GdkPixbufRotation */
-    G_DEF_CLASS(GDK_TYPE_PIXBUF_ROTATION, "GdkPixbufRotation", gdkPixbuf);
-    G_DEF_CONSTANTS(gdkPixbuf, GDK_TYPE_PIXBUF_ROTATION, "GDK_PIXBUF_");
+    G_DEF_CLASS(GDK_TYPE_PIXBUF_ROTATION, "GdkPixbufRotation", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_PIXBUF_ROTATION, "GDK_PIXBUF_");
 #endif
     /*
      * Utilities
      */
-    rb_define_method(gdkPixbuf, "add_alpha", add_alpha, 4);
-    rb_define_method(gdkPixbuf, "copy_area", copy_area, 7);
-    rb_define_method(gdkPixbuf, "saturate_and_pixelate", saturate_and_pixelate, 2);
-    rb_define_method(gdkPixbuf, "fill!", fill, 1);
+    RG_DEF_METHOD(add_alpha, 4);
+    RG_DEF_METHOD(copy_area, 7);
+    RG_DEF_METHOD(saturate_and_pixelate, 2);
+    RG_DEF_METHOD_BANG(fill, 1);
 
     /*
      * Module Interface
      */
 #if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
-    rb_define_singleton_method(gdkPixbuf, "formats", get_formats, 0);
-    rb_define_method(gdkPixbuf, "set_option", set_option, 2);
+    RG_DEF_SMETHOD(formats, 0);
+    RG_DEF_METHOD(set_option, 2);
 #endif
 
     Init_gdk_pixbuf_animation(mGdk);
+    Init_gdk_pixbuf_animation_iter(mGdk);
 #if RBGDK_PIXBUF_CHECK_VERSION(2,8,0)
     Init_gdk_pixbuf_simpleanim(mGdk);
 #endif