gtk2 0.20.0

data/src/rbgtklabel.c

@@ -0,0 +1,168 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtklabel.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+  Copyright (C) 2002-2005 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+#define _SELF(s) (GTK_LABEL(RVAL2GOBJ(s)))
+
+static VALUE
+label_initialize(argc, argv, self)
+    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(NIL_P(label)?NULL:RVAL2CSTR(label));
+    } else {
+        widget = gtk_label_new_with_mnemonic(NIL_P(label)?NULL:RVAL2CSTR(label));
+    }
+
+    RBGTK_INITIALIZE(self, widget);
+    return Qnil;
+}
+
+static VALUE
+label_set_text_only(self, text)
+    VALUE self, text;
+{
+    gtk_label_set_text(_SELF(self), RVAL2CSTR(text));
+    return text;
+}
+
+static VALUE
+label_set_text(argc, argv, self)
+    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
+label_set_markup_only(self, text)
+    VALUE self, text;
+{
+    gtk_label_set_markup(_SELF(self), RVAL2CSTR(text));
+    return text;
+}
+
+static VALUE
+label_set_markup(argc, argv, self)
+    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
+label_get_layout_offsets(self)
+    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
+label_get_text(self)
+    VALUE self;
+{
+    return CSTR2RVAL(gtk_label_get_text(_SELF(self)));
+}
+
+static VALUE
+label_select_region(self, start_offset, end_offset)
+    VALUE self, start_offset, end_offset;
+{
+    gtk_label_select_region(_SELF(self), NUM2INT(start_offset), NUM2INT(end_offset));
+    return self;
+}
+
+static VALUE
+label_get_layout(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gtk_label_get_layout(_SELF(self)));
+}
+
+static VALUE
+label_get_selection_bounds(self)
+    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;
+}
+
+/* Defined as Properties
+gdouble     gtk_label_get_angle             (GtkLabel *label);
+void        gtk_label_set_angle             (GtkLabel *label,
+                                             gdouble angle);
+void        gtk_label_set_ellipsize         (GtkLabel *label,
+                                             PangoEllipsizeMode mode);
+PangoEllipsizeMode gtk_label_get_ellipsize  (GtkLabel *label);
+void        gtk_label_set_max_width_chars   (GtkLabel *label,
+                                             gint n_chars);
+gint        gtk_label_get_max_width_chars   (GtkLabel *label);
+
+gboolean    gtk_label_get_single_line_mode  (GtkLabel *label);
+void        gtk_label_set_single_line_mode  (GtkLabel *label,
+                                             gboolean single_line_mode);
+void        gtk_label_set_width_chars       (GtkLabel *label,
+                                             gint n_chars);
+gint        gtk_label_get_width_chars       (GtkLabel *label);
+void        gtk_label_set_line_wrap_mode    (GtkLabel *label,
+                                             PangoWrapMode wrap_mode);
+PangoWrapMode gtk_label_get_line_wrap_mode  (GtkLabel *label);
+*/
+
+void 
+Init_gtk_label()
+{
+    VALUE gLabel = G_DEF_CLASS(GTK_TYPE_LABEL, "Label", mGtk);
+
+    rb_define_method(gLabel, "initialize", label_initialize, -1);
+    rb_define_method(gLabel, "text", label_get_text, 0);
+    rb_define_method(gLabel, "set_text", label_set_text, -1);
+    rb_define_method(gLabel, "text=", label_set_text_only, 1);
+    rb_define_method(gLabel, "set_markup", label_set_markup, -1);
+    rb_define_method(gLabel, "markup=", label_set_markup_only, 1);
+    rb_define_method(gLabel, "layout_offsets", label_get_layout_offsets, 0);
+    rb_define_method(gLabel, "select_region", label_select_region, 2);
+    rb_define_method(gLabel, "layout", label_get_layout, 0);
+    rb_define_method(gLabel, "selection_bounds", label_get_selection_bounds, 0);
+
+    G_DEF_SETTERS(gLabel);
+}

