gtk3 1.2.0-x86-mingw32

data/ext/gtk3/rbgtkinvisible.c

@@ -0,0 +1,49 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 OGASAWARA, Takeshi
+ *
+ *  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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cInvisible
+#define _SELF(s) RVAL2GTKINVISIBLE(s)
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE screen;
+
+    rb_scan_args(argc, argv, "01", &screen);
+
+    if (argc == 0){
+        RBGTK_INITIALIZE(self, gtk_invisible_new());
+    } else {
+        RBGTK_INITIALIZE(self, gtk_invisible_new_for_screen(
+                             RVAL2GDKSCREEN(screen)));
+    }
+    return Qnil;
+}
+
+void
+Init_gtk_invisible(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_INVISIBLE, "Invisible", mGtk);
+
+    RG_DEF_METHOD(initialize, -1);
+}

data/ext/gtk3/rbgtklabel.c

@@ -0,0 +1,139 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2005 Ruby-GNOME2 Project Team
+ *  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+ *                          Daisuke Kanda,
+ *                          Hiroshi Igarashi
+ *
+ *  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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cLabel
+#define _SELF(s) (RVAL2GTKLABEL(s))
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE label, with_mnemonic;
+    GtkWidget* widget = NULL;
+
+    rb_scan_args(argc, argv, "02", &label, &with_mnemonic);
+    if (NIL_P(with_mnemonic) || ! RVAL2CBOOL(with_mnemonic)){
+        widget = gtk_label_new(RVAL2CSTR_ACCEPT_NIL(label));
+    } else {
+        widget = gtk_label_new_with_mnemonic(RVAL2CSTR_ACCEPT_NIL(label));
+    }
+
+    RBGTK_INITIALIZE(self, widget);
+    return Qnil;
+}
+
+static VALUE
+rg_operator_label_set_text_only(VALUE self, VALUE text)
+{
+    gtk_label_set_text(_SELF(self), RVAL2CSTR(text));
+    return text;
+}
+
+static VALUE
+rg_set_text(int argc, VALUE *argv, VALUE self)
+{
+    VALUE label, with_mnemonic;
+
+    rb_scan_args(argc, argv, "02", &label, &with_mnemonic);
+    if (NIL_P(with_mnemonic) || ! RVAL2CBOOL(with_mnemonic)){
+        gtk_label_set_text(_SELF(self), RVAL2CSTR(label));
+    } else {
+        gtk_label_set_text_with_mnemonic(_SELF(self), RVAL2CSTR(label));
+    }
+    return self;
+}
+
+static VALUE
+rg_operator_label_set_markup_only(VALUE self, VALUE text)
+{
+    gtk_label_set_markup(_SELF(self), RVAL2CSTR(text));
+    return text;
+}
+
+static VALUE
+rg_set_markup(int argc, VALUE *argv, VALUE self)
+{
+    VALUE str, with_mnemonic;
+    rb_scan_args(argc, argv, "02", &str, &with_mnemonic);
+
+    if (NIL_P(with_mnemonic) || ! RVAL2CBOOL(with_mnemonic)){
+        gtk_label_set_markup(_SELF(self), RVAL2CSTR(str));
+    } else {
+        gtk_label_set_markup_with_mnemonic(_SELF(self), RVAL2CSTR(str));
+    }        
+    return self;
+}
+
+static VALUE
+rg_layout_offsets(VALUE self)
+{ 
+    gint x, y;
+    gtk_label_get_layout_offsets(_SELF(self), &x, &y);
+    return rb_ary_new3(2, INT2NUM(x), INT2NUM(y));
+}
+
+static VALUE
+rg_text(VALUE self)
+{
+    return CSTR2RVAL(gtk_label_get_text(_SELF(self)));
+}
+
+static VALUE
+rg_select_region(VALUE self, VALUE start_offset, VALUE end_offset)
+{
+    gtk_label_select_region(_SELF(self), NUM2INT(start_offset), NUM2INT(end_offset));
+    return self;
+}
+
+static VALUE
+rg_layout(VALUE self)
+{
+    return GOBJ2RVAL(gtk_label_get_layout(_SELF(self)));
+}
+
+static VALUE
+rg_selection_bounds(VALUE self)
+{
+    gint start, end;
+    gboolean ret = gtk_label_get_selection_bounds(_SELF(self), &start, &end);
+    return ret ? rb_ary_new3(2, INT2NUM(start), INT2NUM(end)) : Qnil;
+}
+
+void 
+Init_gtk_label(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_LABEL, "Label", mGtk);
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(text, 0);
+    RG_DEF_METHOD(set_text, -1);
+    RG_DEF_METHOD_OPERATOR("text=", label_set_text_only, 1);
+    RG_DEF_METHOD(set_markup, -1);
+    RG_DEF_METHOD_OPERATOR("markup=", label_set_markup_only, 1);
+    RG_DEF_METHOD(layout_offsets, 0);
+    RG_DEF_METHOD(select_region, 2);
+    RG_DEF_METHOD(layout, 0);
+    RG_DEF_METHOD(selection_bounds, 0);
+}

