goocanvas 0.90.6-x86-mingw32

data/ChangeLog

@@ -0,0 +1,87 @@
+2011-01-30  Kouhei Sutou  <kou@cozmixng.org>
+
+	* ./: support gem for Windows build.
+
+2011-01-28  Masaaki Aoyagi
+
+	* src/lib/: -> lib/.
+
+	* src/: -> ext/goocanvas/.
+
+	* extconf.rb: -> ext/goocanvas/extconf.rb
+
+	* ext/goocanvas/extconf.rb: support directory structure change.
+
+	* extconf.rb: add.
+
+	* Rakefile: add.
+
+2010-09-23  Kouhei Sutou  <kou@cozmixng.org>
+
+	* extconf.rb: support Ruby/GLib2 directory structure change.
+
+2008-11-01  Kouhei Sutou  <kou@cozmixng.org>
+
+	* src/: use RARRAY_PTR() and RARRAY_LEN().
+
+2008-09-30  yselkowitz
+
+	* extconf.rb: add missing dependencies.
+
+2008-09-14  Kouhei Sutou  <kou@cozmixng.org>
+
+	* extconf.rb: fix path.
+
+2008-09-13  Kouhei Sutou  <kou@cozmixng.org>
+
+	* extconf.rb: use check_cairo.
+
+	* /: move to The Ruby-GNOME2 Project.
+
+2008-08-16  Kouhei Sutou  <kou@cozmixng.org>
+
+	* sample/demo-primitives.rb: update menu widgets to follow the
+	latest original demo.
+
+	* sample/demo-primitives.rb: TAB -> 2 spaces.
+
+2008-07-21  Kouhei Sutou  <kou@cozmixng.org>
+
+	* src/rbgoocairo.c (rb_cairo_pattern_to_goo)
+	(rb_cairo_matrix_to_goo): fix a reference count bug.
+
+	* sample/demo-fifteen.rb (CanvasSampleFifteen#scramble): fix broken.
+
+	* src/rbgoocanvas.c: bind Goo::Canvas#scroll_to.
+
+2008-06-27  Kouhei Sutou  <kou@cozmixng.org>
+
+	* sample/demo.rb: support quiting by C-q.
+
+	* sample/demo.rb: set $LOAD_PATH.
+
+2007-06-22  Kouhei Sutou  <kou@cozmixng.org>
+
+	* src/:
+	- cleanup macros.
+	- cleanup styles.
+
+	* src/rbgoocanvasitem.c:
+	- fixed style.
+	- used more self-describing macro.
+
+	* README: added.
+
+2007-05-02  Kouhei Sutou  <kou@cozmixng.org>
+
+	* sample/demo.rb: cleanup.
+
+	* extconf.rb, src/rbgoocairo.c: required >= 0.8.0.
+
+	* sample/demo.rb: untabified.
+
+	* extconf.rb: supported GooCanvas version check in C.
+
+	* src/rbgoocanvas.h, src/rbgoocairo.c: supported build with
+	GooCanvas 0.6.0.
+

data/README

@@ -0,0 +1,37 @@
+Ruby/GooCanvas
+==============
+Ruby/GooCanvas is a Ruby binding of GooCanvas.
+
+Requirements
+------------
+   Ruby: http://www.ruby-lang.org/
+   GooCanvas: http://live.gnome.org/GooCanvas
+
+Install
+-------
+   0. install ruby-1.8.x or later and GooCanvas.
+   1. ruby extconf.rb
+   2. make
+   3. su
+   4. make install
+
+Copying
+-------
+   Copyright (c) 2008 Ruby-GNOME2 Project Team
+   Copyright (c) 2007 Vincent Isambart
+   Copyright (c) 2007 Kouhei Sutou <kou@cozmixng.org>
+   Copyright (c) 2007 Manu
+
+   This program is free software.
+   You can distribute/modify this program under the terms of
+   the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1.
+
+Project Website
+---------------
+   http://ruby-gnome2.sourceforge.jp/
+
+Thanks
+------
+
+  * Andrew Whyte
+    - improved rbgoocanvasitem.c.

data/Rakefile

@@ -0,0 +1,14 @@
+# -*- ruby -*-
+
+require './../glib2/lib/gnome2-raketask'
+
+package = GNOME2Package.new do |_package|
+  _package.summary = "Ruby/GooCanvas is a Ruby binding of GooCanvas."
+  _package.description = "Ruby/GooCanvas is a Ruby binding of GooCanvas."
+  _package.dependency.gem.runtime = ["gtk2"]
+  _package.win32.packages = ["goocanvas"]
+  _package.win32.dependencies = []
+  _package.post_install_message = "This library is experimental."
+end
+package.define_tasks
+

data/ext/goocanvas/depend

@@ -0,0 +1,5 @@
+install:
+	if test -n "$(pkgconfigdir)"; then			\
+	  $(MAKEDIRS) $(pkgconfigdir);				\
+	  $(INSTALL_DATA) ../ruby-goocanvas.pc $(pkgconfigdir);	\
+	fi

data/ext/goocanvas/extconf.rb

@@ -0,0 +1,66 @@
+=begin
+extconf.rb for Ruby/GooCanvas extension library
+=end
+
+require 'pathname'
+
+base_dir = Pathname(__FILE__).dirname.parent.parent.expand_path
+top_dir = base_dir.parent.expand_path
+top_build_dir = Pathname(".").parent.parent.parent.expand_path
+
+mkmf_gnome2_dir = top_dir + "glib2" + 'lib'
+version_suffix = ""
+unless mkmf_gnome2_dir.exist?
+  if /(-\d+\.\d+\.\d+)(?:\.\d+)?\z/ =~ base_dir.basename.to_s
+    version_suffix = $1
+    mkmf_gnome2_dir = top_dir + "glib2#{version_suffix}" + 'lib'
+  end
+end
+
+$LOAD_PATH.unshift(mkmf_gnome2_dir.to_s)
+
+module_name = "goocanvas"
+package_id = "goocanvas"
+
+require 'mkmf-gnome2'
+
+["glib2", "atk", "pango", "gdk_pixbuf2", "gtk2"].each do |package|
+  directory = "#{package}#{version_suffix}"
+  build_dir = "#{directory}/tmp/#{RUBY_PLATFORM}/#{package}/#{RUBY_VERSION}"
+  add_depend_package(package, "#{directory}/ext/#{package}",
+                     top_dir.to_s,
+                     :top_build_dir => top_build_dir.to_s,
+                     :target_build_dir => build_dir)
+end
+
+rcairo_options = {}
+rcairo_source_dir_names = ["rcairo"]
+if /mingw|cygwin|mswin32/ =~ RUBY_PLATFORM
+  rcairo_source_dir_names.unshift("rcairo.win32")
+end
+rcairo_source_dir_names.each do |rcairo_source_dir_name|
+  rcairo_source_dir = top_dir.parent.expand_path + rcairo_source_dir_name
+  if rcairo_source_dir.exist?
+    rcairo_options[:rcairo_source_dir] = rcairo_source_dir.to_s
+    break
+  end
+end
+check_cairo(rcairo_options) or exit(false)
+
+setup_win32(module_name, base_dir)
+
+PKGConfig.have_package(package_id) or exit 1
+
+make_version_header("GOO_CANVAS", package_id, ".")
+
+create_pkg_config_file("Ruby/GooCanvas", package_id)
+$defs << "-DRUBY_GOO_CANVAS_COMPILATION"
+create_makefile(module_name)
+pkg_config_dir = with_config("pkg-config-dir")
+if pkg_config_dir.is_a?(String)
+  File.open("Makefile", "ab") do |makefile|
+    makefile.puts
+    makefile.puts("pkgconfigdir=#{pkg_config_dir}")
+  end
+end
+

data/ext/goocanvas/goocanvas.def

@@ -0,0 +1,2 @@
+EXPORTS
+	Init_goocanvas

data/ext/goocanvas/rbgoocairo.c

@@ -0,0 +1,74 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/* $Id: rbgoocairo.c 3288 2008-09-13 10:07:44Z ktou $ */
+/* convertion from Cairo types to GooCairo types
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "rbgoocanvas.h"
+
+static VALUE
+rb_cairo_pattern_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;
+}
+
+static VALUE
+rb_cairo_matrix_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_goocairo(void)
+{
+    VALUE Cairo, CairoPattern, CairoMatrix;
+
+    G_DEF_CLASS(GOO_TYPE_CAIRO_MATRIX, "CairoMatrix", mGoo);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_PATTERN, "CairoPattern", mGoo);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_FILL_RULE, "CairoFillRule", mGoo);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_OPERATOR, "CairoOperator", mGoo);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_ANTIALIAS, "CairoAntiAlias", mGoo);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_LINE_CAP, "CairoLineCap", mGoo);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_LINE_JOIN, "CairoLineJoin", mGoo);
+    G_DEF_CLASS(GOO_TYPE_CAIRO_HINT_METRICS, "CairoHintMetrics", mGoo);
+
+    Cairo = rb_const_get(rb_mKernel, rb_intern("Cairo"));
+
+    CairoPattern = rb_const_get(Cairo, rb_intern("Pattern"));
+    rb_define_method(CairoPattern, "to_goo", rb_cairo_pattern_to_goo, 0);
+
+    CairoMatrix = rb_const_get(Cairo, rb_intern("Matrix"));
+    rb_define_method(CairoMatrix, "to_goo", rb_cairo_matrix_to_goo, 0);
+}

data/ext/goocanvas/rbgoocanvas.c

@@ -0,0 +1,236 @@
+/* -*- 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>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "rbgoocanvas.h"
+
+VALUE mGoo;
+
+#define SELF(self) RVAL2GC(self)
+
+void
+rb_goo_canvas_initialize_item_object(VALUE obj, GooCanvasItem *item)
+{
+    g_object_ref_sink(item);
+    G_INITIALIZE(obj, item);
+}
+
+static VALUE
+rb_goo_canvas_new(VALUE self)
+{
+    RBGTK_INITIALIZE(self, goo_canvas_new());
+    return Qnil;
+}
+
+static VALUE
+rb_goo_canvas_set_bounds(VALUE self, VALUE left, VALUE top,
+                         VALUE right, VALUE bottom)
+{
+    goo_canvas_set_bounds(SELF(self), NUM2DBL(left), NUM2DBL(top),
+                          NUM2DBL(right), NUM2DBL(bottom));
+    return self;
+}
+
+static VALUE
+rb_goo_canvas_get_root_item(VALUE self)
+{
+    VALUE root;
+
+    root = GOBJ2RVAL(goo_canvas_get_root_item(SELF(self)));
+    G_CHILD_ADD(self, root);
+
+    return root;
+}
+
+static VALUE
+rb_goo_canvas_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));
+    } else {
+        rb_call_super(0, 0);
+    }
+
+    return self;
+}
+
+static VALUE
+rb_goo_canvas_pointer_grab(VALUE self, VALUE item, VALUE event_mask, VALUE cursor, VALUE etime)
+{
+    return GENUM2RVAL(
+        goo_canvas_pointer_grab(SELF(self), RVAL2GCI(item),
+                                NUM2INT(event_mask),
+                                (GdkCursor *)RVAL2BOXED(cursor, GDK_TYPE_CURSOR),
+                                NIL_P(etime) ? 0 : NUM2UINT(etime)),
+        GDK_TYPE_GRAB_STATUS);
+}
+
+static VALUE
+rb_goo_canvas_pointer_ungrab(VALUE self, VALUE item, VALUE etime)
+{
+    goo_canvas_pointer_ungrab(SELF(self), RVAL2GCI(item),
+                              NIL_P(etime) ? 0 : NUM2UINT(etime));
+    return self;
+}
+
+static VALUE
+rb_goo_canvas_render(VALUE self, VALUE cr, VALUE rb_bounds, VALUE scale)
+{
+    GooCanvasBounds bounds;
+
+    goo_canvas_render(SELF(self), RVAL2CRCONTEXT(cr),
+                      RVAL2GCBOUNDS(rb_bounds, &bounds),
+                      NUM2DBL(scale));
+    return self;
+}
+
+static VALUE
+rb_goo_canvas_scroll_to(VALUE self, VALUE left, VALUE top)
+{
+    goo_canvas_scroll_to(SELF(self), NUM2DBL(left), NUM2DBL(top));
+    return self;
+}
+
+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
+}

data/ext/goocanvas/rbgoocanvas.h

@@ -0,0 +1,66 @@
+/* -*- 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>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _RBGOOCANVAS_H_included
+#define _RBGOOCANVAS_H_included
+
+#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)))
+
+#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 RB_GOO_CANVAS_ITEM_INITIALIZE(obj, item) \
+    (rb_goo_canvas_initialize_item_object(obj, GOO_CANVAS_ITEM(item)))
+
+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 */

data/ext/goocanvas/rbgoocanvasellipse.c

@@ -0,0 +1,50 @@
+/* -*- 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>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "rbgoocanvas.h"
+
+static VALUE
+rb_goo_canvas_ellipse_new(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),
+                                  NUM2DBL(center_x),
+                                  NUM2DBL(center_y),
+                                  NUM2DBL(radius_x),
+                                  NUM2DBL(radius_y),
+                                  NULL);
+    RB_GOO_CANVAS_ITEM_INITIALIZE(self, item);
+    G_CHILD_ADD(parent, self);
+    return Qnil;
+}
+
+void
+Init_goocanvasellipse(void)
+{
+    VALUE GooCanvasEllipse;
+
+    GooCanvasEllipse = G_DEF_CLASS(GOO_TYPE_CANVAS_ELLIPSE, "CanvasEllipse",
+                                   mGoo);
+
+    rb_define_method(GooCanvasEllipse, "initialize",
+                     rb_goo_canvas_ellipse_new, 5);
+}

data/ext/goocanvas/rbgoocanvasgroup.c

@@ -0,0 +1,41 @@
+/* -*- 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>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "rbgoocanvas.h"
+
+static VALUE
+rb_goo_canvas_group_new(VALUE self, VALUE parent)
+{
+    GooCanvasItem *item;
+    item = goo_canvas_group_new(RVAL2GCI(parent), NULL);
+    RB_GOO_CANVAS_ITEM_INITIALIZE(self, item);
+    G_CHILD_ADD(parent, self);
+    return Qnil;
+}
+
+void
+Init_goocanvasgroup(void)
+{
+    VALUE GooCanvasGroup;
+
+    GooCanvasGroup = G_DEF_CLASS(GOO_TYPE_CANVAS_GROUP, "CanvasGroup", mGoo);
+
+    rb_define_method(GooCanvasGroup, "initialize", rb_goo_canvas_group_new, 1);
+}