gtk2 2.2.4-x64-mingw32

data/sample/gtk-demo/images.rb

@@ -0,0 +1,197 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: images.rb,v 1.5 2006/04/08 12:30:03 mutoh Exp $
+=begin
+= Images
+
+Gtk::Image is used to display an image; the image can be in a number of formats.
+Typically, you load an image into a Gdk::Pixbuf, then display the pixbuf.
+
+This demo code shows some of the more obscure cases, in the simple
+case a call to Gtk::Image.new is all you need.
+
+If you want to put image data in your program as a String variable,
+use the make-inline-pixbuf program that comes with GTK+.
+This way you won't need to depend on loading external files, your
+application binary can be self-contained.
+=end
+require 'common'
+
+module Demo
+  class Images < BasicWindow
+    def initialize
+      @pixbuf_loader = nil
+      @load_timeout = 0
+      @image_stream = nil
+
+      super('Images')
+      signal_connect('destroy') do
+	cleanup_callback
+      end
+      
+      self.border_width = 8
+
+      vbox = Gtk::VBox.new(false, 8)
+      vbox.border_width = 8
+      add(vbox)
+
+      label = Gtk::Label.new
+      label.set_markup('<u>Image loaded from a file</u>')
+      vbox.pack_start(label, false, false, 0)
+      
+      frame = Gtk::Frame.new
+      frame.shadow_type = Gtk::SHADOW_IN
+      
+      # The alignment keeps the frame from growing when users resize
+      # the window
+      align = Gtk::Alignment.new(0.5, 0.5, 0, 0)
+      align.add(frame)
+      vbox.pack_start(align, false, false, 0)
+
+      # demo_find_file looks in the the current directory first,
+      # so you can run gtk-demo without installing GTK, then looks
+      # in the location where the file is installed.
+      pixbuf = nil
+      begin
+	filename = Demo.find_file('gtk-logo-rgb.gif')
+	pixbuf = Gdk::Pixbuf.new(filename)
+      rescue
+	# This code shows off error handling. You can just use
+	# Gtk::Image.new instead if you don't want to report
+	# errors to the user. If the file doesn't load when using
+	# Gtk::Image.new, a 'missing image' icon will
+	# be displayed instead.
+	dialog = Gtk::MessageDialog.new(self,
+					Gtk::Dialog::DESTROY_WITH_PARENT,
+					Gtk::MessageDialog::ERROR,
+					Gtk::MessageDialog::BUTTONS_CLOSE,
+					"Unable to open image file 'gtk-logo-rgb.gif': #{$1}")
+	
+	dialog.signal_connect('response') do |widget, data|
+	  widget.destroy
+	end
+	dialog.show
+      end
+      
+      image = Gtk::Image.new(pixbuf)
+      frame.add(image)
+
+
+      # Animation
+      label = Gtk::Label.new
+      label.set_markup('<u>Animation loaded from a file</u>')
+      vbox.pack_start(label, false, false, 0)
+      
+      frame = Gtk::Frame.new
+      frame.shadow_type = Gtk::SHADOW_IN
+      
+      # The alignment keeps the frame from growing when users resize
+      # the window
+      align = Gtk::Alignment.new(0.5, 0.5, 0, 0)
+      align.add(frame)
+      vbox.pack_start(align, false, false, 0)
+
+      filename = Demo.find_file('floppybuddy.gif')
+      image = Gtk::Image.new(filename)
+      frame.add(image)
+      
+
+      # Progressive
+      label = Gtk::Label.new
+      label.set_markup('<u>Progressive image loading</u>')
+      vbox.pack_start(label, false, false, 0)
+      
+      frame = Gtk::Frame.new(nil)
+      frame.shadow_type = Gtk::SHADOW_IN
+      
+      # The alignment keeps the frame from growing when users resize
+      # the window
+      align = Gtk::Alignment.new(0.5, 0.5, 0, 0)
+      align.add(frame)
+      vbox.pack_start(align, false, false, 0)
+
+      # Create an empty image for now; the progressive loader
+      # will create the pixbuf and fill it in.
+      image = Gtk::Image.new
+      frame.add(image)
+
+      start_progressive_loading(image)
+
+      # Sensitivity control
+      button = Gtk::ToggleButton.new('_Insensitive', true)
+      vbox.pack_start(button, false, false, 0)
+
+      button.signal_connect('toggled') do |widget|
+	vbox.children.each do |widget|
+	  if widget != button
+	    widget.sensitive = ! button.active?
+	  end
+	end
+      end
+    end
+
+    def start_progressive_loading(image)
+      @load_timeout = Gtk.timeout_add(150) do
+	progressive_timeout(image)
+      end
+    end
+
+    def progressive_timeout(image)
+      if @image_stream
+	buf = @image_stream.read(256)
+	
+	@pixbuf_loader.write(buf)
+	
+	if @image_stream.eof?
+	  @image_stream.close
+	  @image_stream = nil
+	  
+	  @pixbuf_loader.close
+	  @pixbuf_loader = nil
+	end
+      else
+	filename = Demo.find_file('alphatest.png')
+	@image_stream = File.open(filename, 'rb')
+
+	if @pixbuf_loader != nil
+	  @pixbuf_loader.close
+	  @pixbuf_loader = nil
+	end
+	
+	@pixbuf_loader = Gdk::PixbufLoader.new
+	
+	@pixbuf_loader.signal_connect('area_prepared') do |loader|
+	  pixbuf = loader.pixbuf
+
+	  # Avoid displaying random memory contents, since the pixbuf
+	  # isn't filled in yet.
+	  pixbuf.fill!(0xaaaaaaff)
+	  
+	  image.pixbuf = pixbuf
+	end
+	
+	@pixbuf_loader.signal_connect('area_updated') do
+	  # We know the pixbuf inside the Gtk::Image has changed, but the image
+	  # itself doesn't know this; so queue a redraw.  If we wanted to be
+	  # really efficient, we could use a drawing area or something
+	  # instead of a Gtk::Image, so we could control the exact position of
+	  # the pixbuf on the display, then we could queue a draw for only
+	  # the updated area of the image.
+	  image.queue_draw
+	end
+      end
+      
+      # leave timeout installed
+      return true
+    end
+
+    def cleanup_callback
+      @pixbuf_loader.close if @pixbuf_loader
+      @pixbuf_loader = nil
+      if @load_timeout != 0
+	Gtk.timeout_remove(@load_timeout)
+      end
+    end
+  end
+end