data/src/rbgtklayout.c

@@ -0,0 +1,91 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtklayout.c -
+
+  $Author: mutoh $
+  $Date: 2003/02/01 16:46:23 $
+
+  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+#define _SELF(self) (GTK_LAYOUT(RVAL2GOBJ(self)))
+#define RVAL2ADJ(a) (GTK_ADJUSTMENT(RVAL2GOBJ(a)))
+
+static VALUE
+layout_initialize(argc, argv, self)
+    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 : RVAL2ADJ(hadjustment),
+        NIL_P(vadjustment) ? 0 : RVAL2ADJ(vadjustment));
+    
+    RBGTK_INITIALIZE(self, layout);
+    return Qnil;
+}
+
+static VALUE
+layout_put(self, widget, x, y)
+    VALUE self, widget, x, y;
+{
+    gtk_layout_put(_SELF(self), GTK_WIDGET(RVAL2GOBJ(widget)),
+		   NUM2INT(x), NUM2INT(y));
+    return self;
+}
+
+static VALUE
+layout_move(self, widget, x,  y)
+    VALUE self, widget, x, y;
+{
+    gtk_layout_move(_SELF(self), GTK_WIDGET(RVAL2GOBJ(widget)),
+		    NUM2INT(x), NUM2INT(y));
+    return self;
+}
+
+static VALUE
+layout_set_size(self, width, height)
+    VALUE self, width, height;
+{
+    gtk_layout_set_size(_SELF(self), NUM2UINT(width), NUM2UINT(height));
+    return self;
+}
+
+static VALUE
+layout_get_size(self)
+    VALUE self;
+{
+    guint width, height;
+    gtk_layout_get_size(_SELF(self), &width, &height);
+    return rb_ary_new3(2, INT2NUM(width), INT2NUM(height));
+}
+
+static VALUE
+layout_get_bin_window(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(_SELF(self)->bin_window);
+}
+
+void
+Init_gtk_layout()
+{
+    VALUE gLayout = G_DEF_CLASS(GTK_TYPE_LAYOUT, "Layout", mGtk);
+
+    rb_define_method(gLayout, "initialize", layout_initialize, -1);
+    rb_define_method(gLayout, "put", layout_put, 3);
+    rb_define_method(gLayout, "move", layout_move, 3);
+    rb_define_method(gLayout, "set_size", layout_set_size, 2);
+    rb_define_method(gLayout, "size", layout_get_size, 0);
+    rb_define_method(gLayout, "bin_window", layout_get_bin_window, 0);
+}

data/src/rbgtklinkbutton.c

@@ -0,0 +1,68 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtklinkbutton.c -
+
+  $Author: sakai $
+  $Date: 2007/07/08 03:00:49 $
+
+  Copyright (C) 2006 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#if GTK_CHECK_VERSION(2,10,0)
+
+#define _SELF(self) (GTK_LINK_BUTTON(RVAL2GOBJ(self)))
+
+static VALUE
+lb_initialize(argc, argv, self)
+    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(button, link, func)
+    GtkLinkButton* button;
+    const gchar* link;
+    gpointer func;
+{
+    rb_funcall((VALUE)func, id_call, 2, GOBJ2RVAL(button), CSTR2RVAL(link));
+}
+
+static VALUE
+lb_set_uri_hook(self)
+    VALUE self;
+{
+    VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+    gtk_link_button_set_uri_hook((GtkLinkButtonUriFunc)link_func, (gpointer)func, (GDestroyNotify)NULL);
+    return self;
+}
+#endif 
+
+void 
+Init_gtk_link_button()
+{
+#if GTK_CHECK_VERSION(2,10,0)
+    VALUE button = G_DEF_CLASS(GTK_TYPE_LINK_BUTTON, "LinkButton", mGtk);
+
+    rb_define_method(button, "initialize", lb_initialize, -1);
+    rb_define_singleton_method(button, "set_uri_hook", lb_set_uri_hook, 0);
+
+    G_DEF_SETTERS(button);
+#endif
+}

