gdk_pixbuf2 2.2.4-x64-mingw32

data/ext/gdk_pixbuf2/rbgdk-pixbuf.h

@@ -0,0 +1,41 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-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
+ */
+
+#ifndef __RBGDK_PIXBUF_H__
+#define __RBGDK_PIXBUF_H__
+
+#define GDK_PIXBUF_ENABLE_BACKEND
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gdk-pixbuf/gdk-pixdata.h>
+#include "rbgobject.h"
+#include "rbgdk-pixbuf2conversions.h"
+
+extern GType gdk_pixbuf_format_get_type(void);
+
+#define RBGDK_PIXBUF_CHECK_VERSION(major,minor,micro)    \
+    (GDK_PIXBUF_MAJOR > (major) || \
+     (GDK_PIXBUF_MAJOR == (major) && GDK_PIXBUF_MINOR > (minor)) || \
+     (GDK_PIXBUF_MAJOR == (major) && GDK_PIXBUF_MINOR == (minor) && \
+      GDK_PIXBUF_MICRO >= (micro)))
+
+#define GDK_TYPE_PIXBUF_FORMAT (gdk_pixbuf_format_get_type())
+
+#endif /* __RBGDK_PIXBUF_H__ */

data/ext/gdk_pixbuf2/rbgdk-pixbuf2conversions.h

@@ -0,0 +1,42 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  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
+ */
+
+#ifndef __RBGDK_PIXBUF2CONVERSIONS_H__
+#define __RBGDK_PIXBUF2CONVERSIONS_H__
+
+#define RVAL2GDKPIXBUF(o)                  (GDK_PIXBUF(RVAL2GOBJ(o)))
+#define RVAL2GDKPIXBUFANIMATION(o)         (GDK_PIXBUF_ANIMATION(RVAL2GOBJ(o)))
+#define RVAL2GDKPIXBUFANIMATIONITER(o)     (GDK_PIXBUF_ANIMATION_ITER(RVAL2GOBJ(o)))
+#define RVAL2GDKPIXBUFLOADER(o)            (GDK_PIXBUF_LOADER(RVAL2GOBJ(o)))
+#define RVAL2GDKPIXBUFSIMPLEANIM(o)        (GDK_PIXBUF_SIMPLE_ANIM(RVAL2GOBJ(o)))
+
+#define RVAL2GDKPIXBUFFORMAT(o)            ((GdkPixbufFormat*)RVAL2BOXED(o, GDK_TYPE_PIXBUF_FORMAT))
+#define GDKPIXBUFFORMAT2RVAL(o)            (BOXED2RVAL(o, GDK_TYPE_PIXBUF_FORMAT))
+#define RVAL2GDKPIXDATA(o)                 ((GdkPixdata*)RVAL2BOXED(o, GDK_TYPE_PIXDATA))
+#define GDKPIXDATA2RVAL(o)                 (BOXED2RVAL(o, GDK_TYPE_PIXDATA))
+
+#define RVAL2GDKCOLORSPACE(o)              (RVAL2GENUM(o, GDK_TYPE_COLORSPACE))
+#define GDKCOLORSPACE2RVAL(o)              (GENUM2RVAL(o, GDK_TYPE_COLORSPACE))
+#define RVAL2GDKINTERPTYPE(o)              (RVAL2GENUM(o, GDK_TYPE_INTERP_TYPE))
+#define GDKINTERPTYPE2RVAL(o)              (GENUM2RVAL(o, GDK_TYPE_INTERP_TYPE))
+#define RVAL2GDKPIXBUFROTATION(o)          (RVAL2GENUM(o, GDK_TYPE_PIXBUF_ROTATION))
+#define GDKPIXBUFROTATION2RVAL(o)          (GENUM2RVAL(o, GDK_TYPE_PIXBUF_ROTATION))
+
+#endif /* __RBGDK_PIXBUF2CONVERSIONS_H__ */

data/ext/gdk_pixbuf2/rbgdk-pixbuf2private.h

