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

data/ext/goocanvas/rbgoo.c

@@ -0,0 +1,41 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  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 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 "rbgoocanvasprivate.h"
+
+#define RG_TARGET_NAMESPACE mGoo
+
+VALUE RG_TARGET_NAMESPACE;
+
+void
+Init_goo(void)
+{
+    RG_TARGET_NAMESPACE = rb_define_module("Goo");
+
+    G_DEF_CLASS(GOO_TYPE_CAIRO_MATRIX, "CairoMatrix", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_PATTERN, "CairoPattern", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_FILL_RULE, "CairoFillRule", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_OPERATOR, "CairoOperator", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_ANTIALIAS, "CairoAntiAlias", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_LINE_CAP, "CairoLineCap", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_LINE_JOIN, "CairoLineJoin", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_HINT_METRICS, "CairoHintMetrics", RG_TARGET_NAMESPACE);
+}

data/ext/goocanvas/rbgoocairomatrix.c

@@ -0,0 +1,47 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  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 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 "rbgoocanvasprivate.h"
+
+#define RG_TARGET_NAMESPACE cMatrix
+
+static VALUE
+rg_to_goo(VALUE self)
+{
+    GValue gval = {0,};
+    VALUE result;
+
+    g_value_init(&gval, GOO_TYPE_CAIRO_MATRIX);
+    g_value_set_boxed(&gval, RVAL2CRMATRIX(self));
+
+    result = rbgobj_gvalue_to_rvalue(&gval);
+    g_value_unset(&gval);
+
+    return result;
+}
+
+void
+Init_goocairomatrix(VALUE mCairo)
+{
+    VALUE RG_TARGET_NAMESPACE = rb_const_get(mCairo, rb_intern("Matrix"));
+
+    RG_DEF_METHOD(to_goo, 0);
+}

data/ext/goocanvas/rbgoocairopattern.c

@@ -0,0 +1,47 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  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 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 "rbgoocanvasprivate.h"
+
+#define RG_TARGET_NAMESPACE cPattern
+
+static VALUE
+rg_to_goo(VALUE self)
+{
+    GValue gval = {0,};
+    VALUE result;
+
+    g_value_init(&gval, GOO_TYPE_CAIRO_PATTERN);
+    g_value_set_boxed(&gval, RVAL2CRPATTERN(self));
+
+    result = rbgobj_gvalue_to_rvalue(&gval);
+    g_value_unset(&gval);
+
+    return result;
+}
+
+void
+Init_goocairopattern(VALUE mCairo)
+{
+    VALUE RG_TARGET_NAMESPACE = rb_const_get(mCairo, rb_intern("Pattern"));
+
+    RG_DEF_METHOD(to_goo, 0);
+}

data/ext/goocanvas/rbgoocanvas.c

