goocanvas 0.90.6-x86-mingw32

data/sample/demo.rb

@@ -0,0 +1,84 @@
+#  -*- indent-tabs-mode: nil -*-
+=begin header
+
+  demo.rb - Canvas test rewritten in Ruby/GooCanvas
+
+  Rewritten by  Emmanuel Pinault <seatmanu@yahoo.com>
+
+Original Copyright:
+
+  Author :  Richard Hestilow <hestgray@ionet.net>
+
+  Copyright (C) 1998 Free Software Foundation
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  This program 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 General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+  02111-1307, USA.
+
+=end
+
+base_dir = File.dirname(__FILE__)
+src_dir = File.expand_path(File.join(base_dir, "..", "src"))
+lib_dir = File.join(src_dir, "lib")
+
+$LOAD_PATH.unshift(src_dir)
+$LOAD_PATH.unshift(lib_dir)
+$LOAD_PATH.unshift(base_dir)
+
+require 'goocanvas'
+require 'demo-primitives'
+require 'demo-arrowhead'
+require 'demo-fifteen'
+
+class GooCanvasSample < Gtk::Window
+  def initialize
+    super(Gtk::Window::TOPLEVEL)
+
+    signal_connect("destroy") do |widget, event|
+      Gtk::main_quit()
+    end
+
+    signal_connect("key_press_event") do |widget, event|
+      if event.state.control_mask? and event.keyval == Gdk::Keyval::GDK_q
+        destroy
+        true
+      else
+        false
+      end
+    end
+
+    set_default_size(640, 600)
+    notebook = Gtk::Notebook.new
+    add(notebook)
+    notebook.show
+
+    notebook.append_page(CanvasSamplePrimitives.new(false),
+                         Gtk::Label.new("Primitives"))
+    notebook.append_page(CanvasSampleArrowhead.new,
+                         Gtk::Label.new("Arrowhead"))
+    notebook.append_page(CanvasSampleFifteen.new,
+                         Gtk::Label.new("Fifteen"))
+#     notebook.append_page(CanvasSampleFeatures.new,
+#                          Gtk::Label.new("Feature"))
+#     notebook.append_page(CanvasSampleRichText.new,
+#                          Gtk::Label.new("Rich Text"))
+#     notebook.append_page(CanvasSampleBezierCurve.new,
+#                          Gtk::Label.new("Bezier Curve"))
+    show
+  end
+end
+
+canvas = GooCanvasSample.new
+
+Gtk.main

data/sample/scalability-demo.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+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
+# to show upm I decreased them a little
+N_GROUP_COLS = 15 #25
+N_GROUP_ROWS = 10 #20
+N_COLS = 10
+N_ROWS = 10
+
+PADDING = 10
+
+ONLY_ONE = false
+
+def setup_canvas(canvas)
+  root = canvas.root_item
+  root.font = 'Sans 8'
+
+  item_width = 400
+  item_height = 19
+	
+  cell_width = item_width + PADDING * 2
+  cell_height = item_height + PADDING * 2
+
+  group_width = N_COLS * cell_width
+  group_height = N_ROWS * cell_height
+
+  total_width = N_GROUP_COLS * group_width
+  total_height = N_GROUP_ROWS * group_height
+
+  # We use -ve offsets to test if -ve coords are handled correctly.
+  left_offset = -total_width / 2
+  top_offset = -total_height / 2
+
+  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
+
+  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
+
+  total_items = 0
+
+  N_GROUP_COLS.times do |group_i|
+    N_GROUP_ROWS.times do |group_j|
+      group_x = left_offset + (group_i * group_width);
+      group_y = top_offset + (group_j * group_height);
+
+      group = Goo::CanvasGroup.new(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
+          item_y = (j * cell_height) + PADDING
+          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.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.rotate(rotation, rotation_x, rotation_y)
+          
+          total_items += 2
+          break if ONLY_ONE
+        end
+        break if ONLY_ONE
+      end
+      break if ONLY_ONE
+    end
+    break if ONLY_ONE
+  end
+
+  puts "Total items: #{total_items}"
+  [ total_width, total_height, left_offset, top_offset ]
+end
+
+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}"
+
+  start = Time.new
+  canvas.set_bounds(left_offset, top_offset, left_offset + total_width, top_offset + total_height)
+  canvas.show
+
+  first_time = true
+  canvas.signal_connect("expose_event") 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.set_default_size(640, 600)
+window.show
+window.signal_connect('delete_event') { Gtk.main_quit }
+
+scrolled_win = Gtk::ScrolledWindow.new
+scrolled_win.show
+window.add(scrolled_win)
+
+canvas = create_canvas
+scrolled_win.add(canvas)
+
+Gtk.main

