goocanvas 1.0.3-x86-mingw32 → 1.1.0-x86-mingw32

data/ext/goocanvas/rbgoocanvasconversions.h

@@ -0,0 +1,31 @@
+/* -*- 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 __RBGOOCANVASCONVERSIONS_H__
+#define __RBGOOCANVASCONVERSIONS_H__
+
+#define RVAL2GOOCANVAS(o)                  (GOO_CANVAS(RVAL2GOBJ(o)))
+#define RVAL2GOOCANVASITEM(o)              (GOO_CANVAS_ITEM(RVAL2GOBJ(o)))
+#define RVAL2GOOCANVASSTYLE(o)             (GOO_CANVAS_STYLE(RVAL2GOBJ(o)))
+
+#define RVAL2GOOCANVASPOINTS(o)            ((GooCanvasPoints*)RVAL2BOXED(o, GOO_TYPE_CANVAS_POINTS))
+#define GOOCANVASPOINTS2RVAL(o)            (BOXED2RVAL(o, GOO_TYPE_CANVAS_POINTS))
+
+#endif /* __RBGOOCANVASCONVERSIONS_H__ */

data/ext/goocanvas/rbgoocanvasellipse.c

@@ -1,32 +1,35 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/* $Id: rbgoocanvasellipse.c 3288 2008-09-13 10:07:44Z ktou $ */
-/* GooCanvasEllipse
- * Copyright (C) 2007 Vincent Isambart <vincent.isambart@gmail.com>
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2007  Vincent Isambart <vincent.isambart@gmail.com>
  *
- * 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 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.
+ *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *  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 "rbgoocanvas.h"
+#include "rbgoocanvasprivate.h"
+
+#define RG_TARGET_NAMESPACE cCanvasEllipse
 
 static VALUE
-rb_goo_canvas_ellipse_new(VALUE self, VALUE parent,
+rg_initialize(VALUE self, VALUE parent,
                           VALUE center_x, VALUE center_y,
                           VALUE radius_x, VALUE radius_y)
 {
     GooCanvasItem *item;
-    item = goo_canvas_ellipse_new(RVAL2GCI(parent),
+    item = goo_canvas_ellipse_new(RVAL2GOOCANVASITEM(parent),
                                   NUM2DBL(center_x),
                                   NUM2DBL(center_y),
                                   NUM2DBL(radius_x),
@@ -38,13 +41,12 @@ rb_goo_canvas_ellipse_new(VALUE self, VALUE parent,
 }
 
 void
-Init_goocanvasellipse(void)
+Init_goocanvasellipse(VALUE mGoo)
 {
-    VALUE GooCanvasEllipse;
+    VALUE RG_TARGET_NAMESPACE;
 
-    GooCanvasEllipse = G_DEF_CLASS(GOO_TYPE_CANVAS_ELLIPSE, "CanvasEllipse",
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GOO_TYPE_CANVAS_ELLIPSE, "CanvasEllipse",
                                    mGoo);
 
-    rb_define_method(GooCanvasEllipse, "initialize",
-                     rb_goo_canvas_ellipse_new, 5);
+    RG_DEF_METHOD(initialize, 5);
 }

data/ext/goocanvas/rbgoocanvasgroup.c

@@ -1,41 +1,44 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/* $Id: rbgoocanvasgroup.c 3288 2008-09-13 10:07:44Z ktou $ */
-/* GooCanvasGroup
- * Copyright (C) 2007 Vincent Isambart <vincent.isambart@gmail.com>
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2007  Vincent Isambart <vincent.isambart@gmail.com>
  *
- * 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 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.
+ *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *  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 "rbgoocanvas.h"
+#include "rbgoocanvasprivate.h"
+
+#define RG_TARGET_NAMESPACE cCanvasGroup
 
 static VALUE
-rb_goo_canvas_group_new(VALUE self, VALUE parent)
+rg_initialize(VALUE self, VALUE parent)
 {
     GooCanvasItem *item;
-    item = goo_canvas_group_new(RVAL2GCI(parent), NULL);
+    item = goo_canvas_group_new(RVAL2GOOCANVASITEM(parent), NULL);
     RB_GOO_CANVAS_ITEM_INITIALIZE(self, item);
     G_CHILD_ADD(parent, self);
     return Qnil;
 }
 
 void
-Init_goocanvasgroup(void)
+Init_goocanvasgroup(VALUE mGoo)
 {
-    VALUE GooCanvasGroup;
+    VALUE RG_TARGET_NAMESPACE;
 
-    GooCanvasGroup = G_DEF_CLASS(GOO_TYPE_CANVAS_GROUP, "CanvasGroup", mGoo);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GOO_TYPE_CANVAS_GROUP, "CanvasGroup", mGoo);
 
-    rb_define_method(GooCanvasGroup, "initialize", rb_goo_canvas_group_new, 1);
+    RG_DEF_METHOD(initialize, 1);
 }

data/ext/goocanvas/rbgoocanvasimage.c

@@ -1,32 +1,35 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/* $Id: rbgoocanvasimage.c 3288 2008-09-13 10:07:44Z ktou $ */
-/* GooCanvasImage
- * Copyright (C) 2007 Vincent Isambart <vincent.isambart@gmail.com>
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2007  Vincent Isambart <vincent.isambart@gmail.com>
  *
- * 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 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.
+ *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *  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 "rbgoocanvas.h"
+#include "rbgoocanvasprivate.h"
+
+#define RG_TARGET_NAMESPACE cCanvasImage
 
 static VALUE
-rb_goo_canvas_image_new(VALUE self, VALUE parent, VALUE pixbuf,
+rg_initialize(VALUE self, VALUE parent, VALUE pixbuf,
                         VALUE x, VALUE y)
 {
     GooCanvasItem *item;
-    item = goo_canvas_image_new(RVAL2GCI(parent),
-                                RVAL2GDK_PIXBUF(pixbuf),
+    item = goo_canvas_image_new(RVAL2GOOCANVASITEM(parent),
+                                RVAL2GDKPIXBUF(pixbuf),
                                 NUM2DBL(x),
                                 NUM2DBL(y),
                                 NULL);
@@ -36,10 +39,10 @@ rb_goo_canvas_image_new(VALUE self, VALUE parent, VALUE pixbuf,
 }
 
 void
-Init_goocanvasimage(void)
+Init_goocanvasimage(VALUE mGoo)
 {
-    VALUE GooCanvasImage;
+    VALUE RG_TARGET_NAMESPACE;
 
-    GooCanvasImage = G_DEF_CLASS(GOO_TYPE_CANVAS_IMAGE, "CanvasImage", mGoo);
-    rb_define_method(GooCanvasImage, "initialize", rb_goo_canvas_image_new, 4);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GOO_TYPE_CANVAS_IMAGE, "CanvasImage", mGoo);
+    RG_DEF_METHOD(initialize, 4);
 }

data/ext/goocanvas/rbgoocanvasitem.c

@@ -1,29 +1,31 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/* $Id: rbgoocanvasitem.c 3288 2008-09-13 10:07:44Z ktou $ */
-/* GooCanvasItem
- * Copyright (C) 2007 Vincent Isambart <vincent.isambart@gmail.com>
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2007  Vincent Isambart <vincent.isambart@gmail.com>
  *
- * 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 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.
+ *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *  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 "rbgoocanvas.h"
+#include "rbgoocanvasprivate.h"
 
-#define SELF(self) RVAL2GCI(self)
+#define RG_TARGET_NAMESPACE cCanvasItem
+#define SELF(self) RVAL2GOOCANVASITEM(self)
 
 static VALUE
-rb_goo_canvas_item_rotate(VALUE self, VALUE degrees, VALUE cx, VALUE cy)
+rg_rotate(VALUE self, VALUE degrees, VALUE cx, VALUE cy)
 {
     goo_canvas_item_rotate(SELF(self), NUM2DBL(degrees),
                            NUM2DBL(cx), NUM2DBL(cy));
@@ -31,35 +33,35 @@ rb_goo_canvas_item_rotate(VALUE self, VALUE degrees, VALUE cx, VALUE cy)
 }
 
 static VALUE
-rb_goo_canvas_item_translate(VALUE self, VALUE tx, VALUE ty)
+rg_translate(VALUE self, VALUE tx, VALUE ty)
 {
     goo_canvas_item_translate(SELF(self), NUM2DBL(tx), NUM2DBL(ty));
     return self;
 }
 
 static VALUE
-rb_goo_canvas_item_lower(VALUE self, VALUE below)
+rg_lower(VALUE self, VALUE below)
 {
     goo_canvas_item_lower(SELF(self), SELF(below));
     return self;
 }
 
 static VALUE
-rb_goo_canvas_item_raise(VALUE self, VALUE above)
+rg_raise(VALUE self, VALUE above)
 {
     goo_canvas_item_raise(SELF(self), SELF(above));
     return self;
 }
 
 static VALUE
-rb_goo_canvas_item_scale(VALUE self, VALUE sx, VALUE sy)
+rg_scale(VALUE self, VALUE sx, VALUE sy)
 {
     goo_canvas_item_scale(SELF(self), NUM2DBL(sx), NUM2DBL(sy));
     return self;
 }
 
 static VALUE
-rb_goo_canvas_bounds_x1(VALUE self)
+rg_x1(VALUE self)
 {
     GooCanvasBounds bounds;
     goo_canvas_item_get_bounds(SELF(self), &bounds);
@@ -67,7 +69,7 @@ rb_goo_canvas_bounds_x1(VALUE self)
 }
 
 static VALUE
-rb_goo_canvas_bounds_x2(VALUE self)
+rg_x2(VALUE self)
 {
     GooCanvasBounds bounds;
     goo_canvas_item_get_bounds(SELF(self), &bounds);
@@ -75,7 +77,7 @@ rb_goo_canvas_bounds_x2(VALUE self)
 }
 
 static VALUE
-rb_goo_canvas_bounds_y1(VALUE self)
+rg_y1(VALUE self)
 {
     GooCanvasBounds bounds;
     goo_canvas_item_get_bounds(SELF(self), &bounds);
@@ -83,7 +85,7 @@ rb_goo_canvas_bounds_y1(VALUE self)
 }
 
 static VALUE
-rb_goo_canvas_bounds_y2(VALUE self)
+rg_y2(VALUE self)
 {
     GooCanvasBounds bounds;
     goo_canvas_item_get_bounds(SELF(self), &bounds);
@@ -91,7 +93,7 @@ rb_goo_canvas_bounds_y2(VALUE self)
 }
 
 static VALUE
-rb_goo_canvas_item_skew_x(VALUE self, VALUE degrees, VALUE cx, VALUE cy)
+rg_skew_x(VALUE self, VALUE degrees, VALUE cx, VALUE cy)
 {
     goo_canvas_item_skew_x(SELF(self), NUM2DBL(degrees),
                            NUM2DBL(cx), NUM2DBL(cy));
@@ -99,7 +101,7 @@ rb_goo_canvas_item_skew_x(VALUE self, VALUE degrees, VALUE cx, VALUE cy)
 }
 
 static VALUE
-rb_goo_canvas_item_skew_y(VALUE self, VALUE degrees, VALUE cx, VALUE cy)
+rg_skew_y(VALUE self, VALUE degrees, VALUE cx, VALUE cy)
 {
     goo_canvas_item_skew_y(SELF(self), NUM2DBL(degrees),
                            NUM2DBL(cx), NUM2DBL(cy));
@@ -107,7 +109,7 @@ rb_goo_canvas_item_skew_y(VALUE self, VALUE degrees, VALUE cx, VALUE cy)
 }
 
 static VALUE
-rb_goo_canvas_item_set_simple_transform(VALUE self, VALUE x, VALUE y,
+rg_set_simple_transform(VALUE self, VALUE x, VALUE y,
                                         VALUE scale, VALUE rotation)
 {
     goo_canvas_item_set_simple_transform(SELF(self), NUM2DBL(x), NUM2DBL(y),
@@ -116,7 +118,7 @@ rb_goo_canvas_item_set_simple_transform(VALUE self, VALUE x, VALUE y,
 }
 
 static VALUE
-rb_goo_canvas_item_animate(VALUE self, VALUE x, VALUE y, VALUE scale,
+rg_animate(VALUE self, VALUE x, VALUE y, VALUE scale,
                            VALUE degrees, VALUE absolute, VALUE duration,
                            VALUE step_time, VALUE type)
 {
@@ -133,21 +135,21 @@ rb_goo_canvas_item_animate(VALUE self, VALUE x, VALUE y, VALUE scale,
 }
 
 static VALUE
-rb_goo_canvas_item_stop_animation(VALUE self)
+rg_stop_animation(VALUE self)
 {
     goo_canvas_item_stop_animation(SELF(self));
     return self;
 }
 
 static VALUE
-rb_goo_canvas_item_set_style(VALUE self, VALUE style)
+rg_set_style(VALUE self, VALUE style)
 {
-    goo_canvas_item_set_style(SELF(self), RVAL2GCS(style));
+    goo_canvas_item_set_style(SELF(self), RVAL2GOOCANVASSTYLE(style));
     return self;
 }
 
 static VALUE
-rb_goo_canvas_item_set_child_property(VALUE self, VALUE child,
+rg_set_child_property(VALUE self, VALUE child,
                                       VALUE prop_name, VALUE val)
 {
     GParamSpec* pspec;
@@ -204,13 +206,13 @@ rb_goo_canvas_item_set_child_property(VALUE self, VALUE child,
 }
 
 static VALUE
-rb_goo_canvas_item_get_canvas(VALUE self, VALUE tx, VALUE ty)
+rg_canvas(VALUE self, VALUE tx, VALUE ty)
 {
     return GOBJ2RVAL(goo_canvas_item_get_canvas(SELF(self)));
 }
 
 static VALUE
-rb_goo_canvas_item_remove_child(VALUE self, VALUE child)
+rg_remove_child(VALUE self, VALUE child)
 {
     gint child_num;
 
@@ -222,137 +224,44 @@ rb_goo_canvas_item_remove_child(VALUE self, VALUE child)
 }
 
 void
-Init_goocanvasitem(void)
+Init_goocanvasitem(VALUE mGoo)
 {
-    VALUE GooCanvasItem;
+    VALUE RG_TARGET_NAMESPACE;
 
-    GooCanvasItem = G_DEF_CLASS(GOO_TYPE_CANVAS_ITEM, "CanvasItem", mGoo);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GOO_TYPE_CANVAS_ITEM, "CanvasItem", mGoo);
 
-    rb_define_method(GooCanvasItem, "rotate", rb_goo_canvas_item_rotate, 3);
-    rb_define_method(GooCanvasItem, "translate", rb_goo_canvas_item_translate, 2);
-    rb_define_method(GooCanvasItem, "lower", rb_goo_canvas_item_lower, 1);
-    rb_define_method(GooCanvasItem, "raise", rb_goo_canvas_item_raise, 1);
-    rb_define_method(GooCanvasItem, "scale", rb_goo_canvas_item_scale, 2);
-    rb_define_method(GooCanvasItem, "skew_x", rb_goo_canvas_item_skew_x, 3);
-    rb_define_method(GooCanvasItem, "skew_y", rb_goo_canvas_item_skew_y, 3);
-    rb_define_method(GooCanvasItem, "set_simple_transform", rb_goo_canvas_item_set_simple_transform, 4);
-    rb_define_method(GooCanvasItem, "animate", rb_goo_canvas_item_animate, 8);
-    rb_define_method(GooCanvasItem, "stop_animation", rb_goo_canvas_item_stop_animation, 0);
+    RG_DEF_METHOD(rotate, 3);
+    RG_DEF_METHOD(translate, 2);
+    RG_DEF_METHOD(lower, 1);
+    RG_DEF_METHOD(raise, 1);
+    RG_DEF_METHOD(scale, 2);
+    RG_DEF_METHOD(skew_x, 3);
+    RG_DEF_METHOD(skew_y, 3);
+    RG_DEF_METHOD(set_simple_transform, 4);
+    RG_DEF_METHOD(animate, 8);
+    RG_DEF_METHOD(stop_animation, 0);
 
-    rb_define_method(GooCanvasItem, "set_style", rb_goo_canvas_item_set_style, 1);
+    RG_DEF_METHOD(set_style, 1);
 
-    rb_define_method(GooCanvasItem, "set_child_property", rb_goo_canvas_item_set_child_property, 3);
+    RG_DEF_METHOD(set_child_property, 3);
 
-    rb_define_method(GooCanvasItem, "canvas", rb_goo_canvas_item_get_canvas, 0);
+    RG_DEF_METHOD(canvas, 0);
 
-    rb_define_method(GooCanvasItem, "remove_child", rb_goo_canvas_item_remove_child, 1);
+    RG_DEF_METHOD(remove_child, 1);
 
-    rb_define_method(GooCanvasItem, "x1", rb_goo_canvas_bounds_x1, 0);
-    rb_define_method(GooCanvasItem, "x2", rb_goo_canvas_bounds_x2, 0);
-    rb_define_method(GooCanvasItem, "y1", rb_goo_canvas_bounds_y1, 0);
-    rb_define_method(GooCanvasItem, "y2", rb_goo_canvas_bounds_y2, 0);
+    RG_DEF_METHOD(x1, 0);
+    RG_DEF_METHOD(x2, 0);
+    RG_DEF_METHOD(y1, 0);
+    RG_DEF_METHOD(y2, 0);
 
     /* Enums */