data/sample/gtk-demo/item_factory.rb

@@ -0,0 +1,94 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: item_factory.rb,v 1.4 2005/02/12 23:02:43 kzys Exp $
+=begin
+= Item Factory
+
+The Gtk::ItemFactory object allows the easy creation of menus
+from an array of descriptions of menu items.
+=end
+require 'common'
+
+module Demo
+  class ItemFactory < BasicWindow
+    def initialize
+      super('Item Factory')
+      
+      accel_group = Gtk::AccelGroup.new
+      item_factory = Gtk::ItemFactory.new(Gtk::ItemFactory::TYPE_MENU_BAR,
+					  '<main>', accel_group)
+      
+      add_accel_group(accel_group)
+      set_border_width(0)
+      ifactory_cb = proc do |data, widget|
+	puts "ItemFactory: activated \"#{Gtk::ItemFactory.path_from_widget(widget)}\""
+      end
+      menu_items = [
+	['/_File'],
+	['/File/tearoff1',
+	  '<Tearoff>', nil, nil, ifactory_cb],
+	['/File/_New',
+	  '<Item>', '<control>N', nil, ifactory_cb],
+	['/File/_Open',
+	  '<Item>', '<control>O', nil, ifactory_cb],
+	['/File/_Save',
+	  '<Item>', '<control>S', nil, ifactory_cb],
+	['/File/Save _As...',
+	  '<Item>', nil, nil, ifactory_cb],
+	['/File/sep1', '<Separator>'],
+	['/File/_Quit',
+	  '<Item>', '<control>Q', nil, ifactory_cb],
+	
+	['/_Preferences'],
+	['/_Preferences/_Color'],
+	[ '/_Preferences/Color/_Red',
+	  '<RadioItem>', nil, nil, ifactory_cb],
+	['/_Preferences/Color/_Green',
+	  '/Preferences/Color/Red', nil, nil, ifactory_cb],
+	['/_Preferences/Color/_Blue',
+	  '/Preferences/Color/Red', nil, nil, ifactory_cb],
+	['/_Preferences/_Shape'],
+	['/_Preferences/Shape/_Square',
+	  '<RadioItem>', nil, nil, ifactory_cb],
+	[ '/_Preferences/Shape/_Rectangle',
+	  '/Preferences/Shape/Square', nil, nil, ifactory_cb],
+	[ '/_Preferences/Shape/_Oval',
+	  '/Preferences/Shape/Rectangle', nil, nil, ifactory_cb],
+	
+	[ '/_Help', '<LastBranch>'],
+	[ '/Help/_About', '<Item>', nil, nil, ifactory_cb],
+      ]
+      item_factory.create_items(menu_items)
+
+      item_factory.get_item('/Preferences/Shape/Oval').set_active(true)
+      
+      box1 = Gtk::VBox.new(false, 0)
+      add(box1)
+
+      box1.pack_start(item_factory.get_widget('<main>'), false, false, 0)
+
+      label = Gtk::Label.new("Type\n<alt>\nto start")
+      label.set_size_request(200, 200)
+      label.set_alignment(0.5, 0.5)
+      box1.pack_start(label, true, true, 0)
+
+      separator = Gtk::HSeparator.new
+      box1.pack_start(separator)
+
+      
+      box2 = Gtk::VBox.new(false, 10)
+      box2.set_border_width(10)
+      box1.pack_start(box2, false, true, 0)
+
+      button = Gtk::Button.new('close')
+      # TODO: Need signal_connect_swapped?
+      button.signal_connect('clicked') do
+	quit
+      end
+      box2.pack_start(button, true, true, 0)
+      button.set_flags(Gtk::Widget::CAN_DEFAULT)
+      button.grab_default
+    end
+  end
+end