data/sample/simple-demo.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+require 'goocanvas'
+
+# Create the window and widgets.
+window = Gtk::Window.new(Gtk::Window::TOPLEVEL)
+window.set_default_size(640, 600)
+window.show
+window.signal_connect('delete_event') { Gtk.main_quit }
+
+scrolled_win = Gtk::ScrolledWindow.new
+scrolled_win.shadow_type = Gtk::SHADOW_IN
+scrolled_win.show
+window.add(scrolled_win)
+
+canvas = Goo::Canvas.new
+canvas.set_size_request(600, 450)
+canvas.set_bounds(0, 0, 1000, 1000)
+canvas.show
+scrolled_win.add(canvas)
+
+root = canvas.root_item
+
+rect_item = Goo::CanvasRect.new(root, 100, 100, 400, 400,
+  :line_width => 10.0,
+  :radius_x => 20.0,
+  :radius_y => 10.0,
+  :stroke_color => 'yellow',
+  :fill_color => 'red')
+rect_item.signal_connect('button_press_event') { puts "rect item received button press event\n" }
+
+text_item = Goo::CanvasText.new(root, 'Hello World', 300, 300, -1, Gtk::ANCHOR_CENTER, :font => 'Sans 24')
+
+text_item.rotate(45, 300, 300)
+
+Gtk.main

data/sample/table-demo.rb

@@ -0,0 +1,137 @@
+#!/usr/bin/env ruby
+require 'goocanvas'
+DEMO_RECT_ITEM = 0
+DEMO_TEXT_ITEM = 1
+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')
+  when DEMO_TEXT_ITEM
+    item = Goo::CanvasText.new(table, text, 0, 0, -1, Gtk::ANCHOR_NW, nil)
+  when DEMO_WIDGET_ITEM
+    widget = Gtk::Button.new(text)
+    item = Goo::CanvasWidget.new(table, widget, 0, 0, -1, -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)
+
+  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})"
+    true
+  end
+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.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 embedding_level > 0
+    level = embedding_level - 1
+    create_table(table, 0, 0, level, 50, 50, 0, 0.7, demo_item_type)
+    create_table(table, 0, 1, level, 50, 50, 45, 1.0, demo_item_type)
+    create_table(table, 0, 2, level, 50, 50, 90, 1.0, demo_item_type)
+    create_table(table, 1, 0, level, 50, 50, 135, 1.0, demo_item_type)
+    create_table(table, 1, 1, level, 50, 50, 180, 1.5, demo_item_type)
+    create_table(table, 1, 2, level, 50, 50, 225, 1.0, demo_item_type)
+    create_table(table, 2, 0, level, 50, 50, 270, 1.0, demo_item_type)
+    create_table(table, 2, 1, level, 50, 50, 315, 1.0, demo_item_type)
+    create_table(table, 2, 2, level, 50, 50, 360, 2.0, demo_item_type)
+  else
+    create_demo_item(table, demo_item_type, 0, 0, 1, 1, "(0,0)")
+    create_demo_item(table, demo_item_type, 0, 1, 1, 1, "(1,0)")
+    create_demo_item(table, demo_item_type, 0, 2, 1, 1, "(2,0)")
+    create_demo_item(table, demo_item_type, 1, 0, 1, 1, "(0,1)")
+    create_demo_item(table, demo_item_type, 1, 1, 1, 1, "(1,1)")
+    create_demo_item(table, demo_item_type, 1, 2, 1, 1, "(2,1)")
+    create_demo_item(table, demo_item_type, 2, 0, 1, 1, "(0,2)")
+    create_demo_item(table, demo_item_type, 2, 1, 1, 1, "(1,2)")
+    create_demo_item(table, demo_item_type, 2, 2, 1, 1, "(2,2)")
+  end
+  table
+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.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.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.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)
+  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.set_default_size(640, 600)
+window.signal_connect('delete_event') { Gtk.main_quit }
+
+vbox = Gtk::VBox.new(false, 4)
+vbox.border_width = 4
+vbox.show
+window.add(vbox)
+
+hbox = Gtk::HBox.new(false, 4)
+vbox.pack_start(hbox, false, false, 0)
+hbox.show
+
+scrolled_win = Gtk::ScrolledWindow.new
+scrolled_win.shadow_type = Gtk::SHADOW_IN
+scrolled_win.show
+vbox.pack_start(scrolled_win, true, true, 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)
+
+root = canvas.root_item
+
+create_demo_table(root, 400, 200, -1, -1)
+create_demo_table(root, 400, 260, 100, -1)
+
+create_table(root, nil, nil, 0, 10, 10, 0, 1.0, DEMO_TEXT_ITEM)
+create_table(root, nil, nil, 0, 180, 10, 30, 1.0, DEMO_TEXT_ITEM)
+create_table(root, nil, nil, 0, 350, 10, 60, 1.0, DEMO_TEXT_ITEM)
+create_table(root, nil, nil, 0, 500, 10, 90, 1.0, DEMO_TEXT_ITEM)
+
+table = create_table(root, nil, nil, 0, 30, 150, 0, 1.0, DEMO_TEXT_ITEM)
+table.width = 300.0
+table.height = 100.0
+
+create_table(root, nil, nil, 1, 200, 200, 30, 0.8, DEMO_TEXT_ITEM)
+
+table = create_table(root, nil, nil, 0, 10, 700, 0, 1.0, DEMO_WIDGET_ITEM)
+table.width = 300.0
+table.height = 200.0
+
+canvas.show
+
+window.show
+
+Gtk.main
+