@@ -1,28 +1,28 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/* $Id: rbgoocanvas.c 3288 2008-09-13 10:07:44Z ktou $ */
-/* GooCanvas initialization
- * 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"
 
-VALUE mGoo;
-
-#define SELF(self) RVAL2GC(self)
+#define RG_TARGET_NAMESPACE cCanvas
+#define SELF(self) RVAL2GOOCANVAS(self)
 
 void
 rb_goo_canvas_initialize_item_object(VALUE obj, GooCanvasItem *item)
@@ -32,14 +32,14 @@ rb_goo_canvas_initialize_item_object(VALUE obj, GooCanvasItem *item)
 }
 
 static VALUE
-rb_goo_canvas_new(VALUE self)
+rg_initialize(VALUE self)
 {
     RBGTK_INITIALIZE(self, goo_canvas_new());
     return Qnil;
 }
 
 static VALUE
-rb_goo_canvas_set_bounds(VALUE self, VALUE left, VALUE top,
+rg_set_bounds(VALUE self, VALUE left, VALUE top,
                          VALUE right, VALUE bottom)
 {
     goo_canvas_set_bounds(SELF(self), NUM2DBL(left), NUM2DBL(top),
@@ -48,7 +48,7 @@ rb_goo_canvas_set_bounds(VALUE self, VALUE left, VALUE top,
 }
 
 static VALUE
-rb_goo_canvas_get_root_item(VALUE self)
+rg_root_item(VALUE self)
 {
     VALUE root;
 
@@ -59,12 +59,12 @@ rb_goo_canvas_get_root_item(VALUE self)
 }
 
 static VALUE
-rb_goo_canvas_grab_focus(int argc, VALUE *argv, VALUE self)
+rg_grab_focus(int argc, VALUE *argv, VALUE self)
 {
     VALUE item;
 
     if (rb_scan_args(argc, argv, "01", &item) == 1) {
-        goo_canvas_grab_focus(SELF(self), RVAL2GCI(item));
+        goo_canvas_grab_focus(SELF(self), RVAL2GOOCANVASITEM(item));
     } else {
         rb_call_super(0, 0);
     }
@@ -73,10 +73,10 @@ rb_goo_canvas_grab_focus(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-rb_goo_canvas_pointer_grab(VALUE self, VALUE item, VALUE event_mask, VALUE cursor, VALUE etime)
+rg_pointer_grab(VALUE self, VALUE item, VALUE event_mask, VALUE cursor, VALUE etime)
 {
     return GENUM2RVAL(
-        goo_canvas_pointer_grab(SELF(self), RVAL2GCI(item),
+        goo_canvas_pointer_grab(SELF(self), RVAL2GOOCANVASITEM(item),
                                 NUM2INT(event_mask),
                                 (GdkCursor *)RVAL2BOXED(cursor, GDK_TYPE_CURSOR),
                                 NIL_P(etime) ? 0 : NUM2UINT(etime)),
@@ -84,15 +84,15 @@ rb_goo_canvas_pointer_grab(VALUE self, VALUE item, VALUE event_mask, VALUE curso
 }
 
 static VALUE
-rb_goo_canvas_pointer_ungrab(VALUE self, VALUE item, VALUE etime)
+rg_pointer_ungrab(VALUE self, VALUE item, VALUE etime)
 {
-    goo_canvas_pointer_ungrab(SELF(self), RVAL2GCI(item),
+    goo_canvas_pointer_ungrab(SELF(self), RVAL2GOOCANVASITEM(item),
                               NIL_P(etime) ? 0 : NUM2UINT(etime));
     return self;
 }
 
 static VALUE
-rb_goo_canvas_render(VALUE self, VALUE cr, VALUE rb_bounds, VALUE scale)
+rg_render(VALUE self, VALUE cr, VALUE rb_bounds, VALUE scale)
 {
     GooCanvasBounds bounds;
 
@@ -103,7 +103,7 @@ rb_goo_canvas_render(VALUE self, VALUE cr, VALUE rb_bounds, VALUE scale)
 }
 
 static VALUE
-rb_goo_canvas_scroll_to(VALUE self, VALUE left, VALUE top)
+rg_scroll_to(VALUE self, VALUE left, VALUE top)
 {
     goo_canvas_scroll_to(SELF(self), NUM2DBL(left), NUM2DBL(top));
     return self;
@@ -112,125 +112,33 @@ rb_goo_canvas_scroll_to(VALUE self, VALUE left, VALUE top)
 void
 Init_goocanvas(void)
 {
-    VALUE cGooCanvas;
-
-    mGoo = rb_define_module("Goo");
-    cGooCanvas = G_DEF_CLASS(GOO_TYPE_CANVAS, "Canvas", mGoo);
-
-    rb_define_method(cGooCanvas, "initialize", rb_goo_canvas_new, 0);
-    rb_define_method(cGooCanvas, "set_bounds", rb_goo_canvas_set_bounds, 4);
-    rb_define_method(cGooCanvas, "root_item", rb_goo_canvas_get_root_item, 0);
-    rb_define_method(cGooCanvas, "grab_focus", rb_goo_canvas_grab_focus, -1);
-    rb_define_method(cGooCanvas, "pointer_grab", rb_goo_canvas_pointer_grab, 4);
-    rb_define_method(cGooCanvas, "pointer_ungrab",
-		     rb_goo_canvas_pointer_ungrab, 2);
-    rb_define_method(cGooCanvas, "render", rb_goo_canvas_render, 3);
-    rb_define_method(cGooCanvas, "scroll_to", rb_goo_canvas_scroll_to, 2);
-
-    Init_goocanvasitem(); /* Goo::CanvasItem */
-    Init_goocanvastext(); /* Goo::CanvasText */
-    Init_goocanvasrect(); /* Goo::CanvasRect */
-    Init_goocanvasellipse(); /* Goo::CanvasEllipse */
-    Init_goocanvaspolyline(); /* Goo::CanvasPolyline */
-    Init_goocanvasimage(); /* Goo::CanvasImage */
-    Init_goocanvastable(); /* Goo::CanvasTable */
-    Init_goocanvaswidget(); /* Goo::CanvasWidget */
-    Init_goocanvasstyle(); /* Goo::CanvasStyle */
-    Init_goocanvasgroup(); /* Goo::CanvasGroup */
-    Init_goocairo(); /* conversion from Cairo types to GooCairo types */
-
-#if 0
-   GooCanvasItem*  goo_canvas_get_root_item    (GooCanvas		*canvas);
-   void            goo_canvas_set_root_item    (GooCanvas		*canvas,
-   					     GooCanvasItem      *item);
-
-   GooCanvasItemModel* goo_canvas_get_root_item_model (GooCanvas	       *canvas);
-   void                goo_canvas_set_root_item_model (GooCanvas	       *canvas,
-   						    GooCanvasItemModel *model);
-
-   GooCanvasItem*  goo_canvas_get_item	    (GooCanvas		*canvas,
-   					     GooCanvasItemModel *model);
-   GooCanvasItem*  goo_canvas_get_item_at	    (GooCanvas		*canvas,
-   					     gdouble             x,
-   					     gdouble             y,
-   					     gboolean            is_pointer_event);
-
-   gdouble         goo_canvas_get_scale	    (GooCanvas		*canvas);
-   void            goo_canvas_set_scale	    (GooCanvas		*canvas,
-   					     gdouble             scale);
-
-   void            goo_canvas_get_bounds	    (GooCanvas		*canvas,
-   					     gdouble            *left,
-   					     gdouble            *top,
-   					     gdouble            *right,
-   					     gdouble            *bottom);
-
-
-   void            goo_canvas_grab_focus	    (GooCanvas		*canvas,
-   					     GooCanvasItem	*item);
-
-   void            goo_canvas_render	    (GooCanvas		*canvas,
-   					     cairo_t            *cr,
-   					     GooCanvasBounds    *bounds,
-   					     gdouble             scale);
-
-   /*
-    * Coordinate conversion.
-    */
-   void		goo_canvas_convert_to_pixels	   (GooCanvas       *canvas,
-   						    gdouble         *x,
-   						    gdouble         *y);
-   void		goo_canvas_convert_from_pixels	   (GooCanvas       *canvas,
-   						    gdouble         *x,
-   						    gdouble         *y);
-
-   void		goo_canvas_convert_to_item_space   (GooCanvas	    *canvas,
-   						    GooCanvasItem   *item,
-   						    gdouble         *x,
-   						    gdouble         *y);
-   void		goo_canvas_convert_from_item_space (GooCanvas       *canvas,
-   						    GooCanvasItem   *item,
-   						    gdouble         *x,
-   						    gdouble         *y);
-
-
-   /*
-    * Pointer/keyboard grabbing & ungrabbing.
-    */
-   GdkGrabStatus	goo_canvas_pointer_grab	    (GooCanvas		*canvas,
-   					     GooCanvasItem	*item,
-   					     GdkEventMask        event_mask,
-   					     GdkCursor		*cursor,
-   					     guint32             time);
-   void		goo_canvas_pointer_ungrab   (GooCanvas		*canvas,
-   					     GooCanvasItem	*item,
-   					     guint32             time);
-   GdkGrabStatus	goo_canvas_keyboard_grab    (GooCanvas		*canvas,
-   					     GooCanvasItem	*item,
-   					     gboolean            owner_events,
-   					     guint32             time);
-   void		goo_canvas_keyboard_ungrab  (GooCanvas		*canvas,
-   					     GooCanvasItem	*item,
-   					     guint32             time);
-
-
-   /*
-    * Internal functions, mainly for canvas subclasses and item implementations.
-    */
-   GooCanvasItem*	goo_canvas_create_item	    (GooCanvas          *canvas,
-   					     GooCanvasItemModel *model);
-   void		goo_canvas_unregister_item  (GooCanvas		*canvas,
-   					     GooCanvasItemModel *model);
-   void		goo_canvas_update	    (GooCanvas		*canvas);
-   void		goo_canvas_request_update   (GooCanvas		*canvas);
-   void		goo_canvas_request_redraw   (GooCanvas		*canvas,
-   					     GooCanvasBounds	*bounds);
-   gdouble         goo_canvas_get_default_line_width (GooCanvas    *canvas);
-
-
-   void            goo_canvas_register_widget_item   (GooCanvas          *canvas,
-   						   GooCanvasWidget    *witem);
-   void            goo_canvas_unregister_widget_item (GooCanvas          *canvas,
-   						   GooCanvasWidget    *witem);
-#endif
+    Init_goo();
+
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GOO_TYPE_CANVAS, "Canvas", mGoo);
+    VALUE mCairo = rb_const_get(rb_mKernel, rb_intern("Cairo"));
+
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_METHOD(set_bounds, 4);
+    RG_DEF_METHOD(root_item, 0);
+    RG_DEF_METHOD(grab_focus, -1);
+    RG_DEF_METHOD(pointer_grab, 4);
+    RG_DEF_METHOD(pointer_ungrab, 2);
+    RG_DEF_METHOD(render, 3);
+    RG_DEF_METHOD(scroll_to, 2);
+
+    Init_goocanvasitem(mGoo); /* Goo::CanvasItem */
+    Init_goocanvastext(mGoo); /* Goo::CanvasText */
+    Init_goocanvasrect(mGoo); /* Goo::CanvasRect */
+    Init_goocanvasellipse(mGoo); /* Goo::CanvasEllipse */
+    Init_goocanvaspolyline(mGoo); /* Goo::CanvasPolyline */
+    Init_goocanvaspoints(mGoo); /* Goo::CanvasPoints */
+    Init_goocanvasimage(mGoo); /* Goo::CanvasImage */
+    Init_goocanvastable(mGoo); /* Goo::CanvasTable */
+    Init_goocanvaswidget(mGoo); /* Goo::CanvasWidget */
+    Init_goocanvasstyle(mGoo); /* Goo::CanvasStyle */
+    Init_goocanvasgroup(mGoo); /* Goo::CanvasGroup */
+    Init_goocairopattern(mCairo);
+    Init_goocairomatrix(mCairo);
 }

