gtk2 1.0.3 → 1.1.0

data/ext/gtk2/rbgtktreerowreference.c

@@ -1,13 +1,23 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgtktreerowreference.c -
-
-  $Author: mutoh $
-  $Date: 2006/10/21 16:58:00 $
-
-  Copyright (C) 2002-2006 Masao Mutoh
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-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 "global.h"
 
@@ -40,6 +50,7 @@ rbgtk_get_tree_row_reference(VALUE obj)
 
 /*****************************************/
 
+#define RG_TARGET_NAMESPACE cTreeRowReference
 #define _SELF(s) RVAL2TREEROWREFERENCE(s)
 
 /*****************************************/
@@ -49,11 +60,11 @@ static ID id_model;
 static ID id_path;
 
 static VALUE
-treerowref_initialize(int argc, VALUE *argv, VALUE self)
+rg_initialize(int argc, VALUE *argv, VALUE self)
 {
   VALUE proxy, model, path;
   GtkTreeRowReference* ref;
-    
+
   if (argc == 3){
     rb_scan_args(argc, argv, "3", &proxy, &model, &path);
     G_CHILD_SET(self, id_proxy, proxy);
@@ -70,14 +81,13 @@ treerowref_initialize(int argc, VALUE *argv, VALUE self)
 
   G_CHILD_SET(self, id_model, model);
   G_CHILD_SET(self, id_path, path);
-  
+
   G_INITIALIZE(self, ref);
   return Qnil;
 }
 
-
 static VALUE
-treerowref_get_path(VALUE self)
+rg_path(VALUE self)
 {
     VALUE ret = GTKTREEPATH2RVAL(gtk_tree_row_reference_get_path(_SELF(self)));
     G_CHILD_SET(self, id_path, ret);
@@ -86,7 +96,7 @@ treerowref_get_path(VALUE self)
 
 #if GTK_CHECK_VERSION(2,8,0)
 static VALUE
-treerowref_get_model(VALUE self)
+rg_model(VALUE self)
 {
     VALUE ret = GOBJ2RVAL(gtk_tree_row_reference_get_model(_SELF(self)));
     G_CHILD_SET(self, id_model, ret);
@@ -95,63 +105,71 @@ treerowref_get_model(VALUE self)
 #endif
 
 static VALUE
-treerowref_valid(VALUE self)
+rg_valid_p(VALUE self)
 {
     return CBOOL2RVAL(gtk_tree_row_reference_valid(_SELF(self)));
 }
 
 static VALUE
-treerowref_s_inserted(VALUE self, VALUE proxy, VALUE path)
+rg_s_inserted(VALUE self, VALUE proxy, VALUE path)
 {
     gtk_tree_row_reference_inserted(RVAL2GOBJ(proxy), RVAL2GTKTREEPATH(path));
     return self;
 }
 
 static VALUE
-treerowref_s_deleted(VALUE self, VALUE proxy, VALUE path)
+rg_s_deleted(VALUE self, VALUE proxy, VALUE path)
 {
     gtk_tree_row_reference_deleted(RVAL2GOBJ(proxy), RVAL2GTKTREEPATH(path));
     return self;
 }
 
 static VALUE
-treerowref_s_reordered(VALUE self, VALUE proxy, VALUE path, VALUE iter, VALUE new_orders)
+rg_s_reordered(VALUE self, VALUE rbproxy, VALUE rbpath, VALUE rbiter, VALUE rbnew_order)
 {
-    gint i, len;
-    gint* orders;
+    GObject *proxy = RVAL2GOBJ(rbproxy);
+    GtkTreePath *path = RVAL2GTKTREEPATH(rbpath);
+    GtkTreeIter *iter = RVAL2GTKTREEITER(rbiter);
+    /* TODO: How do we implement this check?
+    gint columns = gtk_tree_model_get_n_columns(proxy);
+    */
+    long n;
+    gint *new_order = RVAL2GINTS(rbnew_order, n);
+
+    /*
+    if (n != columns) {
+        g_free(new_order);
+
+        rb_raise(rb_eArgError,
+                 "new order array must contain same number of elements as the number of columns in the store: %ld != %d",
+                 n, columns);
+    }
+    */
 
-    Check_Type(new_orders, T_ARRAY);
+    gtk_tree_row_reference_reordered(proxy, path, iter, new_order);
 
-    len = RARRAY_LEN(new_orders);
-    orders = ALLOCA_N(gint, len);
+    g_free(new_order);
 
-    for (i = 0; i < len; i++) {
-        orders[i] = RARRAY_PTR(new_orders)[i];
-    }
-  
-    gtk_tree_row_reference_reordered(RVAL2GOBJ(proxy), RVAL2GTKTREEPATH(path), 
-                                     RVAL2GTKTREEITER(iter), orders);
     return self;
 }
 
 void 
-Init_gtk_treerowreference()
+Init_gtk_treerowreference(VALUE mGtk)
 {
-    VALUE gTreeref = G_DEF_CLASS(GTK_TYPE_TREE_ROW_REFERENCE, "TreeRowReference", mGtk);
-  
-    rb_define_method(gTreeref, "initialize", treerowref_initialize, -1);
-    rb_define_method(gTreeref, "path", treerowref_get_path, 0);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TREE_ROW_REFERENCE, "TreeRowReference", mGtk);
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(path, 0);
 #if GTK_CHECK_VERSION(2,8,0)
-    rb_define_method(gTreeref, "model", treerowref_get_model, 0);
+    RG_DEF_METHOD(model, 0);
 #endif
-    rb_define_method(gTreeref, "valid?", treerowref_valid, 0);
-    
-    rb_define_singleton_method(gTreeref, "inserted", treerowref_s_inserted, 2);
-    rb_define_singleton_method(gTreeref, "deleted", treerowref_s_deleted, 2);
-    rb_define_singleton_method(gTreeref, "reordered", treerowref_s_reordered, 4);
+    RG_DEF_METHOD_P(valid, 0);
+
+    RG_DEF_SMETHOD(inserted, 2);
+    RG_DEF_SMETHOD(deleted, 2);
+    RG_DEF_SMETHOD(reordered, 4);
 
     id_proxy = rb_intern("proxy");
     id_model = rb_intern("model");
     id_path = rb_intern("path");
 }
-

data/ext/gtk2/rbgtktreeselection.c

@@ -1,28 +1,39 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgtktreeselection.c -
-
-  $Author: ggc $ 
-  $Date: 2007/07/13 16:07:32 $
-
-  Copyright (C) 2002-2006 Masao Mutoh
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-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 "global.h"
 
+#define RG_TARGET_NAMESPACE cTreeSelection
 #define _SELF(s) (GTK_TREE_SELECTION(RVAL2GOBJ(s)))
 #define RVAL2TREEMODEL(s) (GTK_TREE_MODEL(RVAL2GOBJ(s)))
 
 static VALUE
-treeselection_set_mode(VALUE self, VALUE type)
+rg_set_mode(VALUE self, VALUE type)
 {
     gtk_tree_selection_set_mode(_SELF(self), RVAL2GENUM(type, GTK_TYPE_SELECTION_MODE));
     return self;
 }
 
 static VALUE
-treeselection_get_mode(VALUE self)
+rg_mode(VALUE self)
 {
     return GENUM2RVAL(gtk_tree_selection_get_mode(_SELF(self)), GTK_TYPE_SELECTION_MODE);
 }
@@ -38,7 +49,7 @@ selection_func(GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *pa
 }
 
 static VALUE
-treeselection_set_select_function(VALUE self)
+rg_set_select_function(VALUE self)
 {
     volatile VALUE func = rb_block_proc();
     G_RELATIVE(self, func);
@@ -54,13 +65,13 @@ gpointer    gtk_tree_selection_get_user_data
 */
 
 static VALUE
-treeselection_get_tree_view(VALUE self)
+rg_tree_view(VALUE self)
 {
     return GOBJ2RVAL(gtk_tree_selection_get_tree_view(_SELF(self)));
 }
 
 static VALUE
-treeselection_get_selected(VALUE self)
+rg_selected(VALUE self)
 {
     GtkTreeIter iter;
     GtkTreeModel* model;
@@ -78,7 +89,7 @@ foreach_func(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer
 }
 
 static VALUE
-treeselection_selected_foreach(VALUE self)
+rg_selected_each(VALUE self)
 {
     volatile VALUE func = rb_block_proc();
     gtk_tree_selection_selected_foreach(_SELF(self), 
@@ -88,61 +99,61 @@ treeselection_selected_foreach(VALUE self)
 }
 
 static VALUE
-treeselection_select_path(VALUE self, VALUE path)
+rg_select_path(VALUE self, VALUE path)
 {
     gtk_tree_selection_select_path(_SELF(self), RVAL2GTKTREEPATH(path));
     return self;
 }
 
 static VALUE
-treeselection_unselect_path(VALUE self, VALUE path)
+rg_unselect_path(VALUE self, VALUE path)
 {
     gtk_tree_selection_unselect_path(_SELF(self), RVAL2GTKTREEPATH(path));
     return self;
 }
 
 static VALUE
-treeselection_path_is_selected(VALUE self, VALUE path)
+rg_path_is_selected_p(VALUE self, VALUE path)
 {
     return CBOOL2RVAL(gtk_tree_selection_path_is_selected(_SELF(self), RVAL2GTKTREEPATH(path)));
 }
 
 static VALUE
-treeselection_select_iter(VALUE self, VALUE iter)
+rg_select_iter(VALUE self, VALUE iter)
 {
     gtk_tree_selection_select_iter(_SELF(self), RVAL2GTKTREEITER(iter));
     return self;
 }
 
 static VALUE
-treeselection_unselect_iter(VALUE self, VALUE iter)
+rg_unselect_iter(VALUE self, VALUE iter)
 {
     gtk_tree_selection_unselect_iter(_SELF(self), RVAL2GTKTREEITER(iter));
     return self;
 }
 
 static VALUE
-treeselection_iter_is_selected(VALUE self, VALUE iter)
+rg_iter_is_selected_p(VALUE self, VALUE iter)
 {
     return CBOOL2RVAL(gtk_tree_selection_iter_is_selected(_SELF(self), RVAL2GTKTREEITER(iter)));
 }
 
 static VALUE
-treeselection_select_all(VALUE self)
+rg_select_all(VALUE self)
 {
     gtk_tree_selection_select_all(_SELF(self));
     return self;
 }
 
 static VALUE
-treeselection_unselect_all(VALUE self)
+rg_unselect_all(VALUE self)
 {
     gtk_tree_selection_unselect_all(_SELF(self));
     return self;
 }
 
 static VALUE
-treeselection_select_range(VALUE self, VALUE start_path, VALUE end_path)
+rg_select_range(VALUE self, VALUE start_path, VALUE end_path)
 {
     gtk_tree_selection_select_range(_SELF(self), RVAL2GTKTREEPATH(start_path), 
                                     RVAL2GTKTREEPATH(end_path));
@@ -151,7 +162,7 @@ treeselection_select_range(VALUE self, VALUE start_path, VALUE end_path)
 
 #if GTK_CHECK_VERSION(2,2,0)
 static VALUE
-treeselection_get_selected_rows(VALUE self)
+rg_selected_rows(VALUE self)
 {
     GtkTreeModel* model;
     GList* list = gtk_tree_selection_get_selected_rows(_SELF(self), &model);
@@ -162,13 +173,13 @@ treeselection_get_selected_rows(VALUE self)
 }
 
 static VALUE
-treeselection_count_selected_rows(VALUE self)
+rg_count_selected_rows(VALUE self)
 {
     return INT2NUM(gtk_tree_selection_count_selected_rows(_SELF(self)));
 }
 
 static VALUE
-treeselection_unselect_range(VALUE self, VALUE start_path, VALUE end_path)
+rg_unselect_range(VALUE self, VALUE start_path, VALUE end_path)
 {
     gtk_tree_selection_unselect_range(_SELF(self), RVAL2GTKTREEPATH(start_path), 
                                       RVAL2GTKTREEPATH(end_path));
@@ -177,32 +188,30 @@ treeselection_unselect_range(VALUE self, VALUE start_path, VALUE end_path)
 #endif
 
 void
-Init_gtk_treeselection()
-{
-    VALUE gTs = G_DEF_CLASS(GTK_TYPE_TREE_SELECTION, "TreeSelection", mGtk); 
-    
-    rb_define_method(gTs, "set_mode", treeselection_set_mode, 1);
-    rb_define_method(gTs, "mode", treeselection_get_mode, 0);
-    rb_define_method(gTs, "set_select_function", treeselection_set_select_function, 0);
-    rb_define_method(gTs, "tree_view", treeselection_get_tree_view, 0);
-    rb_define_method(gTs, "selected", treeselection_get_selected, 0);
-    rb_define_method(gTs, "selected_each", treeselection_selected_foreach, 0);
-    rb_define_method(gTs, "select_path", treeselection_select_path, 1);
-    rb_define_method(gTs, "unselect_path", treeselection_unselect_path, 1);
-    rb_define_method(gTs, "path_is_selected?", treeselection_path_is_selected, 1);
-    rb_define_method(gTs, "select_iter", treeselection_select_iter, 1);
-    rb_define_method(gTs, "unselect_iter", treeselection_unselect_iter, 1);
-    rb_define_method(gTs, "iter_is_selected?", treeselection_iter_is_selected, 1);
-    rb_define_method(gTs, "select_all", treeselection_select_all, 0);
-    rb_define_method(gTs, "unselect_all", treeselection_unselect_all, 0);
-    rb_define_method(gTs, "select_range", treeselection_select_range, 2);
+Init_gtk_treeselection(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TREE_SELECTION, "TreeSelection", mGtk); 
+
+    RG_DEF_METHOD(set_mode, 1);
+    RG_DEF_METHOD(mode, 0);
+    RG_DEF_METHOD(set_select_function, 0);
+    RG_DEF_METHOD(tree_view, 0);
+    RG_DEF_METHOD(selected, 0);
+    RG_DEF_METHOD(selected_each, 0);
+    RG_DEF_METHOD(select_path, 1);
+    RG_DEF_METHOD(unselect_path, 1);
+    RG_DEF_METHOD_P(path_is_selected, 1);
+    RG_DEF_METHOD(select_iter, 1);
+    RG_DEF_METHOD(unselect_iter, 1);
+    RG_DEF_METHOD_P(iter_is_selected, 1);
+    RG_DEF_METHOD(select_all, 0);
+    RG_DEF_METHOD(unselect_all, 0);
+    RG_DEF_METHOD(select_range, 2);
 #if GTK_CHECK_VERSION(2,2,0)
-    rb_define_method(gTs, "selected_rows", treeselection_get_selected_rows, 0);
-    rb_define_method(gTs, "count_selected_rows", treeselection_count_selected_rows, 0);
-    rb_define_method(gTs, "unselect_range", treeselection_unselect_range, 2);
+    RG_DEF_METHOD(selected_rows, 0);
+    RG_DEF_METHOD(count_selected_rows, 0);
+    RG_DEF_METHOD(unselect_range, 2);
 #endif
 
-    G_DEF_SETTERS(gTs);
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 }
-
-

data/ext/gtk2/rbgtktreesortable.c

@@ -1,60 +1,70 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgtktreesortable.c -
-
-  $Author: ggc $
-
-  $Date: 2007/07/13 16:07:32 $
-
-  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
 
 #include "global.h"
 
-#define _SELF(s)	(GTK_TREE_SORTABLE(RVAL2GOBJ(s)))
+#define RG_TARGET_NAMESPACE mTreeSortable
+#define _SELF(s)    (GTK_TREE_SORTABLE(RVAL2GOBJ(s)))
 
 static VALUE
-treesortable_sort_column_changed(VALUE self)
+rg_sort_column_changed(VALUE self)
 {
     gtk_tree_sortable_sort_column_changed(_SELF(self));
     return self;
 }
 
 static VALUE
-treesortable_get_sort_column_id(VALUE self)
+rg_sort_column_id(VALUE self)
 {
     gint sort_column_id;
     GtkSortType order;
 
     if (gtk_tree_sortable_get_sort_column_id(_SELF(self), &sort_column_id,
-					     &order)) {
-	VALUE ary;
+                                             &order)) {
+        VALUE ary;
 
-	ary = rb_ary_new2(2);
-	rb_ary_push(ary, INT2NUM(sort_column_id));
-	rb_ary_push(ary, GENUM2RVAL(order, GTK_TYPE_SORT_TYPE));
-	return ary;
+        ary = rb_ary_new2(2);
+        rb_ary_push(ary, INT2NUM(sort_column_id));
+        rb_ary_push(ary, GENUM2RVAL(order, GTK_TYPE_SORT_TYPE));
+        return ary;
     } else {
-	return Qnil;	/* XXX: or something else? exception? */
+        return Qnil;   /* XXX: or something else? exception? */
     }
 }
 
 static VALUE
-treesortable_set_sort_column_id(int argc, VALUE *argv, VALUE self)
+rg_set_sort_column_id(int argc, VALUE *argv, VALUE self)
 {
     gint sort_column_id;
     GtkSortType order;
 
     if (argc == 1 || argc == 2) {
-	sort_column_id = NUM2INT(argv[0]);
-	order = (argc == 2) ? RVAL2GENUM(argv[1], GTK_TYPE_SORT_TYPE) : GTK_SORT_ASCENDING;
+        sort_column_id = NUM2INT(argv[0]);
+        order = (argc == 2) ? RVAL2GENUM(argv[1], GTK_TYPE_SORT_TYPE) : GTK_SORT_ASCENDING;
     } else {
-	rb_raise(rb_eArgError, "need 1 or 2 arguments.");
+        rb_raise(rb_eArgError, "need 1 or 2 arguments.");
     }
 
     gtk_tree_sortable_set_sort_column_id(_SELF(self), sort_column_id,
-					 order);
+                                         order);
     return self;
 }
 
@@ -64,50 +74,50 @@ sort_func(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer func)
     a->user_data3 = model;
     b->user_data3 = model;
     return NUM2INT(rb_funcall((VALUE)func, id_call, 2, GTKTREEITER2RVAL(a),
-			      GTKTREEITER2RVAL(b)));
+                              GTKTREEITER2RVAL(b)));
 }
 
 static VALUE
-treesortable_set_sort_func(VALUE self, VALUE sort_column_id)
+rg_set_sort_func(VALUE self, VALUE sort_column_id)
 {
     volatile VALUE func = rb_block_proc();
     G_RELATIVE(self, func);
     gtk_tree_sortable_set_sort_func(_SELF(self), NUM2INT(sort_column_id),
-				    (GtkTreeIterCompareFunc)sort_func,
-				    (gpointer)func, NULL);
+                                    (GtkTreeIterCompareFunc)sort_func,
+                                    (gpointer)func, NULL);
     return self;
 }
 
 static VALUE
-treesortable_set_default_sort_func(VALUE self)
+rg_set_default_sort_func(VALUE self)
 {
     volatile VALUE func = rb_block_proc();
     G_RELATIVE(self, func);
     gtk_tree_sortable_set_default_sort_func(_SELF(self),
-					    (GtkTreeIterCompareFunc)sort_func,
-					    (gpointer)func, NULL);
+                                            (GtkTreeIterCompareFunc)sort_func,
+                                            (gpointer)func, NULL);
     return self;
 }
 
 static VALUE