data/sample/units-demo.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+require 'goocanvas'
+
+DATA = {
+  Gtk::PaperSize::UNIT_PIXEL  => [ 100, 100, 200,  20,   10, 200, 310,  24 ],
+  Gtk::PaperSize::UNIT_POINTS => [ 100, 100, 200,  20,   10, 200, 310,  24 ],
+  Gtk::PaperSize::UNIT_INCH   => [   1,   1,   3, 0.5, 0.16,   3,   4, 0.3 ],
+  Gtk::PaperSize::UNIT_MM     => [  30,  30, 100,  10,    5,  80,  60,  10 ],
+}
+
+def setup_canvas(canvas, units, units_name)
+  d = DATA[units]
+
+  root = canvas.root_item
+  
+  item = Goo::CanvasRect.new(root, d[0], d[1], d[2], d[3])
+  item.signal_connect('motion_notify_event') { puts "received 'motion-notify' signal" }
+  
+  item = Goo::CanvasText.new(root, "This box is #{d[2]}x#{d[3]} #{units_name}",
+    d[0] + d[2] / 2.0, d[1] + d[3] / 2.0, -1, Gtk::ANCHOR_CENTER, :font => "Sans #{d[4]}px")
+  
+  item = Goo::CanvasText.new(root, "This font is #{d[7]} #{units_name} high",
+    d[5], d[6], -1, Gtk::ANCHOR_CENTER, :font => "Sans #{d[7]}px")
+end
+
+def create_canvas(units, units_name)
+  vbox = Gtk::VBox.new(false, 4)
+  vbox.show
+
+  hbox = Gtk::HBox.new(false, 4)
+  vbox.pack_start(hbox, false, false, 0)
+  hbox.show
+
+  canvas = Goo::Canvas.new
+
+  w = Gtk::Label.new('Zoom:')
+  hbox.pack_start(w, false, false, 0)
+  w.show
+  
+  adj = Gtk::Adjustment.new(1, 0.05, 100, 0.05, 0.5, 0.5)
+  w = Gtk::SpinButton.new(adj, 0, 2)
+  adj.signal_connect('value_changed') { |new_adj| canvas.scale = new_adj.value }
+
+  w.set_size_request(50, -1)
+  hbox.pack_start(w, false, false, 0)
+  w.show
+
+  scrolled_win = Gtk::ScrolledWindow.new
+  vbox.pack_start(scrolled_win, true, true, 0)
+  scrolled_win.show
+
+  # Create the canvas.
+  canvas.set_size_request(600, 450)
+  setup_canvas(canvas, units, units_name)
+
+  canvas.set_bounds(0, 0, 1000, 1000)
+  canvas.units = units
+  canvas.anchor = Gtk::ANCHOR_CENTER
+  canvas.show
+  
+  scrolled_win.add(canvas)
+
+  vbox
+end
+
+window = Gtk::Window.new(Gtk::Window::TOPLEVEL)
+window.set_default_size(640, 600)
+window.show
+window.signal_connect('delete_event') { Gtk.main_quit }
+
+notebook = Gtk::Notebook.new
+notebook.show
+window.add(notebook)
+
+notebook.append_page(create_canvas(Gtk::PaperSize::UNIT_PIXEL,  'pixels'),      Gtk::Label.new('Pixels'))
+notebook.append_page(create_canvas(Gtk::PaperSize::UNIT_POINTS, 'points'),      Gtk::Label.new('Points'))
+notebook.append_page(create_canvas(Gtk::PaperSize::UNIT_INCH,   'inches'),      Gtk::Label.new('Inches'))
+notebook.append_page(create_canvas(Gtk::PaperSize::UNIT_MM,     'millimeters'), Gtk::Label.new('Millimeters'))
+
+Gtk.main

data/sample/widgets-demo.rb