data/ext/goocanvas/rbgoocanvas.h

@@ -1,46 +1,38 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/* $Id: rbgoocanvas.h 3288 2008-09-13 10:07:44Z ktou $ */
-/* GooCanvas main header
- * 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
  */
 
-#ifndef _RBGOOCANVAS_H_included
-#define _RBGOOCANVAS_H_included
+#ifndef __RBGOOCANVAS_H__
+#define __RBGOOCANVAS_H__
 
 #include <rb_cairo.h>
 #include <rbgtk.h>
 #include <goocanvas.h>
 
 #include "rbgoo_canvasversion.h"
-
-#define RVAL2GC(obj) GOO_CANVAS(RVAL2GOBJ(obj))
-#define RVAL2GCI(obj) GOO_CANVAS_ITEM(RVAL2GOBJ(obj))
-#define RVAL2GCS(obj) GOO_CANVAS_STYLE(RVAL2GOBJ(obj))
-
-#define RVAL2GCPOINTS(obj) \
-    ((GooCanvasPoints *)(RVAL2BOXED(obj, GOO_TYPE_CANVAS_POINTS)))
+#include "rbgoocanvasconversions.h"
 
 #define RVAL2GCBOUNDS(obj, bounds)              \
     (ruby_to_goo_canvas_bounds(obj, bounds))
 