@@ -0,0 +1,35 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  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
+ */
+
+#ifndef __RBGDK_PIXBUF2PRIVATE_H__
+#define __RBGDK_PIXBUF2PRIVATE_H__
+
+#include "rbgdk-pixbuf.h"
+
+G_GNUC_INTERNAL void Init_gdk_pixbuf_animation(VALUE mGLib);
+G_GNUC_INTERNAL void Init_gdk_pixbuf_animation_iter(VALUE mGLib);
+G_GNUC_INTERNAL void Init_gdk_pixbuf_format(VALUE mGLib);
+G_GNUC_INTERNAL void Init_gdk_pixbuf_loader(VALUE mGLib);
+#if RBGDK_PIXBUF_CHECK_VERSION(2,8,0)
+G_GNUC_INTERNAL void Init_gdk_pixbuf_simpleanim(VALUE mGLib);
+#endif
+G_GNUC_INTERNAL void Init_gdk_pixdata(VALUE mGLib);
+
+#endif /* __RBGDK_PIXBUF2PRIVATE_H__ */

data/ext/gdk_pixbuf2/rbgdk-pixbufanimation.c

@@ -0,0 +1,93 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 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"
+
+#define RG_TARGET_NAMESPACE cPixbufAnimation
+#define _SELF(s) (RVAL2GDKPIXBUFANIMATION(s))
+
+static VALUE
+rg_initialize(VALUE self, VALUE filename)
+{
+    GdkPixbufAnimation* ret;
+    GError* error = NULL;
+
+    ret = gdk_pixbuf_animation_new_from_file(RVAL2CSTR(filename), &error);
+    if (ret == NULL)
+        RAISE_GERROR(error);
+
+    G_INITIALIZE(self, ret);
+    return Qnil;
+}
+
+static VALUE
+rg_width(VALUE self)
+{
+    return INT2NUM(gdk_pixbuf_animation_get_width(_SELF(self)));
+}
+
+static VALUE
+rg_height(VALUE self)
+{
+    return INT2NUM(gdk_pixbuf_animation_get_height(_SELF(self)));
+}
+
+static VALUE
+rg_get_iter(int argc, VALUE *argv, VALUE self)
+{
+    VALUE start_time_sec, start_time_usec;
+    GTimeVal start_time;
+
+    rb_scan_args(argc, argv, "02", &start_time_sec, &start_time_usec);
+
+    if (NIL_P(start_time_sec))
+        return GOBJ2RVAL(gdk_pixbuf_animation_get_iter(_SELF(self), NULL));
+
+    start_time.tv_sec = NUM2LONG(start_time_sec);
+    start_time.tv_usec = NIL_P(start_time_usec) ? 0 : NUM2LONG(start_time_usec);
+
+    return GOBJ2RVAL(gdk_pixbuf_animation_get_iter(_SELF(self), &start_time));
+}
+
+static VALUE
+rg_static_image_p(VALUE self)
+{
+    return CBOOL2RVAL(gdk_pixbuf_animation_is_static_image(_SELF(self)));
+}
+
+static VALUE
+rg_static_image(VALUE self)
+{
+    return GOBJ2RVAL(gdk_pixbuf_animation_get_static_image(_SELF(self)));
+}
+
+void
+Init_gdk_pixbuf_animation(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_PIXBUF_ANIMATION, "PixbufAnimation", mGdk);    
+
+    RG_DEF_METHOD(initialize, 1);
+    RG_DEF_METHOD(width, 0);
+    RG_DEF_METHOD(height, 0);
+    RG_DEF_METHOD(get_iter, -1);
+    RG_DEF_METHOD_P(static_image, 0);
+    RG_DEF_METHOD(static_image, 0);
+}

data/ext/gdk_pixbuf2/rbgdk-pixbufanimationiter.c