-    G_DEF_CLASS(GOO_TYPE_CANVAS_ITEM_VISIBILITY, "Visibility", GooCanvasItem);
-    G_DEF_CONSTANTS(GooCanvasItem, GOO_TYPE_CANVAS_ITEM_VISIBILITY, "GOO_CANVAS_ITEM_");
-    G_DEF_CLASS(GOO_TYPE_CANVAS_ANIMATE_TYPE, "AnimateType", GooCanvasItem);
-    G_DEF_CONSTANTS(GooCanvasItem, GOO_TYPE_CANVAS_ANIMATE_TYPE, "GOO_CANVAS_");
-
-    
-    G_DEF_CLASS(GOO_TYPE_CANVAS_POINTER_EVENTS, "PointerEvents",GooCanvasItem);
-    G_DEF_CONSTANTS(GooCanvasItem, GOO_TYPE_CANVAS_POINTER_EVENTS,"GOO_CANVAS_");
-   
-#if 0
-   gint               goo_canvas_item_get_n_children (GooCanvasItem   *item);
-   GooCanvasItem*     goo_canvas_item_get_child      (GooCanvasItem   *item,
-                              gint             child_num);
-   gint               goo_canvas_item_find_child     (GooCanvasItem   *item,
-                              GooCanvasItem   *child);
-   void               goo_canvas_item_add_child      (GooCanvasItem   *item,
-                              GooCanvasItem   *child,
-                              gint             position);
-   void               goo_canvas_item_move_child     (GooCanvasItem   *item,
-                              gint             old_position,
-                              gint             new_position);
-   void               goo_canvas_item_remove_child   (GooCanvasItem   *item,
-                              gint             child_num);
-
-   void  goo_canvas_item_get_child_properties        (GooCanvasItem   *item,
-                              GooCanvasItem   *child,
-                              ...) G_GNUC_NULL_TERMINATED;
-   void  goo_canvas_item_set_child_properties        (GooCanvasItem   *item,
-                              GooCanvasItem   *child,
-                              ...) G_GNUC_NULL_TERMINATED;
-   void  goo_canvas_item_get_child_properties_valist (GooCanvasItem   *item,
-                              GooCanvasItem   *child,
-                              va_list        var_args);
-   void  goo_canvas_item_set_child_properties_valist (GooCanvasItem   *item,
-                              GooCanvasItem   *child,
-                              va_list        var_args);
-
-   gboolean goo_canvas_item_get_transform_for_child  (GooCanvasItem   *item,
-                              GooCanvasItem   *child,
-                              cairo_matrix_t  *transform);
-
-
-   /*
-    * Item functions - these are safe to call on all items.
-    */
-   GooCanvas*         goo_canvas_item_get_canvas     (GooCanvasItem   *item);
-   void               goo_canvas_item_set_canvas     (GooCanvasItem   *item,
-                              GooCanvas       *canvas);
-   GooCanvasItem*     goo_canvas_item_get_parent     (GooCanvasItem   *item);
-   void               goo_canvas_item_set_parent      (GooCanvasItem   *item,
-                              GooCanvasItem   *parent);
-   gboolean           goo_canvas_item_is_container   (GooCanvasItem   *item);
-
-   cairo_matrix_t*    goo_canvas_item_get_transform  (GooCanvasItem   *item);
-   void               goo_canvas_item_set_transform  (GooCanvasItem   *item,
-                              cairo_matrix_t  *matrix);
-   void               goo_canvas_item_set_simple_transform (GooCanvasItem   *item,
-                                gdouble          x,
-                                gdouble          y,
-                                gdouble          scale,
-                                gdouble          rotation);
-
-   GooCanvasStyle*    goo_canvas_item_get_style      (GooCanvasItem   *item);
-
-
-   void               goo_canvas_item_get_bounds      (GooCanvasItem   *item,
-                              GooCanvasBounds *bounds);
-   GooCanvasItem*       goo_canvas_item_get_item_at    (GooCanvasItem   *item,
-                              gdouble          x,
-                              gdouble          y,
-                              cairo_t         *cr,
-                              gboolean         is_pointer_event,
-                              gboolean         parent_is_visible);
-   gboolean           goo_canvas_item_is_visible     (GooCanvasItem   *item);
-
-   GooCanvasItemModel* goo_canvas_item_get_model      (GooCanvasItem      *item);
-   void                goo_canvas_item_set_model      (GooCanvasItem      *item,
-                              GooCanvasItemModel *model);
-
-   void               goo_canvas_item_request_update (GooCanvasItem   *item);
-   void           goo_canvas_item_ensure_updated (GooCanvasItem   *item);
-   void               goo_canvas_item_update         (GooCanvasItem   *item,
-                              gboolean         entire_tree,
-                              cairo_t         *cr,
-                              GooCanvasBounds *bounds);
-   void               goo_canvas_item_paint          (GooCanvasItem   *item,
-                              cairo_t         *cr,
-                              GooCanvasBounds *bounds,
-                              gdouble          scale);
-
-   gboolean       goo_canvas_item_get_requested_area (GooCanvasItem    *item,
-                                  cairo_t          *cr,
-                                  GooCanvasBounds  *requested_area);
-   void           goo_canvas_item_allocate_area      (GooCanvasItem    *item,
-                                  cairo_t          *cr,
-                                  GooCanvasBounds  *requested_area,
-                                  GooCanvasBounds  *allocated_area,
-                                  gdouble           x_offset,
-                                  gdouble           y_offset);
-#endif
-
-    G_DEF_SETTERS(GooCanvasItem);
+    G_DEF_CLASS(GOO_TYPE_CANVAS_ITEM_VISIBILITY, "Visibility", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GOO_TYPE_CANVAS_ITEM_VISIBILITY, "GOO_CANVAS_ITEM_");
+    G_DEF_CLASS(GOO_TYPE_CANVAS_ANIMATE_TYPE, "AnimateType", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GOO_TYPE_CANVAS_ANIMATE_TYPE, "GOO_CANVAS_");
+
+    G_DEF_CLASS(GOO_TYPE_CANVAS_POINTER_EVENTS, "PointerEvents",RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GOO_TYPE_CANVAS_POINTER_EVENTS,"GOO_CANVAS_");
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 }