goocanvas 2.0.0 → 2.0.1

data/Rakefile

@@ -9,7 +9,6 @@ package = GNOME2Package.new do |_package|
   _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/extconf.rb

@@ -20,7 +20,7 @@ end
 $LOAD_PATH.unshift(mkmf_gnome2_dir.to_s)
 
 module_name = "goocanvas"
-package_id = "goocanvas"
+package_id = "goocanvas-2.0"
 
 begin
   require 'mkmf-gnome2'
@@ -30,9 +30,19 @@ rescue LoadError
   require 'mkmf-gnome2'
 end
 
-["glib2", "atk", "pango", "gdk_pixbuf2", "gtk2"].each do |package|
+[
+  "glib2",
+  "atk",
+  "pango",
+  "gdk_pixbuf2",
+  "gdk3",
+  "gtk3",
+  "gobject-introspection",
+].each do |package|
   directory = "#{package}#{version_suffix}"
-  build_dir = "#{directory}/tmp/#{RUBY_PLATFORM}/#{package}/#{RUBY_VERSION}"
+  build_base_path = "#{directory}/tmp/#{RUBY_PLATFORM}"
+  package_library_name = package.gsub(/-/, "_")
+  build_dir = "#{build_base_path}/#{package_library_name}/#{RUBY_VERSION}"
   add_depend_package(package, "#{directory}/ext/#{package}",
                      top_dir.to_s,
                      :top_build_dir => top_build_dir.to_s,
@@ -55,15 +65,10 @@ check_cairo(rcairo_options) or exit(false)
 
 setup_win32(module_name, base_dir)
 
-unless required_pkg_config_package(package_id,
-                                   :debian => "libgoocanvas-dev",
-                                   :fedora => "goocanvas-devel",
-                                   :macports => "goocanvas")
+unless required_pkg_config_package(package_id)
   exit(false)
 end
 
-make_version_header("GOO_CANVAS", package_id, ".")
-
 create_pkg_config_file("Ruby/GooCanvas", package_id)
 $defs << "-DRUBY_GOO_CANVAS_COMPILATION"
 create_makefile(module_name)

data/ext/goocanvas/rbgoocanvas.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2013  Ruby-GNOME2 Project Team
  *  Copyright (C) 2007  Vincent Isambart <vincent.isambart@gmail.com>
  *
  *  This library is free software; you can redistribute it and/or
@@ -19,197 +19,40 @@
  *  MA  02110-1301  USA
  */
 
-#include "rbgoocanvasprivate.h"
+#include "rbgoocanvas.h"
 
-#define RG_TARGET_NAMESPACE cCanvas
-#define SELF(self) RVAL2GOOCANVAS(self)
-
-void
-rb_goo_canvas_initialize_item_object(VALUE obj, GooCanvasItem *item)
-{
-    g_object_ref_sink(item);
-    G_INITIALIZE(obj, item);
-}
-
-static VALUE
-rg_initialize(VALUE self)
-{
-    RBGTK_INITIALIZE(self, goo_canvas_new());
-    return Qnil;
-}
-
-static VALUE
-rg_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
-rg_root_item(VALUE self)
-{
-    VALUE root;
-
-    root = GOBJ2RVAL(goo_canvas_get_root_item(SELF(self)));
-    G_CHILD_ADD(self, root);
-
-    return root;
-}
-
-static VALUE
-rg_grab_focus(int argc, VALUE *argv, VALUE self)
+static void
+rgoo_canvas_mark(gpointer object)
 {
-    VALUE item;
+    GooCanvas *canvas = object;
+    GooCanvasItem *root_item;
 
-    if (rb_scan_args(argc, argv, "01", &item) == 1) {
-        goo_canvas_grab_focus(SELF(self), RVAL2GOOCANVASITEM(item));
-    } else {
-        rb_call_super(0, 0);
+    rbgobj_gc_mark_instance(object);
+    root_item = goo_canvas_get_root_item(canvas);
+    if (root_item) {
+        rbgobj_gc_mark_instance(root_item);
     }
-
-    return self;
 }
 
-static VALUE
-rg_pointer_grab(VALUE self, VALUE item, VALUE event_mask, VALUE cursor, VALUE etime)
+static void
+rgoo_canvas_item_mark(gpointer object)
 {
-    return GENUM2RVAL(
-        goo_canvas_pointer_grab(SELF(self), RVAL2GOOCANVASITEM(item),
-                                NUM2INT(event_mask),
-                                (GdkCursor *)RVAL2BOXED(cursor, GDK_TYPE_CURSOR),
-                                NIL_P(etime) ? 0 : NUM2UINT(etime)),
-        GDK_TYPE_GRAB_STATUS);
-}
+    GooCanvasItem *item = object;
+    gint i, n_children;
 
-static VALUE
-rg_pointer_ungrab(VALUE self, VALUE item, VALUE etime)
-{
-    goo_canvas_pointer_ungrab(SELF(self), RVAL2GOOCANVASITEM(item),
-                              NIL_P(etime) ? 0 : NUM2UINT(etime));
-    return self;
-}
+    rbgobj_gc_mark_instance(object);
 
-static VALUE
-rg_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
-rg_scroll_to(VALUE self, VALUE left, VALUE top)
-{
-    goo_canvas_scroll_to(SELF(self), NUM2DBL(left), NUM2DBL(top));
-    return self;
-}
-
-static VALUE
-rg_update(VALUE self)
-{
-    goo_canvas_update(SELF(self));
-    return self;
-}
-
-static VALUE
-rg_request_update(VALUE self)
-{
-    goo_canvas_request_update(SELF(self));
-    return self;
-}
-
-static VALUE
-rg_convert_from_pixels(VALUE self, VALUE rb_x, VALUE rb_y)
-{
-    double x = NUM2DBL(rb_x);
-    double y = NUM2DBL(rb_y);
-    goo_canvas_convert_from_pixels(SELF(self), &x, &y);
-    return rb_ary_new3(2, INT2NUM(x), INT2NUM(y));
-}
-
-static VALUE
-rg_convert_to_pixels(VALUE self, VALUE rb_x, VALUE rb_y)
-{
-    double x = NUM2DBL(rb_x);
-    double y = NUM2DBL(rb_y);
-    goo_canvas_convert_to_pixels(SELF(self), &x, &y);
-    return rb_ary_new3(2, INT2NUM(x), INT2NUM(y));
-}
-
-static VALUE
-rg_get_item_at(VALUE self, VALUE x, VALUE y, VALUE b)
-{
-    GooCanvasItem *item;
-    item = goo_canvas_get_item_at(SELF(self),
-                                  NUM2DBL(x),
-                                  NUM2DBL(y),
-                                  RVAL2CBOOL(b));
-    return GOBJ2RVAL(item);
-}
-
-static VALUE
-rg_get_items_at(VALUE self, VALUE x, VALUE y, VALUE b)
-{
-    return GLIST2ARYF(goo_canvas_get_items_at(SELF(self),
-                                  NUM2DBL(x),
-                                  NUM2DBL(y),
-                                  RVAL2CBOOL(b)));
-}
-
-static VALUE
-rg_bounds(VALUE self)
-{
-    double left, top, right, bottom;
-    goo_canvas_get_bounds(SELF(self),
-                          &left,
-                          &top,
-                          &right,
-                          &bottom);
-     return rb_ary_new3(4, INT2NUM(left), INT2NUM(top), INT2NUM(right), INT2NUM(bottom));
+    n_children = goo_canvas_item_get_n_children(item);
+    for (i = 0; i < n_children; i++) {
+        GooCanvasItem *child;
+        child = goo_canvas_item_get_child(item, i);
+        rbgobj_gc_mark_instance(child);
+    }
 }
 
 void
 Init_goocanvas(void)
 {
-    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(bounds, 0);
-    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);
-    RG_DEF_METHOD(update, 0);
-    RG_DEF_METHOD(request_update, 0);
-    RG_DEF_METHOD(convert_from_pixels, 2);
-    RG_DEF_METHOD(convert_to_pixels, 2);
-    RG_DEF_METHOD(get_item_at, 3);
-    RG_DEF_METHOD(get_items_at, 3);
-
-    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);
+    rbgobj_register_mark_func(GOO_TYPE_CANVAS, rgoo_canvas_mark);
+    rbgobj_register_mark_func(GOO_TYPE_CANVAS_ITEM, rgoo_canvas_item_mark);
 }