-#define RVAL2GTK_WIDGET(obj) GTK_WIDGET(RVAL2GOBJ(obj))
-
-#define RVAL2GDK_PIXBUF(obj) GDK_PIXBUF(RVAL2GOBJ(obj))
-
+#define RVAL2GTKWIDGET(obj) GTK_WIDGET(RVAL2GOBJ(obj))
 
 #define RB_GOO_CANVAS_ITEM_INITIALIZE(obj, item) \
     (rb_goo_canvas_initialize_item_object(obj, GOO_CANVAS_ITEM(item)))
@@ -48,19 +40,6 @@
 void rb_goo_canvas_initialize_item_object(VALUE obj, GooCanvasItem *item);
 GooCanvasBounds *ruby_to_goo_canvas_bounds(VALUE rb_bounds, GooCanvasBounds *dest_bounds);
 
-void Init_goocanvas(void); /* Goo::Canvas */
-void Init_goocanvasitem(void); /* Goo::CanvasItem */
-void Init_goocanvastext(void); /* Goo::CanvasText */
-void Init_goocanvasrect(void); /* Goo::CanvasRect */
-void Init_goocanvasellipse(void); /* Goo::CanvasEllipse */
-void Init_goocanvaspolyline(void); /* Goo::CanvasPolyline */
-void Init_goocanvasimage(void); /* Goo::CanvasImage */
-void Init_goocanvastable(void); /* Goo::CanvasTable */
-void Init_goocanvaswidget(void); /* Goo::CanvasWidget */
-void Init_goocanvasstyle(void); /* Goo::CanvasStyle */
-void Init_goocanvasgroup(void); /* Goo::CanvasGroup */
-void Init_goocairo(void); /* conversion from Cairo types to GooCairo types */
-
 extern VALUE mGoo;
 
-#endif /* ! _RBGOOCANVAS_H_included */
+#endif /* __RBGOOCANVAS_H__ */