goocanvas 2.0.0 → 2.0.1

data/sample/scalability-demo.rb

@@ -1,5 +1,27 @@
 #!/usr/bin/env ruby
-require 'goocanvas'
+#
+# This sample code is a port of
+# goocanvas/demo/scalability-demo.c. It is licensed
+# under the terms of the GNU Library General Public License, version
+# 2 or (at your option) later.
+#
+# 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
+
+require "goocanvas"
 
 # the values behind the comments are the ones used in the C version
 # but as with them it takes more than 20 sec on my computer for the window
@@ -19,7 +41,7 @@ def setup_canvas(canvas)
 
   item_width = 400
   item_height = 19
-	
+
   cell_width = item_width + PADDING * 2
   cell_height = item_height + PADDING * 2
 
@@ -36,12 +58,16 @@ def setup_canvas(canvas)
   style = Goo::CanvasStyle.new
   color = Gdk::Color.parse("mediumseagreen")
   pattern = Cairo::SolidPattern.new(color.red / 65535.0, color.green / 65535.0, color.blue / 65535.0)
-  style.fill_pattern = pattern
+  # NOTE: "Goo::CanvasStyle#fill_pattern=" doesn't work. (undefined method)
+  # Substitution is "Goo::CanvasRect#fill_color=".
+  #style.fill_pattern = pattern
 
   style2 = Goo::CanvasStyle.new
   color = Gdk::Color.parse("steelblue")
   pattern = Cairo::SolidPattern.new(color.red / 65535.0, color.green / 65535.0, color.blue / 65535.0)
-  style2.fill_pattern = pattern
+  # NOTE: "Goo::CanvasStyle#fill_pattern=" doesn't work. (undefined method)
+  # Substitution is "Goo::CanvasRect#fill_color=".
+  #style2.fill_pattern = pattern
 
   total_items = 0
 
@@ -50,10 +76,10 @@ def setup_canvas(canvas)
       group_x = left_offset + (group_i * group_width);
       group_y = top_offset + (group_j * group_height);
 
-      group = Goo::CanvasGroup.new(root)
+      group = Goo::CanvasGroup.new(:parent => root)
       total_items += 1
       group.translate(group_x, group_y)
-      
+
       N_COLS.times do |i|
         N_ROWS.times do |j|
           item_x = (i * cell_width) + PADDING
@@ -61,21 +87,32 @@ def setup_canvas(canvas)
           rotation = i % 10 * 2
           rotation_x = item_x + item_width / 2
           rotation_y = item_y + item_height / 2
-          
+
           current_id = "#{group_x + item_x}, #{group_y + item_y}"
-          
-          item = Goo::CanvasRect.new(group, item_x, item_y, item_width, item_height)
-          item.style = (j % 2) == 1 ? style : style2
+
+          item = Goo::CanvasRect.new(:parent => group,
+                                     :x      => item_x,
+                                     :y      => item_y,
+                                     :width  => item_width,
+                                     :height => item_height)
+          # NOTE: "Goo::CanvasStyle#fill_pattern=" doesn't work. (undefined method)
+          # "Goo::CanvasRect#fill_color=" is substitution.
+          item.fill_color = (j % 2) == 1 ? "mediumseagreen" : "steelblue"
+          #item.style = (j % 2) == 1 ? style : style2
           item.rotate(rotation, rotation_x, rotation_y)
-          
+
           item.signal_connect('motion_notify_event') do
             puts "#{current_id} item received 'motion-notify' signal"
           end
 
-          item = Goo::CanvasText.new(group, current_id,
-            item_x + item_width / 2, item_y + item_height / 2, -1, Gtk::ANCHOR_CENTER)
+          item = Goo::CanvasText.new(:parent => group,
+                                     :text   => current_id,
+                                     :x      => item_x + item_width / 2,
+                                     :y      => item_y + item_height / 2,
+                                     :width  => -1,
+                                     :anchor => Goo::CanvasAnchorType::CENTER)
           item.rotate(rotation, rotation_x, rotation_y)