-treesortable_has_default_sort_func(VALUE self)
+rg_has_default_sort_func_p(VALUE self)
 {
     return RVAL2CBOOL(gtk_tree_sortable_has_default_sort_func(_SELF(self)));
 }
 
 void
-Init_gtk_treesortable()
+Init_gtk_treesortable(VALUE mGtk)
 {
-    VALUE mts = G_DEF_INTERFACE(GTK_TYPE_TREE_SORTABLE, "TreeSortable", mGtk);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(GTK_TYPE_TREE_SORTABLE, "TreeSortable", mGtk);
 
-    rb_define_method(mts, "sort_column_changed", treesortable_sort_column_changed, 0);
-    rb_define_method(mts, "sort_column_id", treesortable_get_sort_column_id, 0);
-    rb_define_method(mts, "set_sort_column_id", treesortable_set_sort_column_id, -1);
-    rb_define_method(mts, "set_sort_func", treesortable_set_sort_func, 1);
-    rb_define_method(mts, "set_default_sort_func", treesortable_set_default_sort_func, 0);
-    rb_define_method(mts, "has_default_sort_func?", treesortable_has_default_sort_func, 0);
+    RG_DEF_METHOD(sort_column_changed, 0);
+    RG_DEF_METHOD(sort_column_id, 0);
+    RG_DEF_METHOD(set_sort_column_id, -1);
+    RG_DEF_METHOD(set_sort_func, 1);
+    RG_DEF_METHOD(set_default_sort_func, 0);
+    RG_DEF_METHOD_P(has_default_sort_func, 0);
 
-    rb_define_const(mts, "DEFAULT_SORT_COLUMN_ID", GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID);
+    rb_define_const(RG_TARGET_NAMESPACE, "DEFAULT_SORT_COLUMN_ID", GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID);
 }
 
 /* vim: set sts=4 sw=4 ts=8: */