@@ -0,0 +1,71 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 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"
+
+#define RG_TARGET_NAMESPACE cPixbufAnimationIter
+#define _SELF(i) (RVAL2GDKPIXBUFANIMATIONITER(i))
+
+static VALUE
+rg_advance(int argc, VALUE *argv, VALUE self)
+{
+    VALUE current_time_sec, current_time_usec;
+    GTimeVal current_time;
+
+    rb_scan_args(argc, argv, "02", &current_time_sec, &current_time_usec);
+
+    if (NIL_P(current_time_sec))
+        return CBOOL2RVAL(gdk_pixbuf_animation_iter_advance(_SELF(self), NULL));
+
+    current_time.tv_sec = NUM2LONG(current_time_sec);
+    current_time.tv_usec = NIL_P(current_time_usec) ? 0 : NUM2LONG(current_time_usec);
+
+    return CBOOL2RVAL(gdk_pixbuf_animation_iter_advance(_SELF(self), &current_time));
+}
+
+static VALUE
+rg_delay_time(VALUE self)
+{
+    return INT2NUM(gdk_pixbuf_animation_iter_get_delay_time(_SELF(self)));
+}
+
+static VALUE
+rg_on_currently_loading_frame_p(VALUE self)
+{
+    return CBOOL2RVAL(gdk_pixbuf_animation_iter_on_currently_loading_frame(_SELF(self)));
+}
+
+static VALUE
+rg_pixbuf(VALUE self)
+{
+    return GOBJ2RVAL(gdk_pixbuf_animation_iter_get_pixbuf(_SELF(self)));
+}
+
+void
+Init_gdk_pixbuf_animation_iter(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_PIXBUF_ANIMATION_ITER, "PixbufAnimationIter", mGdk);    
+
+    RG_DEF_METHOD(advance, -1);
+    RG_DEF_METHOD(delay_time, 0);
+    RG_DEF_METHOD_P(on_currently_loading_frame, 0);
+    RG_DEF_METHOD(pixbuf, 0);
+}

data/ext/gdk_pixbuf2/rbgdk-pixbufsimpleanim.c

@@ -0,0 +1,53 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 the ruby-gnome2 project
+ *
+ *  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,8,0)
+#define RG_TARGET_NAMESPACE cPixbufSimpleAnim
+#define _SELF(s) (RVAL2GDKPIXBUFSIMPLEANIM(s))
+
+static VALUE
+rg_initialize(VALUE self, VALUE width, VALUE height, VALUE rate)
+{
+    GdkPixbufSimpleAnim* ret = gdk_pixbuf_simple_anim_new(NUM2INT(width), NUM2INT(height), NUM2DBL(rate));
+    G_INITIALIZE(self, ret);
+    return Qnil;
+}
+
+static VALUE
+rg_add_frame(VALUE self, VALUE pixbuf)
+{
+    gdk_pixbuf_simple_anim_add_frame(_SELF(self), RVAL2GDKPIXBUF(pixbuf));
+    return self;
+}
+#endif
+
+void
+Init_gdk_pixbuf_simpleanim(VALUE mGdk)
+{
+#if RBGDK_PIXBUF_CHECK_VERSION(2,8,0)
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_PIXBUF_SIMPLE_ANIM, "PixbufSimpleAnim", mGdk);    
+
+    RG_DEF_METHOD(initialize, 3);
+    RG_DEF_METHOD(add_frame, 1);
+#endif
+}

data/ext/gdk_pixbuf2/rbgdk-pixdata.c