data/sample/gtk-demo/list_store.rb

@@ -0,0 +1,138 @@
+# Copyright (c) 2003-2005 Ruby-GNOME2 Project Team
+# This program is licenced under the same licence as Ruby-GNOME2.
+#
+# $Id: list_store.rb,v 1.5 2005/02/06 18:25:13 kzys Exp $
+=begin
+= Tree View/List Store
+
+The Gtk::ListStore is used to store data in list form, to be used
+later on by a Gtk::TreeView to display it. This demo builds a
+simple Gtk::ListStore and displays it. See the Stock Browser
+demo for a more advanced example.
+=end
+require 'common'
+
+module Demo
+  class ListStore < BasicWindow
+    Bug = Struct.new('Bug', :fixed, :number, :severity, :description)
+    COLUMN_FIXED, COLUMN_NUMBER, COLUMN_SEVERITY, COLUMN_DESCRIPTION,
+      NUM_COLUMNS = *(0..5).to_a
+    DATA = [
+      [ false, 60482, 'Normal',     'scrollable notebooks and hidden tabs' ],
+      [ false, 60620, 'Critical',   'gdk_window_clear_area (gdkwindow-win32.c) is not thread-safe' ],
+      [ false, 50214, 'Major',      'Xft support does not clean up correctly' ],
+      [ true,  52877, 'Major',      'GtkFileSelection needs a refresh method. ' ],
+      [ false, 56070, 'Normal',     "Can't click button after setting in sensitive" ],
+      [ true,  56355, 'Normal',     'GtkLabel - Not all changes propagate correctly' ],
+      [ false, 50055, 'Normal',     'Rework width/height computations for TreeView' ],
+      [ false, 58278, 'Normal',     "gtk_dialog_set_response_sensitive  doesn't work" ],
+      [ false, 55767, 'Normal',     'Getters for all setters' ],
+      [ false, 56925, 'Normal',     'Gtkcalender size' ],
+      [ false, 56221, 'Normal',     'Selectable label needs right-click copy menu' ],
+      [ true,  50939, 'Normal',     'Add shift clicking to GtkTextView' ],
+      [ false, 6112,  'Enhancement','netscape-like collapsable toolbars' ],
+      [ false, 1,     'Normal',     'First bug :=)' ],
+    ].collect do |ary|
+      Bug.new(*ary)
+    end
+    def initialize
+      super('GtkListStore demo')
+      self.border_width = 8
+
+      vbox = Gtk::VBox.new(false, 8)
+      add(vbox)
+
+      label = Gtk::Label.new('This is the bug list (note: not based on real data, it would be nice to have a nice ODBC interface to bugzilla or so, though).')
+      vbox.pack_start(label, false, false, 0)
+
+      sw = Gtk::ScrolledWindow.new(nil, nil)
+      sw.shadow_type = Gtk::SHADOW_ETCHED_IN
+      sw.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC)
+      vbox.pack_start(sw, true, true, 0)
+
+      # create tree model
+      model = create_model
+
+      # create tree view
+      treeview = Gtk::TreeView.new(model)
+      treeview.rules_hint = true
+      treeview.search_column = COLUMN_DESCRIPTION
+
+      sw.add(treeview)
+
+      # add columns to the tree view
+      add_columns(treeview)
+
+      set_default_size(280, 250)
+    end
+
+    def create_model
+      # create list store
+      store = Gtk::ListStore.new(TrueClass, Integer, String, String)
+
+      # add data to the list store
+      DATA.each do |bug|
+	iter = store.append
+	bug.each_with_index do |value, index|
+	  iter[index] = value
+	end
+      end
+      return store
+    end
+
+    def add_columns(treeview)
+      # column for fixed toggles
+      renderer = Gtk::CellRendererToggle.new
+      renderer.signal_connect('toggled') do |cell, path|
+	fixed_toggled(treeview.model, path)
+      end
+
+      column = Gtk::TreeViewColumn.new('Fixed?',
+				       renderer,
+				       'active' => COLUMN_FIXED)
+
+      # set this column to a fixed sizing (of 50 pixels)
+      column.sizing = Gtk::TreeViewColumn::FIXED
+      column.fixed_width = 50
+      treeview.append_column(column)
+
+      # column for bug numbers
+      renderer = Gtk::CellRendererText.new
+      column = Gtk::TreeViewColumn.new('Bug number',
+				       renderer,
+				       'text' => COLUMN_NUMBER)
+      column.set_sort_column_id(COLUMN_NUMBER)
+      treeview.append_column(column)
+
+      # column for severities
+      renderer = Gtk::CellRendererText.new
+      column = Gtk::TreeViewColumn.new('Severity',
+				       renderer,
+				       'text' => COLUMN_SEVERITY)
+      column.set_sort_column_id(COLUMN_SEVERITY)
+      treeview.append_column(column)
+
+      # column for description
+      renderer = Gtk::CellRendererText.new
+      column = Gtk::TreeViewColumn.new('Description',
+				       renderer,
+				       'text' => COLUMN_DESCRIPTION)
+      column.set_sort_column_id(COLUMN_DESCRIPTION)
+      treeview.append_column(column)
+    end
+
+    def fixed_toggled(model, path_str)
+      path = Gtk::TreePath.new(path_str)
+
+      # get toggled iter
+      iter = model.get_iter(path)
+      fixed =iter[COLUMN_FIXED]
+
+      # do something with the value
+      fixed ^= 1
+
+      # set new value
+      iter[COLUMN_FIXED] = fixed
+    end
+  end
+end