-          
+
           total_items += 2
           break if ONLY_ONE
         end
@@ -94,7 +131,7 @@ def create_canvas
   # Create the canvas.
   canvas = Goo::Canvas.new
   canvas.set_size_request(600, 450)
-  
+
   start = Time.new
   total_width, total_height, left_offset, top_offset = setup_canvas(canvas)
   puts "Create Canvas Time Used: #{Time.new - start}"
@@ -104,18 +141,18 @@ def create_canvas
   canvas.show
 
   first_time = true
-  canvas.signal_connect("expose_event") do
+  canvas.signal_connect("draw") do
     if first_time
       puts "Update Canvas Time Used: #{Time.new - start}"
       first_time = false
     end
     false
   end
-  
+
   canvas
 end
 
-window = Gtk::Window.new(Gtk::Window::TOPLEVEL)
+window = Gtk::Window.new(:toplevel)
 window.set_default_size(640, 600)
 window.show
 window.signal_connect('delete_event') { Gtk.main_quit }
@@ -124,7 +161,9 @@ scrolled_win = Gtk::ScrolledWindow.new
 scrolled_win.show
 window.add(scrolled_win)
 
+GC.disable
 canvas = create_canvas
 scrolled_win.add(canvas)
+GC.enable
 
 Gtk.main

data/sample/simple-demo.rb

@@ -21,9 +21,7 @@
 # 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 'goocanvas-gi'
-
-Goo.init
+require 'goocanvas'
 
 # Create the window and widgets.
 window = Gtk::Window.new(:toplevel)

data/sample/table-demo.rb

@@ -1,5 +1,28 @@
 #!/usr/bin/env ruby
-require 'goocanvas'
+#
+# This sample code is a port of
+# goocanvas/demo/table-demo.c. It is licensed
+# under the terms of the GNU Library General Public License, version
+# 2 or (at your option) later.
+#
+# 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
+
+require "goocanvas"
+
 DEMO_RECT_ITEM = 0
 DEMO_TEXT_ITEM = 1
 DEMO_WIDGET_ITEM = 2
@@ -7,16 +30,37 @@ DEMO_WIDGET_ITEM = 2
 def create_demo_item(table, demo_item_type, row, column, rows, columns, text)
   case demo_item_type
   when DEMO_RECT_ITEM
-    item = Goo::CanvasRect.new(table, 0, 0, 38, 19, :fill_color => 'red')
+    item = Goo::CanvasRect.new(:parent     => table,
+                               :x          => 0,
+                               :y          => 0,
+                               :width      => 38,
+                               :height     => 19,
+                               :fill_color => "red")
   when DEMO_TEXT_ITEM
-    item = Goo::CanvasText.new(table, text, 0, 0, -1, Gtk::ANCHOR_NW, nil)
+    item = Goo::CanvasText.new(:parent => table,
+                               :text   => text,
+                               :x      => 0,
+                               :y      => 0,
+                               :width  => -1,
+                               :anchor => :nw)
   when DEMO_WIDGET_ITEM
-    widget = Gtk::Button.new(text)
-    item = Goo::CanvasWidget.new(table, widget, 0, 0, -1, -1)
+    widget = Gtk::Button.new(:label => text)
+    item = Goo::CanvasWidget.new(:parent => table,
+                                 :widget => widget,
+                                 :x      => 0,
+                                 :y      => 0,
+                                 :width  => -1,
+                                 :height => -1)
   end
 
-  table.set_child_properties(item, :row => row, :column => column, :rows => rows, :columns => columns,
-    :x_expand => true, :x_fill => true, :y_expand => true, :y_fill => true)
+  table.set_child_property(item, "row", row)
+  table.set_child_property(item, "column", column)
+  table.set_child_property(item, "rows", rows)
+  table.set_child_property(item, "columns", columns)
+  table.set_child_property(item, "x-expand", true)
+  table.set_child_property(item, "x-fill", true)
+  table.set_child_property(item, "y-expand", true)
+  table.set_child_property(item, "y-fill", true)
 
   item.signal_connect('button_press_event') do |item, target, event|
     puts "#{text} received 'button-press' signal at #{event.x}, #{event.y} (root:  #{event.x_root}, #{event.y_root})"