data/ext/gtk3/rbgtklayout.c

@@ -0,0 +1,93 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+ *  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+ *                          Daisuke Kanda,
+ *                          Hiroshi Igarashi
+ *
+ *  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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cLayout
+#define _SELF(self) (RVAL2GTKLAYOUT(self))
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE hadjustment, vadjustment;
+    GtkWidget* layout;
+    rb_scan_args(argc, argv, "02", &hadjustment, &vadjustment);
+
+    layout = gtk_layout_new(
+        NIL_P(hadjustment) ? 0 : RVAL2GTKADJUSTMENT(hadjustment),
+        NIL_P(vadjustment) ? 0 : RVAL2GTKADJUSTMENT(vadjustment));
+
+    RBGTK_INITIALIZE(self, layout);
+    return Qnil;
+}
+
+static VALUE
+rg_put(VALUE self, VALUE widget, VALUE x, VALUE y)
+{
+    gtk_layout_put(_SELF(self), RVAL2GTKWIDGET(widget),
+                   NUM2INT(x), NUM2INT(y));
+    return self;
+}
+
+static VALUE
+rg_move(VALUE self, VALUE widget, VALUE x, VALUE y)
+{
+    gtk_layout_move(_SELF(self), RVAL2GTKWIDGET(widget),
+                    NUM2INT(x), NUM2INT(y));
+    return self;
+}
+
+static VALUE
+rg_set_size(VALUE self, VALUE width, VALUE height)
+{
+    gtk_layout_set_size(_SELF(self), NUM2UINT(width), NUM2UINT(height));
+    return self;
+}
+
+static VALUE
+rg_size(VALUE self)
+{
+    guint width, height;
+    gtk_layout_get_size(_SELF(self), &width, &height);
+    return rb_ary_new3(2, INT2NUM(width), INT2NUM(height));
+}
+
+static VALUE
+rg_bin_window(VALUE self)
+{
+    return GOBJ2RVAL(gtk_layout_get_bin_window(_SELF(self)));
+}
+
+void
+Init_gtk_layout(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_LAYOUT, "Layout", mGtk);
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(put, 3);
+    RG_DEF_METHOD(move, 3);
+    RG_DEF_METHOD(set_size, 2);
+    RG_DEF_METHOD(size, 0);
+    RG_DEF_METHOD(bin_window, 0);
+}

data/ext/gtk3/rbgtklinkbutton.c

@@ -0,0 +1,55 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2006  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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cLinkButton
+#define _SELF(self) (RVAL2GTKLINKBUTTON(self))
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE uri, label;
+    GtkWidget *widget = NULL;
+
+    rb_scan_args(argc, argv, "11", &uri, &label);
+    if (NIL_P(label)){
+        widget = gtk_link_button_new(RVAL2CSTR(uri));
+    } else {
+        widget = gtk_link_button_new_with_label(RVAL2CSTR(uri), RVAL2CSTR(label));
+    }
+    RBGTK_INITIALIZE(self, widget); 
+    return Qnil;
+}
+
+static void
+link_func(GtkLinkButton *button, const gchar *link, gpointer func)
+{
+    rb_funcall((VALUE)func, id_call, 2, GOBJ2RVAL(button), CSTR2RVAL(link));
+}
+
+void 
+Init_gtk_link_button(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_LINK_BUTTON, "LinkButton", mGtk);
+
+    RG_DEF_METHOD(initialize, -1);
+}

data/ext/gtk3/rbgtkliststore.c