data/ext/goocanvas/rbgoocanvas.h

@@ -1,7 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
- *  Copyright (C) 2007  Vincent Isambart <vincent.isambart@gmail.com>
+ *  Copyright (C) 2011-2013  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
@@ -22,24 +21,9 @@
 #ifndef __RBGOOCANVAS_H__
 #define __RBGOOCANVAS_H__
 
-#include <rb_cairo.h>
-#include <rbgtk.h>
+#include <rbgobject.h>
 #include <goocanvas.h>
 
-#include "rbgoo_canvasversion.h"
-#include "rbgoocanvasconversions.h"
-
-#define RVAL2GCBOUNDS(obj, bounds)              \
-    (ruby_to_goo_canvas_bounds(obj, bounds))
-
-#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)))
-
-void rb_goo_canvas_initialize_item_object(VALUE obj, GooCanvasItem *item);
-GooCanvasBounds *ruby_to_goo_canvas_bounds(VALUE rb_bounds, GooCanvasBounds *dest_bounds);
-
-extern VALUE mGoo;
+extern void Init_goocanvas(void);
 
 #endif /* __RBGOOCANVAS_H__ */

data/{sample/goocanvas-gi.rb → lib/goo/canvas-item.rb}

@@ -14,28 +14,19 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-require "gtk3"
-require "gobject-introspection"
-
-base_dir = Pathname.new(__FILE__).dirname.dirname.dirname.expand_path
-vendor_dir = base_dir + "vendor" + "local"
-vendor_bin_dir = vendor_dir + "bin"
-GLib.prepend_environment_path(vendor_bin_dir)
-
 module Goo