data/sample/gtk-demo/main.rb

@@ -0,0 +1,386 @@
+#! /usr/bin/env ruby
+=begin
+  main.rb - Main class of gtk-demo.
+
+  Copyright (c) 2003-2013 Ruby-GNOME2 Project Team
+  This program is licenced under the same licence as Ruby-GNOME2.
+
+  $Id: main.rb,v 1.20 2007/07/09 13:21:54 ggc Exp $
+=end
+
+require 'gtk2'
+
+$:.unshift(File.dirname(__FILE__))
+
+module Demo
+
+  class Main < Gtk::Window
+    TITLE_COLUMN, FILENAME_COLUMN, CLASS_COLUMN, ITALIC_COLUMN = 0, 1, 2, 3
+
+    def initialize
+      super()
+
+      @current_file = nil
+
+      @info_buffer = Gtk::TextBuffer.new
+      @source_buffer = Gtk::TextBuffer.new
+
+      set_title('Ruby/GTK+ Code Demos')
+      signal_connect('destroy') do
+        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
+
+      hbox = Gtk::HBox.new
+      add(hbox)
+
+      tree = create_tree
+      scrolled_window = Gtk::ScrolledWindow.new
+      scrolled_window.add(tree)
+      hbox.pack_start(scrolled_window, false, false, 0)
+
+      notebook = Gtk::Notebook.new
+      hbox.pack_start(notebook, true, true, 0)
+
+      notebook.append_page(create_text(@info_buffer, false),
+                           Gtk::Label.new('_Info', true))
+
+      notebook.append_page(create_text(@source_buffer, true),
+                           Gtk::Label.new('_Source', true))
+
+      @info_buffer.create_tag('title',
+                             {'font' => 'Sans 18'})
+
+      @source_buffer.create_tag('comment',
+                               {'foreground' => 'red'})
+      @source_buffer.create_tag('const',
+                               {'foreground' => 'ForestGreen'})
+      @source_buffer.create_tag('string',
+                               {
+                                  'foreground' => 'RosyBrown',
+                                  'weight' => Pango::FontDescription::WEIGHT_BOLD
+                                })
+      @source_buffer.create_tag('reserved',
+                               {'foreground' => 'purple'})
+    end
+
+    def script_info(path)
+      title = nil
+      klass = nil
+      depend = nil
+
+      file = File.open(path)
+      file.each do |ln|
+        if not title and ln =~ /^=\s+(.*)$/
+          title = $1
+          if title =~ /^(.*)\((.+?)\)$/
+            title = $1
+            depend = $2
+          end
+        elsif not klass and ln =~ /\s*class\s+([A-Z][A-Za-z0-9_]*)/
+          klass = $1
+        end
+
+        if title and klass
+          break
+        end
+      end
+
+      if not klass
+          raise "File not found: #{path}."
+      end
+
+      return title, klass.intern, depend
+    end
+
+    def generate_index
+      base_dir = File.dirname(__FILE__)
+      # Target scripts
+      scripts = Dir.glob(File.join(base_dir, '*.rb'))
+
+      # Generate index tree
+      children = {}
+      index = []
+
+      not_script_base_names = %w(common.rb main.rb)
+      scripts.each do |fn|
+        base_name = File.basename(fn)
+        next if not_script_base_names.include?(base_name)
+        title, klass, depend = script_info(fn)
+
+        if depend and not Gtk.const_defined?(depend)
+          next
+        end
+
+        if title =~ %r{^(.+?)/(.+)$}
+          parent = $1
+          child = $2
+
+          unless children[parent]
+            children[parent] = []
+            index += [[parent, nil, nil, []]]
+          end
+
+          children[parent] += [[child, fn, klass]]
+        else
+          index += [[title, fn, klass]]
+        end
+      end
+
+      # Sort children
+      children.each_key do |parent|
+        children[parent].sort! do |a, b|
+          a[0] <=> b[0]
+        end
+      end
+
+      # Expand children
+      index.collect! do |row|
+        if row[3]
+          row[3] = children[row[0]]
+        end
+
+        row
+      end
+
+      index.sort! do |a, b|
+        a[0] <=> b[0]
+      end
+
+      index
+    end
+
+    def create_tree
+      model = Gtk::TreeStore.new(String, String, String, TrueClass)
+
+      tree_view = Gtk::TreeView.new
+      tree_view.set_model(model)
+      selection = tree_view.selection
+
+      selection.set_mode(Gtk::SELECTION_BROWSE)
+      tree_view.set_size_request(200, -1)
+
+      append_children(model, generate_index)
+
+      cell = Gtk::CellRendererText.new
+      cell.style = Pango::FontDescription::STYLE_ITALIC
+      column = Gtk::TreeViewColumn.new("Widget (double click for demo)", cell,
+                                       {
+                                         'text' => TITLE_COLUMN,
+                                         'style_set' => ITALIC_COLUMN,
+                                       })
+
+      tree_view.append_column(column)
+
+      selection.signal_connect('changed') do |selection|
+        iter = selection.selected
+        load_file(iter.get_value(FILENAME_COLUMN)) if iter
+      end
+      tree_view.signal_connect('row_activated') do |tree_view, path, column|
+        row_activated_cb(tree_view.model, path)
+      end
+
+      tree_view.expand_all
+      return tree_view
+    end
+
+    def append_children(model, source, parent = nil)
+      source.each do |title, filename, klass, children|
+        iter = model.append(parent)
+
+        [title, filename, klass].each_with_index do |value, i|
+          if value
+            iter.set_value(i, value)
+          end
+        end
+        iter.set_value(ITALIC_COLUMN, false)
+
+        if children
+          append_children(model, children, iter)
+        end
+      end
+    end
+
+    def row_activated_cb(model, path)
+      iter = model.get_iter(path)
+      iter.set_value(ITALIC_COLUMN, true)
+
+      lib = iter.get_value(FILENAME_COLUMN)
+      if lib
+        require(lib)
+
+        klass = Demo.const_get(iter.get_value(CLASS_COLUMN))
+        window = klass.new
+        window.signal_connect('destroy') do
+          iter.set_value(ITALIC_COLUMN, false)
+        end
+        window.show_all
+        @window = window
+      end
+    end
+
+    def create_text(buffer, is_source)
+      scrolled_window = Gtk::ScrolledWindow.new
+      scrolled_window.set_policy(Gtk::POLICY_AUTOMATIC,
+                                 Gtk::POLICY_AUTOMATIC)
+      scrolled_window.set_shadow_type(Gtk::SHADOW_IN)
+
+      text_view = Gtk::TextView.new
+
+      text_view.set_buffer(buffer)
+      text_view.set_editable(false)
+      text_view.set_cursor_visible(false)
+
+      scrolled_window.add(text_view)
+
+      if is_source
+        font_desc = Pango::FontDescription.new('Monospace 12')
+        text_view.modify_font(font_desc)
+
+        text_view.set_wrap_mode(Gtk::TextTag::WRAP_NONE)
+      else
+        text_view.set_wrap_mode(Gtk::TextTag::WRAP_WORD)
+        text_view.set_pixels_above_lines(2)
+        text_view.set_pixels_below_lines(2)
+      end
+
+      return scrolled_window
+    end
+
+    def fontify(start_iter = @source_buffer.start_iter,
+                end_iter = @source_buffer.end_iter)
+      str = @source_buffer.get_text(start_iter, end_iter, true)
+
+      tokenizer = RubyTokonizer.new
+      tokenizer.tokenize(str, start_iter.offset) do |tag, start, last|
+        @source_buffer.apply_tag(tag.to_s,
+                                 @source_buffer.get_iter_at_offset(start),
+                                 @source_buffer.get_iter_at_offset(last))
+      end
+    end
+
+
+    def load_file(filename)
+      if filename == @current_file
+        return
+      end
+
+      @info_buffer.delete(*@info_buffer.bounds)
+
+      @source_buffer.delete(*@source_buffer.bounds)
+
+      file = begin
+               File.open(filename)
+             rescue
+               $stderr.puts "Cannot open: #{$!}" if $DEBUG
+               return
+             end
+      start = @info_buffer.get_iter_at_offset(0)
+      state = :before_header
+
+      file.each do |line|
+        case state
+        when :before_header
+          if line =~ /^=begin$/
+            state = :in_header
+          end
+        when :in_header
+          if line =~ /^=end$/
+            state = :body
+            start = @source_buffer.get_iter_at_offset(0)
+          elsif line =~ /^=\s+(.*)$/
+            title = $1
+            title.gsub!(/\s*\(.*\)$/, '') # Delete depend field
+
+            last = start
+
+            @info_buffer.insert(last, title)
+            start = last.clone
+
+            start.backward_chars(title.length)
+            @info_buffer.apply_tag('title', start, last)
+
+            start = last
+          else
+            @info_buffer.insert(start, line)
+          end
+        when :body  # Reading program body
+          @source_buffer.insert(start, line)
+        end
+      end
+
+      fontify
+
+      @current_file = filename
+    end
+  end
+
+  class RubyTokonizer
+    RESERVED_WORDS = %w(begin end module class def if then else while unless do case when require yield)
+    RESERVED_WORDS_PATTERN = Regexp.compile(/(^|\s+)(#{RESERVED_WORDS.collect do |pat| Regexp.quote(pat) end.join('|')})(\s+|$)/)
+
+    def tokenize(str, index = 0)
+      until str.empty?
+        tag = nil
+
+        case str
+        when /".+?"/, /'.+?'/
+          tag = :string
+        when /#.*$/
+          tag = :comment
+        when RESERVED_WORDS_PATTERN
+          tag = :reserved
+        when /[A-Z][A-Za-z0-9_]+/
+          tag = :const
+        end
+
+        if tag
+          tokenize($~.pre_match, index) do |*args|
+            yield(*args)
+          end
+          yield(tag, index + $~.begin(0), index + $~.end(0))
+          index += (str.length - $~.post_match.length)
+          str = $~.post_match
+        else
+          index += str.length
+          str = ''
+        end
+      end
+    end
+  end
+end
+
+
+target = ARGV.shift
+if target
+  Demo::INDEX.each do |title, filename, klass_symbol, children|
+    if target == filename or target == klass_symbol.id2name
+      require filename
+
+      window = Demo.const_get(klass_symbol).new
+      window.show_all
+
+      class << window
+        def quit
+          Gtk.main_quit
+        end
+      end
+
+      break
+    end
+  end
+else
+  main = Demo::Main.new
+  main.set_default_size(600, 400)
+  main.show_all
+end
+
+Gtk.main