@@ -0,0 +1,408 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2005 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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cListStore
+#define _SELF(s) (RVAL2GTKLISTSTORE(s))
+
+static ID id_to_a, id_size;
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    gint cnt;
+    GtkListStore* store;
+    GType* buf;
+
+    if (argc == 0) rb_raise(rb_eArgError, "need more than 1 class type.");
+
+    buf = ALLOCA_N(GType, argc);
+    for (cnt = 0; cnt < argc; cnt++) {
+        buf[cnt] = CLASS2GTYPE(argv[cnt]);
+    }
+
+    store = gtk_list_store_newv(argc, buf);
+
+    G_INITIALIZE(self, store);
+
+    return Qnil;
+}
+
+static VALUE
+rg_set_column_types(int argc, VALUE *argv, VALUE self)
+{
+    gint cnt;
+    GType* buf;
+
+    if (argc == 0) rb_raise(rb_eArgError, "need more than 1 class type.");
+    buf = ALLOCA_N(GType, argc);
+    for (cnt = 0; cnt < argc; cnt++) {
+        buf[cnt] = CLASS2GTYPE(argv[cnt]);
+    }
+
+    gtk_list_store_set_column_types(_SELF(self), argc, buf);
+
+    return self;
+}
+
+static VALUE
+rg_set_value(VALUE self, VALUE iter, VALUE column, VALUE value)
+{
+    GType gtype = gtk_tree_model_get_column_type(RVAL2GTKTREEMODEL(self), NUM2INT(column));
+    GValue gval = G_VALUE_INIT;
+    g_value_init(&gval, gtype);
+
+    rbgobj_rvalue_to_gvalue(value, &gval);
+
+    G_CHILD_ADD(self, iter);
+    G_CHILD_ADD(iter, value);
+
+    gtk_list_store_set_value(_SELF(self), RVAL2GTKTREEITER(iter), NUM2INT(column), &gval);
+
+    g_value_unset(&gval);
+    return self;
+}
+
+typedef struct _ValuesInfo
+{
+    gint i;
+    VALUE iter;
+    GtkTreeModel *model;
+    gint *g_columns;
+    GValue *g_values;
+} ValuesInfo;
+
+static int
+collect_value(VALUE key, VALUE value, ValuesInfo *info)
+{
+    GType g_type;
+    gint column;
+
+    column = NUM2INT(key);
+    info->g_columns[info->i] = column;
+    g_type = gtk_tree_model_get_column_type(info->model, column);
+    g_value_init(&(info->g_values[info->i]), g_type);
+    rbgobj_rvalue_to_gvalue(value, &(info->g_values[info->i]));
+    G_CHILD_ADD(info->iter, value);
+    info->i++;
+
+    return ST_CONTINUE;
+}
+
+static void
+hash_to_values(VALUE hash, VALUE iter, GtkTreeModel *model,
+               gint *g_columns, GValue *g_values, G_GNUC_UNUSED gint length)
+{
+    ValuesInfo info;
+
+    info.i = 0;
+    info.iter = iter;
+    info.model = model;
+    info.g_columns = g_columns;
+    info.g_values = g_values;
+    rb_hash_foreach(hash, collect_value, (VALUE)(&info));
+}
+
+static void
+array_to_values(VALUE array, VALUE iter, GtkTreeModel *model,
+                gint *g_columns, GValue *g_values, gint length)
+{
+    gint i;
+
+    for (i = 0; i < length; i++) {
+        GType g_type;
+
+        g_columns[i] = i;
+        g_type = gtk_tree_model_get_column_type(model, i);
+        g_value_init(&g_values[i], g_type);
+        rbgobj_rvalue_to_gvalue(RARRAY_PTR(array)[i], &g_values[i]);
+        G_CHILD_ADD(iter, RARRAY_PTR(array)[i]);
+    }
+}
+
+static VALUE
+rg_set_values(VALUE self, VALUE iter, VALUE values)
+{
+    GValue *g_values;
+    GtkListStore *store;
+    GtkTreeModel *model;
+    gint *g_columns;
+    gint i, length;
+
+    length = NUM2INT(rb_funcall(values, id_size, 0));
+    if (length == 0)
+        return self;
+
+    g_columns = ALLOCA_N(gint, length);
+    g_values = ALLOCA_N(GValue, length);
+    MEMZERO(g_values, GValue, length);
+
+    G_CHILD_ADD(self, iter);
+
+    store = _SELF(self);
+    model = GTK_TREE_MODEL(store);
+    if (RVAL2CBOOL(rb_obj_is_kind_of(values, rb_cHash))) {
+        hash_to_values(values, iter, model, g_columns, g_values, length);
+    }
+    else if (RVAL2CBOOL(rb_obj_is_kind_of(values, rb_cArray))) {
+        array_to_values(values, iter, model, g_columns, g_values, length);
+    }
+    else {
+        rb_raise(rb_eArgError, "must be array or hash of values");
+    }
+
+    gtk_list_store_set_valuesv(store, RVAL2GTKTREEITER(iter),
+                               g_columns, g_values, length);
+
+    for (i = 0; i < length; i++)
+        g_value_unset(&g_values[i]);
+
+    return self;
+}
+
+static VALUE
+rg_remove(VALUE self, VALUE iter)
+{
+    G_CHILD_REMOVE(self, iter);
+    return CBOOL2RVAL(gtk_list_store_remove(_SELF(self), RVAL2GTKTREEITER(iter)));
+}
+
+struct lstore_insert_args {
+    GtkListStore *store;
+    GtkTreeIter iter;
+    gint position;
+    VALUE ary;
+    long i;
+    long n;
+    gint *columns;
+    GValue *values;
+};
+
+static VALUE
+lstore_insert_body(VALUE value)
+{
+    struct lstore_insert_args *args = (struct lstore_insert_args *)value;
+    GtkTreeModel *model = GTK_TREE_MODEL(args->store);
+
+    for (args->i = 0; args->i < args->n; args->i++) {
+        VALUE ary = rb_ary_to_ary(RARRAY_PTR(args->ary)[args->i]);
+
+        args->columns[args->i] = NUM2INT(RARRAY_PTR(ary)[1]);
+        g_value_init(&args->values[args->i],
+                     gtk_tree_model_get_column_type(model, args->columns[args->i]));
+        rbgobj_rvalue_to_gvalue(RARRAY_PTR(ary)[0], &args->values[args->i]);
+    }
+
+    gtk_list_store_insert_with_valuesv(args->store,
+                                       &args->iter,
+                                       args->position,
+                                       args->columns,
+                                       args->values,
+                                       args->n);
+
+    return Qnil;
+}
+
+static VALUE
+lstore_insert_ensure(VALUE value)
+{
+    long i;
+    struct lstore_insert_args *args = (struct lstore_insert_args *)value;
+
+    for (i = 0; i < args->i; i++)
+        g_value_unset(&args->values[i]);
+
+    g_free(args->values);
+    g_free(args->columns);
+
+    return Qnil;
+}
+
+/*
+  Gtk::ListStore#insert(pos, val1 => 0, val2 => 2, ... )
+ */
+static VALUE
+rg_insert(int argc, VALUE *argv, VALUE self)
+{
+    VALUE position, values, result;
+    struct lstore_insert_args args;
+    args.store = _SELF(self);
+
+    rb_scan_args(argc, argv, "11", &position, &values);
+    args.position = NUM2INT(position);
+
+    if (NIL_P(values)){
+        gtk_list_store_insert(args.store, &args.iter, args.position);
+    } else {
+        args.ary = rb_funcall(values, id_to_a, 0);
+        args.n = RARRAY_LEN(args.ary);
+        args.columns = g_new(gint, args.n);
+        args.values = g_new0(GValue, args.n);
+
+        rb_ensure(lstore_insert_body, (VALUE)&args,
+                  lstore_insert_ensure, (VALUE)&args);
+    }
+
+    args.iter.user_data3 = args.store;
+
+    result = GTKTREEITER2RVAL(&args.iter);
+
+    G_CHILD_ADD(self, result);
+
+    return result;
+}
+
+static VALUE
+rg_insert_before(VALUE self, VALUE sibling)
+{
+    VALUE ret;
+    GtkTreeIter iter;
+    GtkListStore* model = _SELF(self);
+    gtk_list_store_insert_before(model, &iter, NIL_P(sibling) ? NULL : RVAL2GTKTREEITER(sibling));
+    iter.user_data3 = model;
+
+    ret = GTKTREEITER2RVAL(&iter);
+    G_CHILD_ADD(self, ret);
+    return ret;
+}
+
+static VALUE
+rg_insert_after(VALUE self, VALUE sibling)
+{ 
+    VALUE ret;
+    GtkTreeIter iter;
+    GtkListStore* model = _SELF(self);
+    gtk_list_store_insert_after(model, &iter, NIL_P(sibling) ? NULL : RVAL2GTKTREEITER(sibling));
+    iter.user_data3 = model;
+
+    ret = GTKTREEITER2RVAL(&iter);
+    G_CHILD_ADD(self, ret);
+    return ret;
+}
+
+static VALUE
+rg_prepend(VALUE self)
+{
+    VALUE ret;
+    GtkTreeIter iter;
+    GtkListStore* model = _SELF(self);
+    gtk_list_store_prepend(model, &iter);
+    iter.user_data3 = model;
+
+    ret = GTKTREEITER2RVAL(&iter);
+    G_CHILD_ADD(self, ret);
+    return ret;
+}
+
+static VALUE
+rg_append(VALUE self)
+{
+    VALUE ret;
+    GtkTreeIter iter;
+    GtkListStore* model = _SELF(self);
+    gtk_list_store_append(model, &iter);
+    iter.user_data3 = model;
+
+    ret = GTKTREEITER2RVAL(&iter);
+    G_CHILD_ADD(self, ret);
+    return ret;
+}
+
+static VALUE
+rg_clear(VALUE self)
+{
+    G_CHILD_REMOVE_ALL(self);
+    gtk_list_store_clear(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_iter_is_valid_p(VALUE self, VALUE iter)
+{
+    return (NIL_P(iter)) ? Qfalse :
+        CBOOL2RVAL(gtk_list_store_iter_is_valid(_SELF(self), RVAL2GTKTREEITER(iter)));
+}
+
+static VALUE
+rg_reorder(VALUE self, VALUE rbnew_order)
+{
+    GtkListStore *store = _SELF(self);
+    long n;
+    gint *new_order = RVAL2GINTS(rbnew_order, n);
+
+    gtk_list_store_reorder(store, new_order);
+
+    g_free(new_order);
+
+    return self;
+}
+
+static VALUE
+rg_swap(VALUE self, VALUE iter1, VALUE iter2)
+{
+    gtk_list_store_swap(_SELF(self), RVAL2GTKTREEITER(iter1), RVAL2GTKTREEITER(iter2));
+    return self;
+}
+
+static VALUE
+rg_move_before(VALUE self, VALUE iter, VALUE position)
+{
+    gtk_list_store_move_before(_SELF(self), RVAL2GTKTREEITER(iter), 
+                               NIL_P(position) ? NULL : RVAL2GTKTREEITER(position));
+    return self;
+}
+
+static VALUE
+rg_move_after(VALUE self, VALUE iter, VALUE position)
+{
+    gtk_list_store_move_after(_SELF(self), RVAL2GTKTREEITER(iter), 
+                               NIL_P(position) ? NULL : RVAL2GTKTREEITER(position));
+    return self;
+}
+
+void
+Init_gtk_list_store(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_LIST_STORE, "ListStore", mGtk);
+
+    id_to_a = rb_intern("to_a");
+    id_size = rb_intern("size");
+
+    rbgtk_register_treeiter_set_value_func(GTK_TYPE_LIST_STORE, 
+                                           (rbgtkiter_set_value_func)&gtk_list_store_set_value);
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(set_column_types, -1);
+    RG_DEF_METHOD(set_value, 3);
+    RG_DEF_METHOD(remove, 1);
+    RG_DEF_METHOD(insert, -1);
+    RG_DEF_METHOD(insert_before, 1);
+    RG_DEF_METHOD(insert_after, 1);
+    RG_DEF_METHOD(prepend, 0);
+    RG_DEF_METHOD(append, 0);
+    RG_DEF_METHOD(clear, 0);
+    RG_DEF_METHOD_P(iter_is_valid, 1);
+    RG_DEF_METHOD(reorder, 1);
+    RG_DEF_METHOD(swap, 2);
+    RG_DEF_METHOD(move_before, 2);
+    RG_DEF_METHOD(move_after, 2);
+    RG_DEF_METHOD(set_values, 2);
+}