-  LOG_DOMAIN = "GooCanvas"
-  GLib::Log.set_log_domain(LOG_DOMAIN)
-
-  @initialized = false
-  class << self
-    def init
-      return if @initialized
-      @initialized = true
-      loader = Loader.new(self)
-      loader.load("GooCanvas")
+  module CanvasItem
+    alias_method :remove_child_raw, :remove_child
+    private :remove_child_raw
+    def remove_child(child_or_position)
+      if child_or_position.is_a?(CanvasItem)
+        child = child_or_position
+        position = find_child(child)
+      else
+        position = child_or_position
+        child = get_child(position)
+      end
+      remove_child_raw(position)
     end
   end
-
-  class Loader < GObjectIntrospection::Loader
-  end
 end

data/lib/goocanvas.rb

@@ -1,155 +1,72 @@
-require 'gtk2'
-require 'cairo'
+# Copyright (C) 2013  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
 
-base_dir = Pathname.new(__FILE__).dirname.dirname.expand_path
+require "gtk3"
+require "gobject-introspection"
+
+base_dir = Pathname.new(__FILE__).dirname.dirname.dirname.expand_path
 vendor_dir = base_dir + "vendor" + "local"
 vendor_bin_dir = vendor_dir + "bin"
 GLib.prepend_dll_path(vendor_bin_dir)