data/src/rbgtkliststore.c

@@ -0,0 +1,412 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkliststore.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 14:27:09 $
+
+  Copyright (C) 2002-2005 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#define _SELF(s) (GTK_LIST_STORE(RVAL2GOBJ(s)))
+
+static ID id_to_a, id_size;
+
+static VALUE
+lstore_initialize(argc, argv, self)
+    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
+lstore_set_column_types(argc, argv, self)
+    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
+lstore_set_value(self, iter, column, value)
+    VALUE self, iter, column, value;
+{
+    GType gtype = gtk_tree_model_get_column_type(GTK_TREE_MODEL(RVAL2GOBJ(self)), NUM2INT(column));
+    GValue gval = {0,};
+    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;
+}
+
+#if GTK_CHECK_VERSION(2, 12, 0)
+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, 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
+lstore_set_valuesv(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;
+}
+#endif
+
+/*
+  void        gtk_tree_store_set (GtkTreeStore *tree_store,
+  GtkTreeIter *iter,
+  ...);
+
+  void        gtk_tree_store_set_valist       (GtkTreeStore *tree_store,
+  GtkTreeIter *iter,
+  va_list var_args);
+*/
+    
+static VALUE
+lstore_remove(self, iter)
+    VALUE self, iter;
+{
+    G_CHILD_REMOVE(self, iter);
+#if GTK_CHECK_VERSION(2,2,0)
+    return CBOOL2RVAL(gtk_list_store_remove(_SELF(self), RVAL2GTKTREEITER(iter)));
+#else
+    gtk_list_store_remove(_SELF(self), RVAL2GTKTREEITER(iter));
+    return Qtrue;
+#endif
+}
+
+/*
+  Gtk::ListStore#insert(pos, val1 => 0, val2 => 2, ... )
+ */
+static VALUE
+lstore_insert(argc, argv, self)
+    int argc;
+    VALUE* argv;
+    VALUE  self;
+{
+    VALUE position, values, ret;
+    GtkTreeIter iter;
+    GtkListStore* store = _SELF(self);
+
+    rb_scan_args(argc, argv, "11", &position, &values);
+
+    if (NIL_P(values)){
+        gtk_list_store_insert(store, &iter, NUM2INT(position));
+    } else {
+#if GTK_CHECK_VERSION(2,6,0)
+        gint cnt, n_values;
+        gint* columns;
+        GType gtype;
+        GValue* gvalues;
+        VALUE ary = rb_funcall(values, id_to_a, 0);
+
+        n_values = RARRAY_LEN(ary);
+        
+        gvalues = g_new(GValue, n_values);
+        columns = g_new(gint, n_values);
+        
+        for (cnt = 0; cnt < n_values; cnt++) {
+            Check_Type(RARRAY_PTR(ary)[cnt], T_ARRAY);
+            columns[cnt] = NUM2INT(RARRAY_PTR(RARRAY_PTR(ary)[cnt])[1]);
+            gtype = gtk_tree_model_get_column_type(GTK_TREE_MODEL(store), columns[cnt]);
+            gvalues[cnt].g_type = 0;
+            g_value_init(&gvalues[cnt], gtype);
+            rbgobj_rvalue_to_gvalue(RARRAY_PTR(RARRAY_PTR(ary)[cnt])[0], &gvalues[cnt]);
+        }
+        
+        gtk_list_store_insert_with_valuesv(store, &iter, NUM2INT(position),
+                                           columns, gvalues, n_values);
+        
+        for (cnt = 0; cnt < n_values; cnt++) {
+            g_value_unset(&gvalues[cnt]);
+        }
+        g_free(gvalues);
+        g_free(columns);
+#else
+        gtk_list_store_insert(store, &iter, NUM2INT(position));
+        rb_warn("Ignored 2nd argument under this environment. Because it has been supported since GTK+-2.6. ");
+#endif
+    }
+    iter.user_data3 = store;
+
+    ret = GTKTREEITER2RVAL(&iter);
+    G_CHILD_ADD(self, ret);
+    return ret;
+}
+
+static VALUE
+lstore_insert_before(self, sibling)
+    VALUE self, 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
+lstore_insert_after(self, sibling)
+    VALUE self, 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
+lstore_prepend(self)
+    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
+lstore_append(self)
+    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
+lstore_clear(self)
+    VALUE self;
+{
+    G_CHILD_REMOVE_ALL(self);
+    gtk_list_store_clear(_SELF(self));
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,2,0)
+static VALUE
+lstore_iter_is_valid(self, iter)
+    VALUE self, iter;
+{
+    return (NIL_P(iter)) ? Qfalse :
+        CBOOL2RVAL(gtk_list_store_iter_is_valid(_SELF(self), RVAL2GTKTREEITER(iter)));
+}
+
+static VALUE
+lstore_reorder(self, new_order)
+    VALUE self, new_order;
+{
+    gint i;
+    gint len = RARRAY_LEN(new_order);
+    gint* gnew_order = g_new(gint, len);
+
+    for (i = 0; i < len; i++){
+        gnew_order[i] = NUM2INT(RARRAY_PTR(new_order)[i]);
+    }
+
+    gtk_list_store_reorder(_SELF(self), gnew_order);
+    g_free(gnew_order);
+    return self;
+}
+static VALUE
+lstore_swap(self, iter1, iter2)
+    VALUE self, iter1, iter2;
+{
+    gtk_list_store_swap(_SELF(self), RVAL2GTKTREEITER(iter1), RVAL2GTKTREEITER(iter2));
+    return self;
+}
+static VALUE
+lstore_move_before(self, iter, position)
+    VALUE self, iter, position;
+{
+    gtk_list_store_move_before(_SELF(self), RVAL2GTKTREEITER(iter), 
+                               NIL_P(position) ? NULL : RVAL2GTKTREEITER(position));
+    return self;
+}
+static VALUE
+lstore_move_after(self, iter, position)
+    VALUE self, iter, position;
+{
+    gtk_list_store_move_after(_SELF(self), RVAL2GTKTREEITER(iter), 
+                               NIL_P(position) ? NULL : RVAL2GTKTREEITER(position));
+    return self;
+}
+#endif
+
+void
+Init_gtk_list_store()
+{
+    VALUE ls = 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);
+    rb_define_method(ls, "initialize", lstore_initialize, -1);
+    rb_define_method(ls, "set_column_types", lstore_set_column_types, -1);
+    rb_define_method(ls, "set_value", lstore_set_value, 3);
+    rb_define_method(ls, "remove", lstore_remove, 1);
+    rb_define_method(ls, "insert", lstore_insert, -1);
+    rb_define_method(ls, "insert_before", lstore_insert_before, 1);
+    rb_define_method(ls, "insert_after", lstore_insert_after, 1);
+    rb_define_method(ls, "prepend", lstore_prepend, 0);
+    rb_define_method(ls, "append", lstore_append, 0);
+    rb_define_method(ls, "clear", lstore_clear, 0);
+#if GTK_CHECK_VERSION(2,2,0)
+    rb_define_method(ls, "iter_is_valid?", lstore_iter_is_valid, 1);
+    rb_define_method(ls, "reorder", lstore_reorder, 1);
+    rb_define_method(ls, "swap", lstore_swap, 2);
+    rb_define_method(ls, "move_before", lstore_move_before, 2);
+    rb_define_method(ls, "move_after", lstore_move_after, 2);
+#endif
+#if GTK_CHECK_VERSION(2, 12, 0)
+    rb_define_method(ls, "set_values", lstore_set_valuesv, 2);
+#endif
+
+}