@@ -26,13 +70,20 @@ end
 
 def create_table(parent, row, column, embedding_level, x, y, rotation, scale, demo_item_type)
   # Add a few simple items.
-  table = Goo::CanvasTable.new(parent, :row_spacing => 4.0, :column_spacing => 4.0)
+  table = Goo::CanvasTable.new(:parent         => parent,
+                               :row_spacing    => 4.0,
+                               :column_spacing => 4.0)
 
   table.translate(x, y)
   table.rotate(rotation, 0, 0)
   table.scale(scale, scale)
 
-  parent.set_child_properties(table, :row => row, :column => column, :x_expand => true, :x_fill => true) if row
+  if row
+    parent.set_child_property(table, "row", row)
+    parent.set_child_property(table, "column", column)
+    parent.set_child_property(table, "x-expand", true)
+    parent.set_child_property(table, "x_fill", true)
+  end
 
   if embedding_level > 0
     level = embedding_level - 1
@@ -60,51 +111,81 @@ def create_table(parent, row, column, embedding_level, x, y, rotation, scale, de
 end
 
 def create_demo_table(root, x, y, width, height)
-  table = Goo::CanvasTable.new(root, :row_spacing => 4.0, :column_spacing => 4.0, :width => width, :height => height)
+  table = Goo::CanvasTable.new(:parent         => root,
+                               :row_spacing    => 4.0,
+                               :column_spacing => 4.0,
+                               :width          => width,
+                               :height         => height)
   table.translate(x, y)
 
-  square = Goo::CanvasRect.new(table, 0.0, 0.0, 50.0, 50.0, :fill_color => 'red')
-  table.set_child_properties(square, :row => 0, :column => 0, :x_shrink => true)
+  square = Goo::CanvasRect.new(:parent     => table,
+                               :x          => 0.0,
+                               :y          => 0.0,
+                               :width      => 50.0,
+                               :height     => 50.0,
+                               :fill_color => "red")
+  table.set_child_property(square, "row", 0)
+  table.set_child_property(square, "column", 0)
+  table.set_child_property(square, "x_shrink", true)
   square.signal_connect('button_press_event') do |item, target, event|
     puts "Red square received 'button-press' signal at #{event.x}, #{event.y} (root:  #{event.x_root}, #{event.y_root})"
     true
   end
 
-  circle = Goo::CanvasEllipse.new(table, 0.0, 0.0, 25.0, 25.0, :fill_color => 'blue')
-  table.set_child_properties(circle, :row => 0, :column => 1, :x_shrink => true)
+  circle = Goo::CanvasEllipse.new(:parent     => table,
+                                  :x          => 0.0,
+                                  :y          => 0.0,
+                                  :radius_x   => 25.0,
+                                  :radius_y   => 25.0,
+                                  :fill_color => "blue")
+  table.set_child_property(circle, "row", 0)
+  table.set_child_property(circle, "column", 1)
+  table.set_child_property(circle, "x_shrink", true)
   circle.signal_connect('button_press_event') do |item, target, event|
     puts "Blue circle received 'button-press' signal at #{event.x}, #{event.y} (root:  #{event.x_root}, #{event.y_root})"
     true
   end
 
-  triangle = Goo::CanvasPolyline.new(table, true, [ [ 25.0, 0.0], [ 0.0, 50.0 ], [ 50.0, 50.0 ] ], :fill_color => "yellow")
-  table.set_child_properties(triangle, :row => 0, :column => 2, :x_shrink => true)
+  points = Goo::CanvasPoints.new(3)
+  points.set_point(0, 25.0,  0.0)
+  points.set_point(1,  0.0, 50.0)
+  points.set_point(2, 50.0, 50.0)
+  triangle = Goo::CanvasPolyline.new(:parent     => table,
+                                     :close_path => true,
+                                     :points     => points,
+                                     :fill_color => "yellow")
+  table.set_child_property(triangle, "row", 0)
+  table.set_child_property(triangle, "column", 2)
+  table.set_child_property(triangle, "x_shrink", true)
   triangle.signal_connect('button_press_event') do |item, target, event|
     puts "Yellow triangle received 'button-press' signal at #{event.x}, #{event.y} (root:  #{event.x_root}, #{event.y_root})"
     true
   end
 end
 
-window = Gtk::Window.new(Gtk::Window::TOPLEVEL)
+window = Gtk::Window.new(:toplevel)
 window.set_default_size(640, 600)
 window.signal_connect('delete_event') { Gtk.main_quit }
 
-vbox = Gtk::VBox.new(false, 4)
+vbox = Gtk::Box.new(:vertical, 4)
 vbox.border_width = 4
 vbox.show
 window.add(vbox)
 
-hbox = Gtk::HBox.new(false, 4)
-vbox.pack_start(hbox, false, false, 0)
+hbox = Gtk::Box.new(:horizontal, 4)
+vbox.pack_start(hbox, :expand  => false,
+                      :fill    => false,
+                      :padding => 0)
 hbox.show
 
 scrolled_win = Gtk::ScrolledWindow.new
-scrolled_win.shadow_type = Gtk::SHADOW_IN
+scrolled_win.shadow_type = :in
 scrolled_win.show
-vbox.pack_start(scrolled_win, true, true, 0)
+vbox.pack_start(scrolled_win, :expand  => true,
+                              :fill    => true,
+                              :padding => 0)
 
 canvas = Goo::Canvas.new
-canvas.flags = Gtk::Widget::CAN_FOCUS
 canvas.set_size_request(600, 450)
 canvas.set_bounds(0, 0, 1000, 1000)
 scrolled_win.add(canvas)

data/sample/units-demo.rb

@@ -21,9 +21,7 @@
 # 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 'goocanvas-gi'
-
-Goo.init
+require 'goocanvas'
 
 DATA = {
   :pixel  => [ 100, 100, 200,  20,   10, 200, 310,  24 ],

data/sample/widgets-demo.rb

@@ -1,5 +1,27 @@
 #!/usr/bin/env ruby
-require 'goocanvas'
+#
+# This sample code is a port of
+# goocanvas/demo/widgets-demo.c. It is licensed
+# under the terms of the GNU Library General Public License, version
+# 2 or (at your option) later.
+#
+# 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
+
+require "goocanvas"
 
 num_added_widgets = 0
 added_widget_items = []
@@ -8,7 +30,15 @@ move_item = nil
 
 def create_focus_box(canvas, x, y, width, height, color)
   root = canvas.root_item
-  item = Goo::CanvasRect.new(root, x, y, width, height, :stroke_pattern => nil, :fill_color => color, :line_width => 5.0, :can_focus => true)
+  item = Goo::CanvasRect.new(:parent         => root,
+                             :x              => x,
+                             :y              => y,
+                             :width          => width,
+                             :height         => height,
+                             :stroke_pattern => nil,
+                             :fill_color     => color,
+                             :line_width     => 5.0,
+                             :can_focus      => true)
 
   item.signal_connect('focus_in_event') do
     puts "#{color} received focus-in event"
@@ -39,25 +69,29 @@ def create_focus_box(canvas, x, y, width, height, color)
 end
 
 def add_button(hbox, button_name, &click_action)
-  w = Gtk::Button.new(button_name)
-  hbox.pack_start(w, false, false, 0)
+  w = Gtk::Button.new(:label => button_name)
+  hbox.pack_start(w, :expand  => false,
+                     :fill    => false,
+                     :padding => 0)
   w.show
   w.signal_connect('clicked', &click_action)
 end
 
 # Create the window and widgets.
-window = Gtk::Window.new(Gtk::Window::TOPLEVEL)
+window = Gtk::Window.new(:toplevel)
 window.set_default_size(640, 600)
 window.show
 window.signal_connect('delete_event') { Gtk.main_quit }
 
-vbox = Gtk::VBox.new(false, 4)
+vbox = Gtk::Box.new(:vertical, 4)
 vbox.border_width = 4
 vbox.show
 window.add(vbox)
 
-hbox = Gtk::HBox.new(false, 4)
-vbox.pack_start(hbox, false, false, 0)
+hbox = Gtk::Box.new(:horizontal, 4)
+vbox.pack_start(hbox, :expand  => false,
+                      :fill    => false,
+                      :padding => 0)
 hbox.show
 
 add_button(hbox, 'Add Widget') do
@@ -68,7 +102,12 @@ add_button(hbox, 'Add Widget') do
   end
 
   root = canvas.root_item
-  witem = Goo::CanvasWidget.new(root, widget, num_added_widgets * 50, num_added_widgets * 50, 200, 50, nil)
+  witem = Goo::CanvasWidget.new(:parent => root,
+                                :widget => widget,
+                                :x      => num_added_widgets * 50,
+                                :y      => num_added_widgets * 50,
+                                :width  => 200,
+                                :height => 50)
 
   added_widget_items.push(witem)
   num_added_widgets += 1
@@ -100,12 +139,14 @@ add_button(hbox, 'Move Widget') do
 end
 
 # here we have to do a little more complicated than in C because Ruby/Gtk+'s enums are not ints and we can't do + 1 on them
-moving_anchor = Gtk::ANCHOR_CENTER.to_i
+moving_anchor = Goo::CanvasAnchorType::CENTER.to_i
 add_button(hbox, 'Change Anchor') do
-  puts "Setting anchor to: #{Gtk::AnchorType.new(moving_anchor).name}"
+  puts "Setting anchor to: #{Goo::CanvasAnchorType.new(moving_anchor).name}"
   move_item.anchor = moving_anchor
   moving_anchor += 1
-  moving_anchor = Gtk::ANCHOR_CENTER.to_i if moving_anchor > Gtk::ANCHOR_EAST.to_i
+  if moving_anchor > Goo::CanvasAnchorType::EAST.to_i
+    moving_anchor = Goo::CanvasAnchorType::CENTER.to_i
+  end
 end
 
 add_button(hbox, 'Change Widget') do
@@ -119,23 +160,26 @@ add_button(hbox, 'Change Widget') do
   end
 end
 
-hbox = Gtk::HBox.new(false, 4)
-vbox.pack_start(hbox, false, false, 0)
+hbox = Gtk::Box.new(:horizontal, 4)
+vbox.pack_start(hbox, :expand  => false,
+                      :fill    => false,
+                      :padding => 0)
 hbox.show
 
 add_button(hbox, 'Hide Canvas') { canvas.hide }
 add_button(hbox, 'Show Canvas') { canvas.show }
-add_button(hbox, 'Hide Item') { move_item.visibility = Goo::CanvasItem::INVISIBLE }
-add_button(hbox, 'Show Item') { move_item.visibility = Goo::CanvasItem::VISIBLE }
+add_button(hbox, 'Hide Item') { move_item.visibility = :invisible }
+add_button(hbox, 'Show Item') { move_item.visibility = :visible }
 add_button(hbox, 'Change Transform') { move_item.translate(25, 25) }
 
 scrolled_win = Gtk::ScrolledWindow.new
-scrolled_win.shadow_type = Gtk::SHADOW_IN
+scrolled_win.shadow_type = :in
 scrolled_win.show
-vbox.pack_start(scrolled_win, true, true, 0)
+vbox.pack_start(scrolled_win, :expand  => true,
+                              :fill    => true,
+                              :padding => 0)
 
 canvas = Goo::Canvas.new
-canvas.flags = Gtk::Widget::CAN_FOCUS
 canvas.set_size_request(600, 450)
 canvas.set_bounds(0, 0, 1000, 1000)
 scrolled_win.add(canvas)
@@ -144,47 +188,83 @@ root = canvas.root_item
 
 # Add a few simple items.
 label = Gtk::Label.new("Hello World")
-witem = Goo::CanvasWidget.new(root, label, 50, 50, 200, 100, nil)
+witem = Goo::CanvasWidget.new(:parent => root,
+                              :widget => label,
+                              :x      => 50,
+                              :y      => 50,
+                              :width  => 200,
+                              :height => 100)
 
 entry = Gtk::Entry.new
-move_item = Goo::CanvasWidget.new(root, entry, 50, 250, 200, 50, nil)
+move_item = Goo::CanvasWidget.new(:parent => root,
+                                  :widget => entry,
+                                  :x      => 50,
+                                  :y      => 250,
+                                  :width  => 200,
+                                  :height => 50)
 
 entry = Gtk::Entry.new
 entry.text = "Size: -1 x -1"
-witem = Goo::CanvasWidget.new(root, entry, 50, 300, -1, -1, nil)
+witem = Goo::CanvasWidget.new(:parent => root,
+                              :widget => entry,
+                              :x      => 50,
+                              :y      => 300,
+                              :width  => -1,
+                              :height => -1)
 
 entry = Gtk::Entry.new
 entry.text = "Size: 100 x -1"
-witem = Goo::CanvasWidget.new(root, entry, 50, 350, 100, -1, nil)
+witem = Goo::CanvasWidget.new(:parent => root,
+                              :widget => entry,
+                              :x      => 50,
+                              :y      => 350,
+                              :width  => 100,
+                              :height => -1)
 
 # Use a textview so we can see the width & height of the widget.
 scrolled_win = Gtk::ScrolledWindow.new
-scrolled_win.shadow_type = Gtk::SHADOW_IN
-scrolled_win.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_NEVER)
+scrolled_win.shadow_type = :in
+scrolled_win.set_policy(:never, :never)
 textview = Gtk::TextView.new
 buffer = textview.buffer
 buffer.text = "Size: -1 x 100"
 textview.show
 scrolled_win.add(textview)
 scrolled_win.set_size_request(160, 50)
-witem = Goo::CanvasWidget.new(root, scrolled_win, 50, 400, -1, 100, nil)
+witem = Goo::CanvasWidget.new(:parent => root,
+                              :widget => scrolled_win,
+                              :x      => 50,
+                              :y      => 400,
+                              :width  => -1,
+                              :height => 100)
 
 # Create a vbox item with several child entry widgets to check focus traversal.
-vbox = Gtk::VBox.new(false, 4)
+vbox = Gtk::Box.new(:vertical, 4)
 
 entry = Gtk::Entry.new
 entry.show
-vbox.pack_start(entry, false, false, 0)
+vbox.pack_start(entry, :expand  => false,
+                       :fill    => false,
+                       :padding => 0)
 
 entry = Gtk::Entry.new
 entry.show
-vbox.pack_start(entry, false, false, 0)
+vbox.pack_start(entry, :expand  => false,
+                       :fill    => false,
+                       :padding => 0)
 
 entry = Gtk::Entry.new
 entry.show
-vbox.pack_start(entry, false, false, 0)
-
-witem = Goo::CanvasWidget.new(root, vbox, 50, 600, -1, -1, nil)
+vbox.pack_start(entry, :expand  => false,
+                       :fill    => false,
+                       :padding => 0)
+
+witem = Goo::CanvasWidget.new(:parent => root,
+                              :widget => vbox,
+                              :x      => 50,
+                              :y      => 600,
+                              :width  => -1,
+                              :height => -1)
 
 # Create a few normal canvas items that take keyboard focus.
 create_focus_box(canvas, 110, 80, 50, 30, 'red')