-begin
-  major, minor, micro, = RUBY_VERSION.split(/\./)
-  require "#{major}.#{minor}/goocanvas.so"
-rescue LoadError
-  require 'goocanvas.so'
-end
-
-module Goo
-  LOG_DOMAIN="Goo"
-  
-  def self.args_to_hash(args)
-    hash = args.pop if args.last.respond_to?(:to_hash)
-    hash ||= Hash.new
-    (args.length/2).times do |i|
-      key_index, value_index = i*2, i*2+1
-      hash[args[key_index]] = args[value_index]
-    end
-    hash
-  end
-  
-  module PropsInit
-    def init_props(*args)
-      hash = Goo.args_to_hash(args)
-      hash.each_pair { |key, value| set_property(key.to_s.gsub(/-/, '_').to_sym, value) }
-    end
-    
-    def self.append_features(klass)
-      super
-      arity = klass.instance_method(:initialize).arity
-      raise 'the initialize method of a class including PropsInit must have a fixed arity' if arity < 0
-      args_list = (1..arity).collect { |i| "param#{i}" }.join(", ")
-      klass.module_eval <<-END
-        alias :_initialize :initialize
-        def initialize(#{args_list}, *args)
-          _initialize(#{args_list})
-          init_props(*args)
-        end
-        
-        alias :_set_property :set_property
-        def set_property(prop_name, value)
-          pspec = self.class.property(prop_name)
-          value = value.to_goo if pspec.value_type.name =~ /^GooCairo/ and value.respond_to?(:to_goo)
-          _set_property(prop_name, value)
-        end        
-      END
-    end
-  end
-
-  module CanvasItem
-    def set_child_properties(child, *args)
-      hash = Goo.args_to_hash(args)
-      hash.each_pair { |key, value| set_child_property(child, key, value) }
-    end
-    
-    def bounds
-      [x1, x2, y1, y2]
-    end
-    
-    def width
-      x2 - x1
-    end
-    
-    def height
-      y2 - y1
-    end
-    
-    def x
-      x1
-    end
-    
-    def y
-      y1
-    end
-  end
-
-  class CanvasText
-    include PropsInit
-  end
 
-  class CanvasRect
-    include PropsInit
+if vendor_dir.exist?
+  begin
+    require "gobject-introspection"
+    vendor_girepository_dir = vendor_dir + "lib" + "girepository-1.0"
+    GObjectIntrospection.prepend_typelib_path(vendor_girepository_dir)
+  rescue LoadError
   end
+end
 
-  class CanvasEllipse
-    include PropsInit
-  end
+module Goo
+  LOG_DOMAIN = "GooCanvas"
+  GLib::Log.set_log_domain(LOG_DOMAIN)
 
-  class CanvasPolyline
-    include PropsInit
-    def initialize(parent, close_path, points, *args)
-      _initialize(parent, close_path)
-      set_points(points)
-      init_props(*args)
-    end
-    
-    def set_points(points)
-      points = CanvasPoints.new(points) unless points.instance_of?(CanvasPoints)
-      set_property(:points, points)
-    end
-    alias :points= :set_points
-    
-    def self.new_line(parent, x1, y1, x2, y2, *args)
-      self.new(parent, false, [ x1, y1, x2, y2 ], *args)
-    end
-  end
-  
-  class CanvasPoints
-    alias :_initialize :initialize
-    def initialize(arg)
-      if arg.respond_to?(:to_ary)
-        points = arg.flatten
-        num_points = points.length / 2
-        _initialize(num_points)
-        num_points.times { |i| self[i] = [ points[i*2], points[i*2+1] ] }
+  class << self
+    def const_missing(name)
+      init
+      if const_defined?(name)
+        const_get(name)
       else
-        _initialize(arg)
+        super
       end
     end
-    
-    def each
-      num_points.times { |i| yield self[i] }
-    end
 
-    def to_a
-      a = []
-      each { |e| a.push(e) }
-      a
+    def init
+      loader = Loader.new(self)
+      loader.load("GooCanvas")
+      begin
+        major, minor, _ = RUBY_VERSION.split(/\./)
+        require "#{major}.#{minor}/goocanvas.so"
+      rescue LoadError
+        require "goocanvas.so"
+      end
+      require "goo/canvas-item"
+      class << self
+        remove_method(:init)
+        remove_method(:const_missing)
+      end
     end
   end
 
-  class CanvasTable
-    include PropsInit
-  end
-
-  class CanvasGroup
-    include PropsInit
-  end
-
-  class CanvasWidget
-    include PropsInit
-  end
-
-  class CanvasImage
-    include PropsInit
+  class Loader < GObjectIntrospection::Loader
+    private
+    def load_field(info, i, field_info, klass)
+      return if field_info.name == "parent"
+      super
+    end
   end
 end
-
-GLib::Log.set_log_domain(Goo::LOG_DOMAIN)