gtk2 1.0.3-x86-mingw32 → 1.1.0-x86-mingw32

data/ext/gtk2/rbgtktreemodelfilter.c

@@ -1,24 +1,36 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgtktreemodelfilter.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:32 $
-
-  Copyright (C) 2004,2005 Masao Mutoh
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004,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 "global.h"
-                                                                                
+
 #if GTK_CHECK_VERSION(2,4,0)
+
+#define RG_TARGET_NAMESPACE cTreeModelFilter
 #define _SELF(s) (GTK_TREE_MODEL_FILTER(RVAL2GOBJ(s)))
 
 static ID id_child_model;
 static ID id_root;
 
 static VALUE
-treemodelfilter_initialize(int argc, VALUE *argv, VALUE self)
+rg_initialize(int argc, VALUE *argv, VALUE self)
 {
     VALUE child_model, root;
     GtkTreeModel* widget;
@@ -50,7 +62,7 @@ visible_func(GtkTreeModel *model, GtkTreeIter *iter, gpointer func)
 }
 
 static VALUE
-treemodelfilter_set_visible_func(VALUE self)
+rg_set_visible_func(VALUE self)
 {
     VALUE func = rb_block_proc();
     G_RELATIVE(self, func);
@@ -79,7 +91,7 @@ modify_func(GtkTreeModel *model, GtkTreeIter *iter, GValue *value, gint column,
  * end
  */
 static VALUE
-treemodelfilter_set_modify_func(int argc, VALUE *argv, VALUE self)
+rg_set_modify_func(int argc, VALUE *argv, VALUE self)
 {
     VALUE func = rb_block_proc();
     gint i;
@@ -102,20 +114,20 @@ treemodelfilter_set_modify_func(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-treemodelfilter_set_visible_column(VALUE self, VALUE column)
+rg_set_visible_column(VALUE self, VALUE column)
 {
     gtk_tree_model_filter_set_visible_column(_SELF(self), NUM2INT(column));
     return self;
 }
 
 static VALUE
-treemodelfilter_get_model(VALUE self)
+rg_model(VALUE self)
 {
     return GOBJ2RVAL(gtk_tree_model_filter_get_model(_SELF(self)));
 }
 
 static VALUE
-treemodelfilter_convert_child_iter_to_iter(VALUE self, VALUE child_iter)
+rg_convert_child_iter_to_iter(VALUE self, VALUE child_iter)
 {
     GtkTreeIter filter_iter;
     GtkTreeModelFilter* modelfilter = _SELF(self);
@@ -126,7 +138,7 @@ treemodelfilter_convert_child_iter_to_iter(VALUE self, VALUE child_iter)
 }
 
 static VALUE
-treemodelfilter_convert_iter_to_child_iter(VALUE self, VALUE filtered_iter)
+rg_convert_iter_to_child_iter(VALUE self, VALUE filtered_iter)
 {
     GtkTreeIter child_iter;
     GtkTreeModelFilter* modelfilter = _SELF(self);
@@ -137,14 +149,14 @@ treemodelfilter_convert_iter_to_child_iter(VALUE self, VALUE filtered_iter)
 } 
 
 static VALUE
-treemodelfilter_convert_child_path_to_path(VALUE self, VALUE child_path)
+rg_convert_child_path_to_path(VALUE self, VALUE child_path)
 {
     return GTKTREEPATH2RVAL(gtk_tree_model_filter_convert_child_path_to_path(
                              _SELF(self),
                              RVAL2GTKTREEPATH(child_path)));
 }
 static VALUE
-treemodelfilter_convert_path_to_child_path(VALUE self, VALUE filter_path)
+rg_convert_path_to_child_path(VALUE self, VALUE filter_path)
 {
     return GTKTREEPATH2RVAL(gtk_tree_model_filter_convert_path_to_child_path(
                              _SELF(self),
@@ -152,14 +164,14 @@ treemodelfilter_convert_path_to_child_path(VALUE self, VALUE filter_path)
 }
 
 static VALUE
-treemodelfilter_refilter(VALUE self)
+rg_refilter(VALUE self)
 {
     gtk_tree_model_filter_refilter(_SELF(self));
     return self;
 }
 
 static VALUE
-treemodelfilter_clear_cache(VALUE self)
+rg_clear_cache(VALUE self)
 {
     gtk_tree_model_filter_clear_cache(_SELF(self));
     return self;
@@ -167,25 +179,25 @@ treemodelfilter_clear_cache(VALUE self)
 #endif
 
 void 
-Init_gtk_treemodelfilter()
+Init_gtk_treemodelfilter(VALUE mGtk)
 {
 #if GTK_CHECK_VERSION(2,4,0)
-    VALUE tmf = G_DEF_CLASS(GTK_TYPE_TREE_MODEL_FILTER, "TreeModelFilter", mGtk);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TREE_MODEL_FILTER, "TreeModelFilter", mGtk);
 
     id_child_model = rb_intern("child_model");
     id_root = rb_intern("root");
 
-    rb_define_method(tmf, "initialize", treemodelfilter_initialize, -1);
-    rb_define_method(tmf, "set_visible_func", treemodelfilter_set_visible_func, 0);
-    rb_define_method(tmf, "set_modify_func", treemodelfilter_set_modify_func, -1);
-    rb_define_method(tmf, "set_visible_column", treemodelfilter_set_visible_column, 1);
-    rb_define_method(tmf, "model", treemodelfilter_get_model, 0);
-    rb_define_method(tmf, "convert_child_iter_to_iter", treemodelfilter_convert_child_iter_to_iter, 1);
-    rb_define_method(tmf, "convert_iter_to_child_iter", treemodelfilter_convert_iter_to_child_iter, 1);
-    rb_define_method(tmf, "convert_child_path_to_path", treemodelfilter_convert_child_path_to_path, 1);
-    rb_define_method(tmf, "convert_path_to_child_path", treemodelfilter_convert_path_to_child_path, 1);
-    rb_define_method(tmf, "refilter", treemodelfilter_refilter, 0);
-    rb_define_method(tmf, "clear_cache", treemodelfilter_clear_cache, 0);
-    G_DEF_SETTERS(tmf);
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(set_visible_func, 0);
+    RG_DEF_METHOD(set_modify_func, -1);
+    RG_DEF_METHOD(set_visible_column, 1);
+    RG_DEF_METHOD(model, 0);
+    RG_DEF_METHOD(convert_child_iter_to_iter, 1);
+    RG_DEF_METHOD(convert_iter_to_child_iter, 1);
+    RG_DEF_METHOD(convert_child_path_to_path, 1);
+    RG_DEF_METHOD(convert_path_to_child_path, 1);
+    RG_DEF_METHOD(refilter, 0);
+    RG_DEF_METHOD(clear_cache, 0);
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 #endif
 }

data/ext/gtk2/rbgtktreemodelsort.c

@@ -1,22 +1,33 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgtktreemodelsort.c -
-
-  $Author: mutoh $
-  $Date: 2005/11/06 04:44:24 $
-
-  Copyright (C) 2003-2005 Masao Mutoh
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003-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 "global.h"
 
+#define RG_TARGET_NAMESPACE cTreeModelSort
 #define _SELF(s) (GTK_TREE_MODEL_SORT(RVAL2GOBJ(s)))
 
 static ID id_model;
 
 static VALUE
-tmodelsort_initialize(VALUE self, VALUE model)
+rg_initialize(VALUE self, VALUE model)
 {
     G_CHILD_SET(self, id_model, model);
     G_INITIALIZE(self, 
@@ -25,7 +36,7 @@ tmodelsort_initialize(VALUE self, VALUE model)
 }
 
 static VALUE
-tmodelsort_convert_child_path_to_path(VALUE self, VALUE child_path)
+rg_convert_child_path_to_path(VALUE self, VALUE child_path)
 {
     return GTKTREEPATH2RVAL(gtk_tree_model_sort_convert_child_path_to_path(
                              _SELF(self),
@@ -33,7 +44,7 @@ tmodelsort_convert_child_path_to_path(VALUE self, VALUE child_path)
 }
 
 static VALUE
-tmodelsort_convert_child_iter_to_iter(VALUE self, VALUE child_iter)
+rg_convert_child_iter_to_iter(VALUE self, VALUE child_iter)
 {
     GtkTreeIter sort_iter;
     GtkTreeModelSort* modelsort = _SELF(self);
@@ -44,7 +55,7 @@ tmodelsort_convert_child_iter_to_iter(VALUE self, VALUE child_iter)
 }
 
 static VALUE
-tmodelsort_convert_path_to_child_path(VALUE self, VALUE sorted_path)
+rg_convert_path_to_child_path(VALUE self, VALUE sorted_path)
 {
     return GTKTREEPATH2RVAL(gtk_tree_model_sort_convert_path_to_child_path(
                              _SELF(self),
@@ -52,7 +63,7 @@ tmodelsort_convert_path_to_child_path(VALUE self, VALUE sorted_path)
 }
 
 static VALUE
-tmodelsort_convert_iter_to_child_iter(VALUE self, VALUE sorted_iter)
+rg_convert_iter_to_child_iter(VALUE self, VALUE sorted_iter)
 {
     GtkTreeIter child_iter;
     GtkTreeModelSort* modelsort = _SELF(self);
@@ -63,14 +74,14 @@ tmodelsort_convert_iter_to_child_iter(VALUE self, VALUE sorted_iter)
 } 
 
 static VALUE
-tmodelsort_reset_default_sort_func(VALUE self)
+rg_reset_default_sort_func(VALUE self)
 {
     gtk_tree_model_sort_reset_default_sort_func(_SELF(self));
     return self;
 }
 
 static VALUE
-tmodelsort_clear_cache(VALUE self)
+rg_clear_cache(VALUE self)
 {
     gtk_tree_model_sort_clear_cache(_SELF(self));
     return self;
@@ -78,28 +89,28 @@ tmodelsort_clear_cache(VALUE self)
 
 #if GTK_CHECK_VERSION(2,2,0)
 static VALUE
-tmodelsort_iter_is_valid(VALUE self, VALUE iter)
+rg_iter_is_valid_p(VALUE self, VALUE iter)
 {
     return CBOOL2RVAL(gtk_tree_model_sort_iter_is_valid(_SELF(self), RVAL2GTKTREEITER(iter)));
 }
 #endif
 
 void 
-Init_gtk_tmodelsort()
+Init_gtk_tmodelsort(VALUE mGtk)
 {
-    VALUE gTMSort = G_DEF_CLASS(GTK_TYPE_TREE_MODEL_SORT, "TreeModelSort", mGtk);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TREE_MODEL_SORT, "TreeModelSort", mGtk);
 
     id_model = rb_intern("model");
 
-    rb_define_method(gTMSort, "initialize", tmodelsort_initialize, 1);
-    rb_define_method(gTMSort, "convert_child_path_to_path", tmodelsort_convert_child_path_to_path, 1);
-    rb_define_method(gTMSort, "convert_child_iter_to_iter", tmodelsort_convert_child_iter_to_iter, 1);
-    rb_define_method(gTMSort, "convert_path_to_child_path", tmodelsort_convert_path_to_child_path, 1);
-    rb_define_method(gTMSort, "convert_iter_to_child_iter", tmodelsort_convert_iter_to_child_iter, 1);
-    rb_define_method(gTMSort, "reset_default_sort_func", tmodelsort_reset_default_sort_func, 0);
-    rb_define_method(gTMSort, "clear_cache", tmodelsort_clear_cache, 0);
+    RG_DEF_METHOD(initialize, 1);
+    RG_DEF_METHOD(convert_child_path_to_path, 1);
+    RG_DEF_METHOD(convert_child_iter_to_iter, 1);
+    RG_DEF_METHOD(convert_path_to_child_path, 1);
+    RG_DEF_METHOD(convert_iter_to_child_iter, 1);
+    RG_DEF_METHOD(reset_default_sort_func, 0);
+    RG_DEF_METHOD(clear_cache, 0);
 #if GTK_CHECK_VERSION(2,2,0)
-    rb_define_method(gTMSort, "iter_is_valid?", tmodelsort_iter_is_valid, 1);
+    RG_DEF_METHOD_P(iter_is_valid, 1);
 #endif
 
 }

data/ext/gtk2/rbgtktreepath.c

@@ -1,27 +1,38 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgtktreepath.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 14:27:10 $
-
-  Copyright (C) 2002-2004 Ruby-GNOME2 Project Team
-  Copyright (C) 2003,2004 Masao Mutoh
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2004 Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003,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 "global.h"
 
+#define RG_TARGET_NAMESPACE cTreePath
 #define _SELF(s) ((GtkTreePath*)RVAL2BOXED(s, GTK_TYPE_TREE_PATH))
 
 static ID id_equal;
 
 static VALUE
-treepath_initialize(int argc, VALUE *argv, VALUE self)
+rg_initialize(int argc, VALUE *argv, VALUE self)
 {
     VALUE path;
     GtkTreePath* widget;
-    
+
     if (argc == 1) {
         path = argv[0];
         if (TYPE(path) == T_STRING){
@@ -38,13 +49,13 @@ treepath_initialize(int argc, VALUE *argv, VALUE self)
         for (i = 0; i < argc; i++)
             gtk_tree_path_append_index(widget, NUM2INT(argv[i]));
     }
-    
+
     G_INITIALIZE(self, widget);
     return Qnil;
 }
 
 static VALUE
-treepath_to_string(VALUE self)
+rg_to_str(VALUE self)
 {
     gchar* s = gtk_tree_path_to_string(_SELF(self));
     VALUE result = CSTR2RVAL(s);
@@ -60,27 +71,27 @@ Deprecated
 */
 
 static VALUE
-treepath_append_index(VALUE self, VALUE index)
+rg_append_index(VALUE self, VALUE index)
 {
     gtk_tree_path_append_index(_SELF(self), NUM2INT(index));
     return self;
 }
 
 static VALUE
-treepath_prepend_index(VALUE self, VALUE index)
+rg_prepend_index(VALUE self, VALUE index)
 {
     gtk_tree_path_prepend_index(_SELF(self), NUM2INT(index));
     return self;
 }
 
 static VALUE
-treepath_get_depth(VALUE self)
+rg_depth(VALUE self)
 {
     return INT2NUM(gtk_tree_path_get_depth(_SELF(self)));
 }
 
 static VALUE
-treepath_get_indices(VALUE self)
+rg_indices(VALUE self)
 {
     VALUE ary;
     gint i, length;
@@ -94,7 +105,7 @@ treepath_get_indices(VALUE self)
         for (i = 0; i < length; i++) {
             rb_ary_push(ary, INT2NUM(indices[i]));
         }
-    
+
         return ary;
     } else {
         return Qnil;
@@ -102,13 +113,13 @@ treepath_get_indices(VALUE self)
 }
 
 static VALUE
-treepath_compare(VALUE self, VALUE other)
+rg_operator_treepath_compare(VALUE self, VALUE other)
 {
     return INT2NUM(gtk_tree_path_compare(_SELF(self), _SELF(other)));
 }
 
 static VALUE
-treepath_equal(VALUE self, VALUE other)
+rg_operator_treepath_equal(VALUE self, VALUE other)
 {
     if (!RVAL2CBOOL(rb_funcall(CLASS_OF(self), id_equal, 1, CLASS_OF(other)))) {
         return Qfalse;
@@ -118,63 +129,63 @@ treepath_equal(VALUE self, VALUE other)
 }
 
 static VALUE
-treepath_next(VALUE self)
+rg_next_bang(VALUE self)
 {
     gtk_tree_path_next(_SELF(self));
     return self;
 }
 
 static VALUE
-treepath_prev(VALUE self)
+rg_prev_bang(VALUE self)
 {
     return CBOOL2RVAL(gtk_tree_path_prev(_SELF(self)));
 }
 
 static VALUE
-treepath_up(VALUE self)
+rg_up_bang(VALUE self)
 {
     return CBOOL2RVAL(gtk_tree_path_up(_SELF(self)));
 }
 
 static VALUE
-treepath_down(VALUE self)
+rg_down_bang(VALUE self)
 {
     gtk_tree_path_down(_SELF(self));
     return Qtrue;
 }
 
 static VALUE
-treepath_is_ancestor(VALUE self, VALUE descendant)
+rg_ancestor_p(VALUE self, VALUE descendant)
 {
     return CBOOL2RVAL(gtk_tree_path_is_ancestor(_SELF(self), _SELF(descendant)));
 }
 
 static VALUE
-treepath_is_descendant(VALUE self, VALUE ancestor)
+rg_descendant_p(VALUE self, VALUE ancestor)
 {
     return CBOOL2RVAL(gtk_tree_path_is_descendant(_SELF(self), _SELF(ancestor)));
 }
 
 void 
-Init_gtk_treepath()
+Init_gtk_treepath(VALUE mGtk)
 {
-    VALUE gTreepath = G_DEF_CLASS(GTK_TYPE_TREE_PATH, "TreePath", mGtk);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TREE_PATH, "TreePath", mGtk);
 
     id_equal = rb_intern("==");
 
-    rb_define_method(gTreepath, "initialize", treepath_initialize, -1);
-    rb_define_method(gTreepath, "to_str", treepath_to_string, 0);
-    rb_define_alias(gTreepath, "to_s", "to_str");
-    rb_define_method(gTreepath, "append_index", treepath_append_index, 1);
-    rb_define_method(gTreepath, "prepend_index", treepath_prepend_index, 1);
-    rb_define_method(gTreepath, "depth", treepath_get_depth, 0);
-    rb_define_method(gTreepath, "indices", treepath_get_indices, 0);
-    rb_define_method(gTreepath, "<=>", treepath_compare, 1);
-    rb_define_method(gTreepath, "==", treepath_equal, 1);
-    rb_define_method(gTreepath, "next!", treepath_next, 0);
-    rb_define_method(gTreepath, "prev!", treepath_prev, 0);
-    rb_define_method(gTreepath, "up!", treepath_up, 0);
-    rb_define_method(gTreepath, "down!", treepath_down, 0);
-    rb_define_method(gTreepath, "ancestor?", treepath_is_ancestor, 1);
-    rb_define_method(gTreepath, "descendant?", treepath_is_descendant, 1);
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(to_str, 0);
+    RG_DEF_ALIAS("to_s", "to_str");
+    RG_DEF_METHOD(append_index, 1);
+    RG_DEF_METHOD(prepend_index, 1);
+    RG_DEF_METHOD(depth, 0);
+    RG_DEF_METHOD(indices, 0);
+    RG_DEF_METHOD_OPERATOR("<=>", treepath_compare, 1);
+    RG_DEF_METHOD_OPERATOR("==", treepath_equal, 1);
+    RG_DEF_METHOD_BANG(next, 0);
+    RG_DEF_METHOD_BANG(prev, 0);
+    RG_DEF_METHOD_BANG(up, 0);
+    RG_DEF_METHOD_BANG(down, 0);
+    RG_DEF_METHOD_P(ancestor, 1);
+    RG_DEF_METHOD_P(descendant, 1);
 }