@@ -0,0 +1,197 @@
+#!/usr/bin/env ruby
+require 'goocanvas'
+
+num_added_widgets = 0
+added_widget_items = []
+canvas = nil
+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.signal_connect('focus_in_event') do
+    puts "#{color} received focus-in event"
+    # Note that this is only for testing. Setting item properties to indicate
+    # focus isn't a good idea for real apps, as there may be multiple views.
+    item.stroke_color = 'black'
+    false
+  end
+
+  item.signal_connect('focus_out_event') do
+    puts "#{color} received focus-out event"
+    # Note that this is only for testing. Setting item properties to indicate
+    # focus isn't a good idea for real apps, as there may be multiple views.
+    item.stroke_pattern = nil
+    false
+  end
+
+  item.signal_connect('button_press_event') do
+    puts "#{color} received button-press event"
+    item.canvas.grab_focus(item)
+    true
+  end
+
+  item.signal_connect('key_press_event') do
+    puts "#{color} received key-press event"
+    false
+  end
+end
+
+def add_button(hbox, button_name, &click_action)
+  w = Gtk::Button.new(button_name)
+  hbox.pack_start(w, false, false, 0)
+  w.show
+  w.signal_connect('clicked', &click_action)
+end
+
+# Create the window and widgets.
+window = Gtk::Window.new(Gtk::Window::TOPLEVEL)
+window.set_default_size(640, 600)
+window.show
+window.signal_connect('delete_event') { Gtk.main_quit }
+
+vbox = Gtk::VBox.new(false, 4)
+vbox.border_width = 4
+vbox.show
+window.add(vbox)
+
+hbox = Gtk::HBox.new(false, 4)
+vbox.pack_start(hbox, false, false, 0)
+hbox.show
+
+add_button(hbox, 'Add Widget') do
+  if num_added_widgets % 2 == 1
+    widget = Gtk::Label.new("Hello World")
+  else
+    widget = Gtk::Entry.new
+  end
+
+  root = canvas.root_item
+  witem = Goo::CanvasWidget.new(root, widget, num_added_widgets * 50, num_added_widgets * 50, 200, 50, nil)
+
+  added_widget_items.push(witem)
+  num_added_widgets += 1
+end
+
+add_button(hbox, 'Remove Widget') do
+  root = canvas.root_item
+  witem = added_widget_items.pop
+  if witem
+    root.remove_child(witem)
+    num_added_widgets -= 1
+  end
+end
+
+move_index = 0
+Moves = [
+  [ 50, 50, -1, -1 ],
+  [ 300, 100, -1, -1 ],
+  [ 200, 200, -1, -1 ],
+  [ 400, 100, -1, -1 ],
+]
+
+add_button(hbox, 'Move Widget') do
+  move_item.x = Moves[move_index][0]
+  move_item.y = Moves[move_index][1]
+  move_item.width = Moves[move_index][2]
+  move_item.height = Moves[move_index][3]
+  move_index = (move_index + 1) % 4
+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
+add_button(hbox, 'Change Anchor') do
+  puts "Setting anchor to: #{Gtk::AnchorType.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
+end
+
+add_button(hbox, 'Change Widget') do
+  witem = added_widget_items.last
+  if witem
+    if witem.widget.instance_of?(Gtk::Entry)
+      witem.widget = Gtk::Label.new("Hello World")
+    else
+      witem.widget = Gtk::Entry.new
+    end
+  end
+end
+
+hbox = Gtk::HBox.new(false, 4)
+vbox.pack_start(hbox, false, false, 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, 'Change Transform') { move_item.translate(25, 25) }
+
+scrolled_win = Gtk::ScrolledWindow.new
+scrolled_win.shadow_type = Gtk::SHADOW_IN
+scrolled_win.show
+vbox.pack_start(scrolled_win, true, true, 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)
+
+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)
+
+entry = Gtk::Entry.new
+move_item = Goo::CanvasWidget.new(root, entry, 50, 250, 200, 50, nil)
+
+entry = Gtk::Entry.new
+entry.text = "Size: -1 x -1"
+witem = Goo::CanvasWidget.new(root, entry, 50, 300, -1, -1, nil)
+
+entry = Gtk::Entry.new
+entry.text = "Size: 100 x -1"
+witem = Goo::CanvasWidget.new(root, entry, 50, 350, 100, -1, nil)
+
+# 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)
+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)
+
+# Create a vbox item with several child entry widgets to check focus traversal.
+vbox = Gtk::VBox.new(false, 4)
+
+entry = Gtk::Entry.new
+entry.show
+vbox.pack_start(entry, false, false, 0)
+
+entry = Gtk::Entry.new
+entry.show
+vbox.pack_start(entry, false, false, 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)
+
+# Create a few normal canvas items that take keyboard focus.
+create_focus_box(canvas, 110, 80, 50, 30, 'red')
+create_focus_box(canvas, 300, 160, 50, 30, 'orange')
+create_focus_box(canvas, 500, 50, 50, 30, 'yellow')
+
+canvas.show
+
+# Pass control to the GTK+ main event loop.
+Gtk.main