@@ -0,0 +1,213 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 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"
+
+#define GDK_TYPE_PIXDATA (gdk_pixdata_get_type())
+#define RG_TARGET_NAMESPACE cPixdata
+#define _SELF(s) (RVAL2GDKPIXDATA(s))
+
+static ID id_pixdata;
+
+/*****************************************/
+static GdkPixdata *
+gdk_pixdata_copy(const GdkPixdata* src)
+{
+  GdkPixdata* data;
+  g_return_val_if_fail (src != NULL, NULL);
+  data = g_new(GdkPixdata, 1);
+  *data = *src;
+  return data;
+}
+
+static GType
+gdk_pixdata_get_type(void)
+{
+  static GType our_type = 0;
+  if (our_type == 0)
+      our_type = g_boxed_type_register_static ("GdkPixdata",
+                                               (GBoxedCopyFunc)gdk_pixdata_copy,
+                                               (GBoxedFreeFunc)g_free);
+  return our_type;
+}
+/*****************************************/
+static VALUE
+rg_s_from_pixbuf(G_GNUC_UNUSED VALUE self, VALUE pixbuf, VALUE use_rle)
+{
+    GdkPixdata pixdata;
+    gpointer rle_data = gdk_pixdata_from_pixbuf(&pixdata, RVAL2GDKPIXBUF(pixbuf), RVAL2CBOOL(use_rle));
+    VALUE ret = GDKPIXDATA2RVAL(&pixdata);
+    if (use_rle){
+        /* need to manage the returned value */
+        rb_ivar_set(ret, id_pixdata, Data_Wrap_Struct(rb_cData, NULL, g_free, rle_data));
+    }
+    return ret;
+}
+
+static VALUE
+rg_to_pixbuf(VALUE self, VALUE copy_pixels)
+{
+    GError* error = NULL;
+    GdkPixbuf* ret = gdk_pixbuf_from_pixdata(_SELF(self), RVAL2CBOOL(copy_pixels), &error);
+    if (error)
+        RAISE_GERROR(error);
+    return GOBJ2RVAL(ret);
+}
+
+static VALUE
+rg_serialize(VALUE self)
+{
+    guint stream_length;
+    guint i;
+    guint8* ret = gdk_pixdata_serialize(_SELF(self), &stream_length);
+    VALUE ary = rb_ary_new2(stream_length);
+    for (i = 0; i < stream_length; i++) {
+        rb_ary_push(ary, UINT2NUM(ret[i]));
+    }
+    return ary;
+}
+
+static VALUE
+rg_s_deserialize(VALUE self, VALUE rbstream)
+{
+    GdkPixdata pixdata;
+    long n;
+    guint8 *stream = RVAL2GUINT8S(rbstream, n);
+    GError *error = NULL;
+
+    /* TODO: Should we really be creating a new array here?  As far as I can
+       tell, the data is copied. */
+    if (!gdk_pixdata_deserialize(&pixdata, n, stream, &error))
+        RAISE_GERROR(error);
+
+    /* need to manage the returned value */
+    rb_ivar_set(self, id_pixdata, Data_Wrap_Struct(rb_cData, NULL, g_free, stream));
+
+    return GDKPIXDATA2RVAL(&pixdata);
+}
+
+static VALUE
+rg_to_csource(VALUE self, VALUE name, VALUE dump_type)
+{
+    GString* str = gdk_pixdata_to_csource(_SELF(self), RVAL2CSTR(name), FIX2INT(dump_type));
+    VALUE ret = CSTR2RVAL(str->str);
+    g_string_free(str, TRUE);
+    return ret;
+}
+
+/* GdkPixdata */
+static VALUE
+rg_magic(VALUE self)
+{
+    return UINT2NUM(_SELF(self)->magic);
+}
+
+static VALUE
+rg_length(VALUE self)
+{
+    gint32 length = _SELF(self)->length;
+
+    if(length > 0)
+        length -= GDK_PIXDATA_HEADER_LENGTH;
+    return INT2NUM(length);
+}
+
+static VALUE
+rg_pixdata_type(VALUE self)
+{
+    return UINT2NUM(_SELF(self)->pixdata_type);
+}
+
+static VALUE
+rg_rowstride(VALUE self)
+{
+    return INT2NUM(_SELF(self)->rowstride);
+}
+
+static VALUE
+rg_width(VALUE self)
+{
+    return INT2NUM(_SELF(self)->width);
+}
+
+static VALUE
+rg_height(VALUE self)
+{
+    return INT2NUM(_SELF(self)->height);
+}
+
+static VALUE
+rg_pixel_data(VALUE self)
+{
+    gint i;
+    guint8* ret = _SELF(self)->pixel_data;
+    gint32 length = _SELF(self)->length - GDK_PIXDATA_HEADER_LENGTH;
+
+    VALUE ary = rb_ary_new2(length);
+    for (i = 0; i < length; i++) {
+        rb_ary_push(ary, UINT2NUM(ret[i]));
+    }
+    return ary;
+}
+
+void
+Init_gdk_pixdata(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_PIXDATA, "Pixdata", mGdk);    
+
+    id_pixdata = rb_intern("pixdata");
+
+    RG_DEF_SMETHOD(from_pixbuf, 2);
+    RG_DEF_SMETHOD(deserialize, 1);
+    RG_DEF_METHOD(to_pixbuf, 1);
+    RG_DEF_METHOD(serialize, 0);
+    RG_DEF_METHOD(to_csource, 2);
+    RG_DEF_METHOD(magic, 0);
+    RG_DEF_METHOD(length, 0);
+    RG_DEF_METHOD(pixdata_type, 0);
+    RG_DEF_METHOD(rowstride, 0);
+    RG_DEF_METHOD(width, 0);
+    RG_DEF_METHOD(height, 0);
+    RG_DEF_METHOD(pixel_data, 0);
+
+    rb_define_const(RG_TARGET_NAMESPACE, "PIXBUF_MAGIC_NUMBER", INT2NUM(GDK_PIXBUF_MAGIC_NUMBER));
+    rb_define_const(RG_TARGET_NAMESPACE, "HEADER_LENGTH", INT2NUM(GDK_PIXDATA_HEADER_LENGTH));
+
+    /* GdkPixdataType */
+    rb_define_const(RG_TARGET_NAMESPACE, "COLOR_TYPE_RGB", INT2FIX(GDK_PIXDATA_COLOR_TYPE_RGB));
+    rb_define_const(RG_TARGET_NAMESPACE, "COLOR_TYPE_RGBA", INT2FIX(GDK_PIXDATA_COLOR_TYPE_RGBA));
+    rb_define_const(RG_TARGET_NAMESPACE, "COLOR_TYPE_MASK", INT2FIX(GDK_PIXDATA_COLOR_TYPE_MASK));
+    rb_define_const(RG_TARGET_NAMESPACE, "SAMPLE_WIDTH_8", INT2FIX(GDK_PIXDATA_SAMPLE_WIDTH_8));
+    rb_define_const(RG_TARGET_NAMESPACE, "SAMPLE_WIDTH_MASK", INT2FIX(GDK_PIXDATA_SAMPLE_WIDTH_MASK));
+    rb_define_const(RG_TARGET_NAMESPACE, "ENCODING_RAW", INT2FIX(GDK_PIXDATA_ENCODING_RAW));
+    rb_define_const(RG_TARGET_NAMESPACE, "ENCODING_RLE", INT2FIX(GDK_PIXDATA_ENCODING_RLE));
+    rb_define_const(RG_TARGET_NAMESPACE, "ENCODING_MASK", INT2FIX(GDK_PIXDATA_ENCODING_MASK));
+
+    /* GdkPixdataDumpType */
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_PIXDATA_STREAM", INT2FIX(GDK_PIXDATA_DUMP_PIXDATA_STREAM));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_PIXDATA_STRUCT", INT2FIX(GDK_PIXDATA_DUMP_PIXDATA_STRUCT));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_MACROS", INT2FIX(GDK_PIXDATA_DUMP_MACROS));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_GTYPES", INT2FIX(GDK_PIXDATA_DUMP_GTYPES));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_CTYPES", INT2FIX(GDK_PIXDATA_DUMP_CTYPES));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_STATIC", INT2FIX(GDK_PIXDATA_DUMP_STATIC));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_CONST", INT2FIX(GDK_PIXDATA_DUMP_CONST));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_RLE_DECODER", INT2FIX(GDK_PIXDATA_DUMP_RLE_DECODER));
+}