This commit was manufactured by cvs2svn to create branch 'ruby_1_8'.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8@6238 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

ext/tcltklib/demo/lines3.rb

@@ -0,0 +1,54 @@
+#! /usr/local/bin/ruby
+
+require "tk"
+
+def drawlines()
+  print Time.now, "\n"
+
+  for j in 0 .. 99
+    print "*"
+    $stdout.flush
+    if (j & 1) != 0
+      col = "blue"
+    else
+      col = "red"
+    end
+    for i in 0 .. 99
+#      $a.create(TkcLine, i, 0, 0, 500 - i, "fill"=>col)
+    end
+  end
+
+  print Time.now, "\n"
+
+  for j in 0 .. 99
+    print "*"
+    $stdout.flush
+    if (j & 1) != 0
+      col = "blue"
+    else
+      col = "red"
+    end
+    for i in 0 .. 99
+      $a.create(TkcLine, i, 0, 0, 500 - i, "fill"=>col)
+    end
+  end
+
+  print Time.now, "\n"
+#  Tk.root.destroy
+end
+
+$a = TkCanvas.new{
+  height(500)
+  width(500)
+}
+
+$b = TkButton.new{
+  text("draw")
+  command(proc{drawlines()})
+}
+
+TkPack.configure($a, $b, {"side"=>"left"})
+
+Tk.mainloop
+
+# eof

ext/tcltklib/demo/lines4.rb

@@ -0,0 +1,54 @@
+#! /usr/local/bin/ruby
+
+require "tk"
+
+def drawlines()
+  print Time.now, "\n"
+
+  for j in 0 .. 99
+    print "*"
+    $stdout.flush
+    if (j & 1) != 0
+      col = "blue"
+    else
+      col = "red"
+    end
+    for i in 0 .. 99
+#      TkCore::INTERP.__invoke($a.path, "create", "line", i.to_s, '0', '0', (500 - i).to_s, "-fill", col)
+    end
+  end
+
+  print Time.now, "\n"
+
+  for j in 0 .. 99
+    print "*"
+    $stdout.flush
+    if (j & 1) != 0
+      col = "blue"
+    else
+      col = "red"
+    end
+    for i in 0 .. 99
+      TkCore::INTERP.__invoke($a.path, "create", "line", i.to_s, '0', '0', (500 - i).to_s, "-fill", col)
+    end
+  end
+
+  print Time.now, "\n"
+#  Tk.root.destroy
+end
+
+$a = TkCanvas.new{
+  height(500)
+  width(500)
+}
+
+$b = TkButton.new{
+  text("draw")
+  command(proc{drawlines()})
+}
+
+TkPack.configure($a, $b, {"side"=>"left"})
+
+Tk.mainloop
+
+# eof

ext/tk/README.fork

@@ -0,0 +1,29 @@
+Ruby/Tk does NOT support forking the process on which Tk interpreter
+is running (unless NEVER control Tk interpreter under the forked child 
+process). In the library 'tk.rb', a Tk interpreter is initialized. 
+Therefore, if you want running Tk under a child process, please call
+"require 'tk'" in the child process. 
+
+For example, the following sample1 will NOT work, and sample2 will
+work properly.
+
+---<sample1: NOT work>---------------------------------------
+require 'tk'  ## init Tk interpreter under parent process
+
+exit! if fork ## exit parent process
+
+## child process
+TkButton.new(:text=>'QUIT', :command=>proc{exit}).pack
+Tk.mainloop
+-------------------------------------------------------------
+
+---<sample2: will work>--------------------------------------
+exit! if fork ## exit main process
+
+## child process
+require 'tk'  ## init Tk interpreter under child process
+TkButton.new(:text=>'QUIT', :command=>proc{exit}).pack
+Tk.mainloop
+-------------------------------------------------------------
+
+                                         2004/04/20  Hidetoshi NAGAI

ext/tk/lib/tk/after.rb

@@ -0,0 +1,6 @@
+#
+#   tk/after.rb : methods for Tcl/Tk after command
+#
+#   $Id$
+#
+require 'tk/timer'

ext/tk/lib/tk/autoload.rb

@@ -0,0 +1,181 @@
+#
+#  autoload
+#
+
+#######################
+#  geometry manager
+autoload :TkGrid,             'tk/grid'
+def TkGrid(*args); TkGrid.configure(*args); end
+
+autoload :TkPack,             'tk/pack'
+def TkPack(*args); TkPack.configure(*args); end
+
+autoload :TkPlace,            'tk/place'
+def TkPlace(*args); TkPlace.configure(*args); end
+
+
+#######################
+# others
+autoload :TkBgError,          'tk/bgerror'
+
+autoload :TkBindTag,          'tk/bindtag'
+autoload :TkBindTagAll,       'tk/bindtag'
+autoload :TkDatabaseClass,    'tk/bindtag'
+
+autoload :TkButton,           'tk/button'
+
+autoload :TkConsole,          'tk/console'
+
+autoload :TkCanvas,           'tk/canvas'
+
+autoload :TkcTagAccess,       'tk/canvastag'
+autoload :TkcTag,             'tk/canvastag'
+autoload :TkcTagString,       'tk/canvastag'
+autoload :TkcNamedTag,        'tk/canvastag'
+autoload :TkcTagAll,          'tk/canvastag'
+autoload :TkcTagCurrent,      'tk/canvastag'
+autoload :TkcTagGroup,        'tk/canvastag'
+
+autoload :TkCheckButton,      'tk/checkbutton'
+autoload :TkCheckbutton,      'tk/checkbutton'
+
+autoload :TkClipboard,        'tk/clipboard'
+
+autoload :TkComposite,        'tk/composite'
+
+autoload :TkConsole,          'tk/console'
+
+autoload :TkDialog,           'tk/dialog'
+autoload :TkDialog2,          'tk/dialog'
+autoload :TkWarning,          'tk/dialog'
+autoload :TkWarning2,         'tk/dialog'
+
+autoload :TkEntry,            'tk/entry'
+
+autoload :TkEvent,            'tk/event'
+
+autoload :TkFont,             'tk/font'
+autoload :TkTreatTagFont,     'tk/font'
+
+autoload :TkFrame,            'tk/frame'
+
+autoload :TkImage,            'tk/image'
+autoload :TkBitmapImage,      'tk/image'
+autoload :TkPhotoImage,       'tk/image'
+
+autoload :TkTreatItemFont,    'tk/itemfont'
+
+autoload :TkKinput,           'tk/kinput'
+
+autoload :TkLabel,            'tk/label'
+
+autoload :TkLabelFrame,       'tk/labelframe'
+autoload :TkLabelframe,       'tk/labelframe'
+
+autoload :TkListbox,          'tk/listbox'
+
+autoload :TkMacResource,      'tk/macpkg'
+
+autoload :TkMenu,             'tk/menu'
+autoload :TkMenuClone,        'tk/menu'
+autoload :TkSystemMenu,       'tk/menu'
+autoload :TkSysMenu_Help,     'tk/menu'
+autoload :TkSysMenu_System,   'tk/menu'
+autoload :TkSysMenu_Apple,    'tk/menu'
+autoload :TkMenubutton,       'tk/menu'
+autoload :TkOptionMenubutton, 'tk/menu'
+
+autoload :TkMenubar,          'tk/menubar'
+
+autoload :TkMessage,          'tk/message'
+
+autoload :TkManageFocus,      'tk/mngfocus'
+
+autoload :TkMsgCatalog,       'tk/msgcat'
+autoload :TkMsgCat,           'tk/msgcat'
+
+autoload :TkNamespace,        'tk/namespace'
+
+autoload :TkOptionDB,         'tk/optiondb'
+autoload :TkOption,           'tk/optiondb'
+autoload :TkResourceDB,       'tk/optiondb'
+
+autoload :TkPackage,          'tk/package'
+
+autoload :TkPalette,          'tk/palette'
+
+autoload :TkPanedWindow,      'tk/panedwindow'
+autoload :TkPanedwindow,      'tk/panedwindow'
+
+autoload :TkRadioButton,      'tk/radiobutton'
+autoload :TkRadiobutton,      'tk/radiobutton'
+
+autoload :TkRoot,             'tk/root'
+
+autoload :TkScale,            'tk/scale'
+
+autoload :TkScrollbar,        'tk/scrollbar'
+autoload :TkXScrollbar,       'tk/scrollbar'
+autoload :TkYScrollbar,       'tk/scrollbar'
+
+autoload :TkScrollbox,        'tk/scrollbox'
+
+autoload :TkSelection,        'tk/selection'
+
+autoload :TkSpinbox,          'tk/spinbox'
+
+autoload :TkTreatTagFont,     'tk/tagfont'
+
+autoload :TkText,             'tk/text'
+
+autoload :TkTextImage,        'tk/textimage'
+
+autoload :TkTextMark,         'tk/textmark'
+autoload :TkTextNamedMark,    'tk/textmark'
+autoload :TkTextMarkInsert,   'tk/textmark'
+autoload :TkTextMarkCurrent,  'tk/textmark'
+autoload :TkTextMarkAnchor,   'tk/textmark'
+
+autoload :TkTextTag,          'tk/texttag'
+autoload :TkTextNamedTag,     'tk/texttag'
+autoload :TkTextTagSel,       'tk/texttag'
+
+autoload :TkTextWindow,       'tk/textwindow'
+
+autoload :TkAfter,            'tk/timer'
+autoload :TkTimer,            'tk/timer'
+
+autoload :TkToplevel,         'tk/toplevel'
+
+autoload :TkTextWin,          'tk/txtwin_abst'
+
+autoload :TkValidation,       'tk/validation'
+autoload :TkVariable,         'tk/variable'
+autoload :TkVarAccess,        'tk/variable'
+
+autoload :TkVirtualEvent,     'tk/virtevent'
+
+autoload :TkWinfo,            'tk/winfo'
+
+autoload :TkWinDDE,           'tk/winpkg'
+autoload :TkWinRegistry,      'tk/winpkg'
+
+autoload :TkXIM,              'tk/xim'
+
+
+#######################
+# sub-module of Tk
+module Tk
+  autoload :Clock,            'tk/clock'
+  autoload :Scrollable,       'tk/scrollable'
+  autoload :Wm,               'tk/wm'
+
+  autoload :EncodedString,    'tk/encodedstr'
+  def Tk.EncodedString(str, enc = nil); Tk::EncodedString.new(str, enc); end
+
+  autoload :BinaryString,     'tk/encodedstr'
+  def Tk.BinaryString(str); Tk::BinaryString.new(str); end
+
+  autoload :UTF8_String,      'tk/encodedstr'
+  def Tk.UTF8_String(str); Tk::UTF8_String.new(str); end
+end

ext/tk/lib/tk/bgerror.rb

@@ -0,0 +1,29 @@
+#
+#  tkbgerror -- bgerror ( tkerror ) module
+#                     1998/07/16 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+require 'tk'
+
+module TkBgError
+  extend Tk
+
+  TkCommandNames = ['bgerror'.freeze].freeze
+
+  def bgerror(message)
+    tk_call('bgerror', message)
+  end
+  alias tkerror bgerror
+  alias show bgerror
+  module_function :bgerror, :tkerror, :show
+
+  def set_handler(hdlr = Proc.new) #==> handler :: proc{|msg| ...body... }
+    tk_call('proc', 'bgerror', 'msg', install_cmd(hdlr) + ' $msg')
+  end
+  def set_default
+    begin
+      tk_call('rename', 'bgerror', '')
+    rescue RuntimeError
+    end
+  end
+  module_function :set_handler, :set_default
+end

ext/tk/lib/tk/bindtag.rb

@@ -0,0 +1,78 @@
+#
+# tk/bind.rb : control event binding
+#
+require 'tk'
+
+class TkBindTag
+  include TkBindCore
+
+  #BTagID_TBL = {}
+  BTagID_TBL = TkCore::INTERP.create_table
+  Tk_BINDTAG_ID = ["btag".freeze, "00000".taint].freeze
+
+  TkCore::INTERP.init_ip_env{ BTagID_TBL.clear }
+
+  def TkBindTag.id2obj(id)
+    BTagID_TBL[id]? BTagID_TBL[id]: id
+  end
+
+  def TkBindTag.new_by_name(name, *args, &b)
+    return BTagID_TBL[name] if BTagID_TBL[name]
+    self.new(*args, &b).instance_eval{
+      BTagID_TBL.delete @id
+      @id = name
+      BTagID_TBL[@id] = self
+    }
+  end
+
+  def initialize(*args, &b)
+    @id = Tk_BINDTAG_ID.join('')
+    Tk_BINDTAG_ID[1].succ!
+    BTagID_TBL[@id] = self
+    bind(*args, &b) if args != []
+  end
+
+  ALL = self.new_by_name('all')
+
+  def name
+    @id
+  end
+
+  def to_eval
+    @id
+  end
+
+  def inspect
+    #Kernel.format "#<TkBindTag: %s>", @id
+    '#<TkBindTag: ' + @id + '>'
+  end
+end
+
+
+class TkBindTagAll<TkBindTag
+  def TkBindTagAll.new(*args, &b)
+    $stderr.puts "Warning: TkBindTagALL is obsolete. Use TkBindTag::ALL\n"
+
+    TkBindTag::ALL.bind(*args, &b) if args != []
+    TkBindTag::ALL
+  end
+end
+
+
+class TkDatabaseClass<TkBindTag
+  def self.new(name, *args, &b)
+    return BTagID_TBL[name] if BTagID_TBL[name]
+    super(name, *args, &b)
+  end
+
+  def initialize(name, *args, &b)
+    @id = name
+    BTagID_TBL[@id] = self
+    bind(*args, &b) if args != []
+  end
+
+  def inspect
+    #Kernel.format "#<TkDatabaseClass: %s>", @id
+    '#<TkDatabaseClass: ' + @id + '>'
+  end
+end

ext/tk/lib/tk/button.rb

@@ -0,0 +1,27 @@
+#
+# tk/button.rb : treat button widget
+#
+require 'tk'
+require 'tk/label'
+
+class TkButton<TkLabel
+  TkCommandNames = ['button'.freeze].freeze
+  WidgetClassName = 'Button'.freeze
+  WidgetClassNames[WidgetClassName] = self
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('button', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('button', @path)
+    end
+  end
+  private :create_self
+
+  def invoke
+    _fromUTF8(tk_send_without_enc('invoke'))
+  end
+  def flash
+    tk_send_without_enc('flash')
+    self
+  end
+end

ext/tk/lib/tk/canvas.rb

@@ -0,0 +1,697 @@
+#
+#		tk/canvas.rb - Tk canvas classes
+#			$Date$
+#			by Yukihiro Matsumoto <matz@caelum.co.jp>
+#			$Date$
+#			by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+require 'tk'
+require 'tk/canvastag'
+require 'tk/itemfont'
+require 'tk/scrollable'
+
+module TkTreatCItemFont
+  include TkTreatItemFont
+
+  ItemCMD = ['itemconfigure'.freeze, TkComm::None].freeze
+  def __conf_cmd(idx)
+    ItemCMD[idx]
+  end
+
+  def __item_pathname(tagOrId)
+    if tagOrId.kind_of?(TkcItem) || tagOrId.kind_of?(TkcTag)
+      self.path + ';' + tagOrId.id.to_s
+    else
+      self.path + ';' + tagOrId.to_s
+    end
+  end
+
+  private :__conf_cmd, :__item_pathname
+end
+
+class TkCanvas<TkWindow
+  include TkTreatCItemFont
+  include Scrollable
+
+  TkCommandNames = ['canvas'.freeze].freeze
+  WidgetClassName = 'Canvas'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+  def __destroy_hook__
+    TkcItem::CItemID_TBL.delete(@path)
+  end
+
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('canvas', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('canvas', @path)
+    end
+  end
+  private :create_self
+
+  def tagid(tag)
+    if tag.kind_of?(TkcItem) || tag.kind_of?(TkcTag)
+      tag.id
+    else
+      tag
+    end
+  end
+  private :tagid
+
+
+  def create(type, *args)
+    # create a canvas item without creating a TkcItem object
+    if type.kind_of?(TkcItem)
+      fail ArgumentError, 'TkcItem class expected for 1st argument'
+    end
+    type.create(@path, *args)
+  end
+
+
+  def addtag(tag, mode, *args)
+    tk_send_without_enc('addtag', tagid(tag), mode, *args)
+    self
+  end
+  def addtag_above(tagOrId, target)
+    addtag(tagOrId, 'above', tagid(target))
+  end
+  def addtag_all(tagOrId)
+    addtag(tagOrId, 'all')
+  end
+  def addtag_below(tagOrId, target)
+    addtag(tagOrId, 'below', tagid(target))
+  end
+  def addtag_closest(tagOrId, x, y, halo=None, start=None)
+    addtag(tagOrId, 'closest', x, y, halo, start)
+  end
+  def addtag_enclosed(tagOrId, x1, y1, x2, y2)
+    addtag(tagOrId, 'enclosed', x1, y1, x2, y2)
+  end
+  def addtag_overlapping(tagOrId, x1, y1, x2, y2)
+    addtag(tagOrId, 'overlapping', x1, y1, x2, y2)
+  end
+  def addtag_withtag(tagOrId, tag)
+    addtag(tagOrId, 'withtag', tagid(tag))
+  end
+
+  def bbox(tagOrId, *tags)
+    list(tk_send_without_enc('bbox', tagid(tagOrId), 
+			     *tags.collect{|t| tagid(t)}))
+  end
+
+  def itembind(tag, context, cmd=Proc.new, args=nil)
+    _bind([path, "bind", tagid(tag)], context, cmd, args)
+    self
+  end
+
+  def itembind_append(tag, context, cmd=Proc.new, args=nil)
+    _bind_append([path, "bind", tagid(tag)], context, cmd, args)
+    self
+  end
+
+  def itembind_remove(tag, context)
+    _bind_remove([path, "bind", tagid(tag)], context)
+    self
+  end
+
+  def itembindinfo(tag, context=nil)
+    _bindinfo([path, "bind", tagid(tag)], context)
+  end
+
+  def canvasx(screen_x, *args)
+    #tk_tcl2ruby(tk_send_without_enc('canvasx', screen_x, *args))
+    number(tk_send_without_enc('canvasx', screen_x, *args))
+  end
+  def canvasy(screen_y, *args)
+    #tk_tcl2ruby(tk_send_without_enc('canvasy', screen_y, *args))
+    number(tk_send_without_enc('canvasy', screen_y, *args))
+  end
+
+  def coords(tag, *args)
+    if args == []
+      tk_split_list(tk_send_without_enc('coords', tagid(tag)))
+    else
+      tk_send_without_enc('coords', tagid(tag), *(args.flatten))
+    end
+  end
+
+  def dchars(tag, first, last=None)
+    tk_send_without_enc('dchars', tagid(tag), 
+			_get_eval_enc_str(first), _get_eval_enc_str(last))
+    self
+  end
+
+  def delete(*args)
+    if TkcItem::CItemID_TBL[self.path]
+      find('withtag', *args).each{|item| 
+	TkcItem::CItemID_TBL[self.path].delete(item.id)
+      }
+    end
+    tk_send_without_enc('delete', *args.collect{|t| tagid(t)})
+    self
+  end
+  alias remove delete
+
+  def dtag(tag, tag_to_del=None)
+    tk_send_without_enc('dtag', tagid(tag), tag_to_del)
+    self
+  end
+
+  def find(mode, *args)
+    list(tk_send_without_enc('find', mode, *args)).collect!{|id| 
+      TkcItem.id2obj(self, id)
+    }
+  end
+  def find_above(target)
+    find('above', tagid(target))
+  end
+  def find_all
+    find('all')
+  end
+  def find_below(target)
+    find('below', tagid(target))
+  end
+  def find_closest(x, y, halo=None, start=None)
+    find('closest', x, y, halo, start)
+  end
+  def find_enclosed(x1, y1, x2, y2)
+    find('enclosed', x1, y1, x2, y2)
+  end
+  def find_overlapping(x1, y1, x2, y2)
+    find('overlapping', x1, y1, x2, y2)
+  end
+  def find_withtag(tag)
+    find('withtag', tag)
+  end
+
+  def itemfocus(tagOrId=nil)
+    if tagOrId
+      tk_send_without_enc('focus', tagid(tagOrId))
+      self
+    else
+      ret = tk_send_without_enc('focus')
+      if ret == ""
+	nil
+      else
+	TkcItem.id2obj(self, ret)
+      end
+    end
+  end
+
+  def gettags(tagOrId)
+    list(tk_send_without_enc('gettags', tagid(tagOrId))).collect{|tag|
+      TkcTag.id2obj(self, tag)
+    }
+  end
+
+  def icursor(tagOrId, index)
+    tk_send_without_enc('icursor', tagid(tagOrId), index)
+    self
+  end
+
+  def index(tagOrId, index)
+    number(tk_send_without_enc('index', tagid(tagOrId), index))
+  end
+
+  def insert(tagOrId, index, string)
+    tk_send_without_enc('insert', tagid(tagOrId), index, 
+			_get_eval_enc_str(string))
+    self
+  end
+
+  def itemcget(tagOrId, option)
+    case option.to_s
+    when 'dash', 'activedash', 'disableddash'
+      conf = tk_send_without_enc('itemcget', tagid(tagOrId), "-#{option}")
+      if conf =~ /^[0-9]/
+	list(conf)
+      else
+	conf
+      end
+    when 'text', 'label', 'show', 'data', 'file', 'maskdata', 'maskfile'
+      _fromUTF8(tk_send_without_enc('itemcget', tagid(tagOrId), "-#{option}"))
+    when 'font', 'kanjifont'
+      #fnt = tk_tcl2ruby(tk_send('itemcget', tagid(tagOrId), "-#{option}"))
+      fnt = tk_tcl2ruby(_fromUTF8(tk_send_with_enc('itemcget', tagid(tagOrId), '-font')))
+      unless fnt.kind_of?(TkFont)
+	fnt = tagfontobj(tagid(tagOrId), fnt)
+      end
+      if option.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
+	# obsolete; just for compatibility
+	fnt.kanji_font
+      else
+	fnt
+      end
+    else
+      tk_tcl2ruby(_fromUTF8(tk_send_without_enc('itemcget', tagid(tagOrId), 
+						"-#{option}")))
+    end
+  end
+
+  def itemconfigure(tagOrId, key, value=None)
+    if key.kind_of? Hash
+      key = _symbolkey2str(key)
+      if ( key['font'] || key['kanjifont'] \
+	  || key['latinfont'] || key['asciifont'] )
+	tagfont_configure(tagid(tagOrId), key.dup)
+      else
+	_fromUTF8(tk_send_without_enc('itemconfigure', tagid(tagOrId), 
+				      *hash_kv(key, true)))
+      end
+
+    else
+      if ( key == 'font' || key == :font || 
+           key == 'kanjifont' || key == :kanjifont || 
+	   key == 'latinfont' || key == :latinfont || 
+           key == 'asciifont' || key == :asciifont )
+	if value == None
+	  tagfontobj(tagid(tagOrId))
+	else
+	  tagfont_configure(tagid(tagOrId), {key=>value})
+	end
+      else
+	_fromUTF8(tk_send_without_enc('itemconfigure', tagid(tagOrId), 
+				      "-#{key}", _get_eval_enc_str(value)))
+      end
+    end
+    self
+  end
+#  def itemconfigure(tagOrId, key, value=None)
+#    if key.kind_of? Hash
+#      tk_send 'itemconfigure', tagid(tagOrId), *hash_kv(key)
+#    else
+#      tk_send 'itemconfigure', tagid(tagOrId), "-#{key}", value
+#    end
+#  end
+#  def itemconfigure(tagOrId, keys)
+#    tk_send 'itemconfigure', tagid(tagOrId), *hash_kv(keys)
+#  end
+
+  def itemconfiginfo(tagOrId, key=nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+	case key.to_s
+	when 'dash', 'activedash', 'disableddash'
+	  conf = tk_split_simplelist(tk_send_without_enc('itemconfigure', tagid(tagOrId), "-#{key}"))
+	  if conf[3] && conf[3] =~ /^[0-9]/
+	    conf[3] = list(conf[3])
+	  end
+	  if conf[4] && conf[4] =~ /^[0-9]/
+	    conf[4] = list(conf[4])
+	  end
+	when 'text', 'label', 'show', 'data', 'file', 'maskdata', 'maskfile'
+	  conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('itemconfigure', tagid(tagOrId), "-#{key}")))
+	when 'font', 'kanjifont'
+	  conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('itemconfigure', tagid(tagOrId),"-#{key}")))
+	  conf[4] = tagfont_configinfo(tagid(tagOrId), conf[4])
+	else
+	  conf = tk_split_list(_fromUTF8(tk_send_without_enc('itemconfigure', tagid(tagOrId), "-#{key}")))
+	end
+	conf[0] = conf[0][1..-1]
+	conf
+      else
+	ret = tk_split_simplelist(_fromUTF8(tk_send_without_enc('itemconfigure', tagid(tagOrId)))).collect{|conflist|
+	  conf = tk_split_simplelist(conflist)
+	  conf[0] = conf[0][1..-1]
+	  case conf[0]
+	  when 'text', 'label', 'show', 'data', 'file', 'maskdata', 'maskfile'
+	  when 'dash', 'activedash', 'disableddash'
+	    if conf[3] && conf[3] =~ /^[0-9]/
+	      conf[3] = list(conf[3])
+	    end
+	    if conf[4] && conf[4] =~ /^[0-9]/
+	      conf[4] = list(conf[4])
+	    end
+	  else
+	    if conf[3]
+	      if conf[3].index('{')
+		conf[3] = tk_split_list(conf[3]) 
+	      else
+		conf[3] = tk_tcl2ruby(conf[3]) 
+	      end
+	    end
+	    if conf[4]
+	      if conf[4].index('{')
+		conf[4] = tk_split_list(conf[4]) 
+	      else
+		conf[4] = tk_tcl2ruby(conf[4]) 
+	      end
+	    end
+	  end
+	  conf[1] = conf[1][1..-1] if conf.size == 2 # alias info
+	  conf
+	}
+	fontconf = ret.assoc('font')
+	if fontconf
+	  ret.delete_if{|item| item[0] == 'font' || item[0] == 'kanjifont'}
+	  fontconf[4] = tagfont_configinfo(tagid(tagOrId), fontconf[4])
+	  ret.push(fontconf)
+	else
+	  ret
+	end
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+	case key.to_s
+	when 'dash', 'activedash', 'disableddash'
+	  conf = tk_split_simplelist(tk_send_without_enc('itemconfigure', 
+							 tagid(tagOrId), 
+							 "-#{key}"))
+	  if conf[3] && conf[3] =~ /^[0-9]/
+	    conf[3] = list(conf[3])
+	  end
+	  if conf[4] && conf[4] =~ /^[0-9]/
+	    conf[4] = list(conf[4])
+	  end
+	when 'text', 'label', 'show', 'data', 'file', 'maskdata', 'maskfile'
+	  conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('itemconfigure', tagid(tagOrId), "-#{key}")))
+	when 'font', 'kanjifont'
+	  conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('itemconfigure', tagid(tagOrId),"-#{key}")))
+	  conf[4] = tagfont_configinfo(tagid(tagOrId), conf[4])
+	else
+	  conf = tk_split_list(_fromUTF8(tk_send_without_enc('itemconfigure', tagid(tagOrId), "-#{key}")))
+	end
+	key = conf.shift[1..-1]
+	{ key => conf }
+      else
+	ret = {}
+	tk_split_simplelist(_fromUTF8(tk_send_without_enc('itemconfigure', tagid(tagOrId)))).each{|conflist|
+	  conf = tk_split_simplelist(conflist)
+	  key = conf.shift[1..-1]
+	  case key
+	  when 'text', 'label', 'show', 'data', 'file', 'maskdata', 'maskfile'
+	  when 'dash', 'activedash', 'disableddash'
+	    if conf[2] && conf[2] =~ /^[0-9]/
+	      conf[2] = list(conf[2])
+	    end
+	    if conf[3] && conf[3] =~ /^[0-9]/
+	      conf[3] = list(conf[3])
+	    end
+	  else
+	    if conf[2]
+	      if conf[2].index('{')
+		conf[2] = tk_split_list(conf[2]) 
+	      else
+		conf[2] = tk_tcl2ruby(conf[2]) 
+	      end
+	    end
+	    if conf[3]
+	      if conf[3].index('{')
+		conf[3] = tk_split_list(conf[3]) 
+	      else
+		conf[3] = tk_tcl2ruby(conf[3]) 
+	      end
+	    end
+	  end
+	  if conf.size == 1
+	    ret[key] = conf[0][1..-1]  # alias info
+	  else
+	    ret[key] = conf
+	  end
+	}
+	fontconf = ret['font']
+	if fontconf
+	  ret.delete('font')
+	  ret.delete('kanjifont')
+	  fontconf[3] = tagfont_configinfo(tagid(tagOrId), fontconf[3])
+	  ret['font'] = fontconf
+	end
+	ret
+      end
+    end
+  end
+
+  def current_itemconfiginfo(tagOrId, key=nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+	conf = itemconfiginfo(tagOrId, key)
+	{conf[0] => conf[4]}
+      else
+	ret = {}
+	itemconfiginfo(tagOrId).each{|conf|
+	  ret[conf[0]] = conf[4] if conf.size > 2
+	}
+	ret
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      ret = {}
+      itemconfiginfo(tagOrId, key).each{|k, conf|
+	ret[k] = conf[-1] if conf.kind_of?(Array)
+      }
+      ret
+    end
+  end
+
+  def lower(tag, below=nil)
+    if below
+      tk_send_without_enc('lower', tagid(tag), tagid(below))
+    else
+      tk_send_without_enc('lower', tagid(tag))
+    end
+    self
+  end
+
+  def move(tag, x, y)
+    tk_send_without_enc('move', tagid(tag), x, y)
+    self
+  end
+
+  def postscript(keys)
+    tk_send("postscript", *hash_kv(keys))
+  end
+
+  def raise(tag, above=nil)
+    if above
+      tk_send_without_enc('raise', tagid(tag), tagid(above))
+    else
+      tk_send_without_enc('raise', tagid(tag))
+    end
+    self
+  end
+
+  def scale(tag, x, y, xs, ys)
+    tk_send_without_enc('scale', tagid(tag), x, y, xs, ys)
+    self
+  end
+
+  def scan_mark(x, y)
+    tk_send_without_enc('scan', 'mark', x, y)
+    self
+  end
+  def scan_dragto(x, y)
+    tk_send_without_enc('scan', 'dragto', x, y)
+    self
+  end
+
+  def select(mode, *args)
+    r = tk_send_without_enc('select', mode, *args)
+    (mode == 'item')? TkcItem.id2obj(self, r): self
+  end
+  def select_adjust(tagOrId, index)
+    select('adjust', tagid(tagOrId), index)
+  end
+  def select_clear
+    select('clear')
+  end
+  def select_from(tagOrId, index)
+    select('from', tagid(tagOrId), index)
+  end
+  def select_item
+    select('item')
+  end
+  def select_to(tagOrId, index)
+    select('to', tagid(tagOrId), index)
+  end
+
+  def itemtype(tag)
+    TkcItem.type2class(tk_send('type', tagid(tag)))
+  end
+end
+
+class TkcItem<TkObject
+  extend Tk
+  include TkcTagAccess
+
+  CItemTypeToClass = {}
+  CItemID_TBL = TkCore::INTERP.create_table
+
+  TkCore::INTERP.init_ip_env{ CItemID_TBL.clear }
+
+  def TkcItem.type2class(type)
+    CItemTypeToClass[type]
+  end
+
+  def TkcItem.id2obj(canvas, id)
+    cpath = canvas.path
+    return id unless CItemID_TBL[cpath]
+    CItemID_TBL[cpath][id]? CItemID_TBL[cpath][id]: id
+  end
+
+  ########################################
+  def self.create(canvas, *args)
+    fail RuntimeError, "TkcItem is an abstract class"
+  end
+  ########################################
+
+  def initialize(parent, *args)
+    unless parent.kind_of?(TkCanvas)
+      fail ArguemntError, "expect TkCanvas for 1st argument"
+    end
+    @parent = @c = parent
+    @path = parent.path
+    fontkeys = {}
+    if args.size == 1 && args[0].kind_of?(Hash)
+      args[0] = _symbolkey2str(args[0])
+      coords = args[0].delete('coords')
+      unless coords.kind_of?(Array)
+        fail "coords parameter must be given by an Array"
+      end
+      args[0,0] = coords.flatten
+    end
+    if args[-1].kind_of? Hash
+      keys = _symbolkey2str(args.pop)
+      ['font', 'kanjifont', 'latinfont', 'asciifont'].each{|key|
+	fontkeys[key] = keys.delete(key) if keys.key?(key)
+      }
+      args.concat(hash_kv(keys))
+    end
+    @id = create_self(*args).to_i ;# 'canvas item id' is integer number
+    CItemID_TBL[@path] = {} unless CItemID_TBL[@path]
+    CItemID_TBL[@path][@id] = self
+    configure(fontkeys) unless fontkeys.empty?
+
+######## old version
+#    if args[-1].kind_of? Hash
+#      keys = args.pop
+#    end
+#    @id = create_self(*args).to_i ;# 'canvas item id' is integer number
+#    CItemID_TBL[@path] = {} unless CItemID_TBL[@path]
+#    CItemID_TBL[@path][@id] = self
+#    if keys
+#      # tk_call @path, 'itemconfigure', @id, *hash_kv(keys)
+#      configure(keys) if keys
+#    end
+########
+  end
+  def create_self(*args)
+    self.class.create(@path, *args)
+  end
+  private :create_self
+
+  def id
+    @id
+  end
+
+  def delete
+    @c.delete @id
+    CItemID_TBL[@path].delete(@id) if CItemID_TBL[@path]
+    self
+  end
+  alias remove  delete
+  alias destroy delete
+end
+
+class TkcArc<TkcItem
+  CItemTypeToClass['arc'] = self
+  def self.create(path, *args)
+    if args[-1].kind_of?(Hash)
+      keys = args.pop
+      args.concat(hash_kv(keys))
+    end
+    tk_call_without_enc(path, 'create', 'arc', *args)
+  end
+end
+
+class TkcBitmap<TkcItem
+  CItemTypeToClass['bitmap'] = self
+  def self.create(path, *args)
+    if args[-1].kind_of?(Hash)
+      keys = args.pop
+      args.concat(hash_kv(keys))
+    end
+    tk_call_without_enc(path, 'create', 'bitmap', *args)
+  end
+end
+
+class TkcImage<TkcItem
+  CItemTypeToClass['image'] = self
+  def self.create(path, *args)
+    if args[-1].kind_of?(Hash)
+      keys = args.pop
+      args.concat(hash_kv(keys))
+    end
+    tk_call_without_enc(path, 'create', 'image', *args)
+  end
+end
+
+class TkcLine<TkcItem
+  CItemTypeToClass['line'] = self
+  def self.create(path, *args)
+    if args[-1].kind_of?(Hash)
+      keys = args.pop
+      args.concat(hash_kv(keys))
+    end
+    tk_call_without_enc(path, 'create', 'line', *args)
+  end
+end
+
+class TkcOval<TkcItem
+  CItemTypeToClass['oval'] = self
+  def self.create(path, *args)
+    if args[-1].kind_of?(Hash)
+      keys = args.pop
+      args.concat(hash_kv(keys))
+    end
+    tk_call_without_enc(path, 'create', 'oval', *args)
+  end
+end
+
+class TkcPolygon<TkcItem
+  CItemTypeToClass['polygon'] = self
+  def self.create(path, *args)
+    if args[-1].kind_of?(Hash)
+      keys = args.pop
+      args.concat(hash_kv(keys))
+    end
+    tk_call_without_enc(path, 'create', 'polygon', *args)
+  end
+end
+
+class TkcRectangle<TkcItem
+  CItemTypeToClass['rectangle'] = self
+  def self.create(path, *args)
+    if args[-1].kind_of?(Hash)
+      keys = args.pop
+      args.concat(hash_kv(keys))
+    end
+    tk_call_without_enc(path, 'create', 'rectangle', *args)
+  end
+end
+
+class TkcText<TkcItem
+  CItemTypeToClass['text'] = self
+  def self.create(path, *args)
+    if args[-1].kind_of?(Hash)
+      keys = args.pop
+      args.concat(hash_kv(keys))
+    end
+    #tk_call_without_enc(path, 'create', 'text', 
+    #			*(args.each{|arg| _get_eval_enc_str(arg)}))
+    tk_call(path, 'create', 'text', *args)
+  end
+end
+
+class TkcWindow<TkcItem
+  CItemTypeToClass['window'] = self
+  def self.create(path, *args)
+    if args[-1].kind_of?(Hash)
+      keys = _symbolkey2str(args.pop)
+      win = keys['window']
+      # keys['window'] = win.epath if win.kind_of?(TkWindow)
+      keys['window'] = _epath(win) if win
+      args.concat(hash_kv(keys))
+    end
+    tk_call_without_enc(path, 'create', 'window', *args)
+  end
+end

ext/tk/lib/tk/canvastag.rb

@@ -0,0 +1,337 @@
+#
+# tk/canvastag.rb - methods for treating canvas tags
+#
+require 'tk'
+require 'tk/canvas'
+require 'tk/tagfont'
+
+module TkcTagAccess
+  include TkComm
+  include TkTreatTagFont
+
+  def addtag(tag)
+    @c.addtag(tag, 'with', @id)
+    self
+  end
+
+  def bbox
+    @c.bbox(@id)
+  end
+
+  def bind(seq, cmd=Proc.new, args=nil)
+    @c.itembind @id, seq, cmd, args
+    self
+  end
+
+  def bind_append(seq, cmd=Proc.new, args=nil)
+    @c.itembind_append @id, seq, cmd, args
+    self
+  end
+
+  def bind_remove(seq)
+    @c.itembind_remove @id, seq
+    self
+  end
+
+  def bindinfo(seq=nil)
+    @c.itembindinfo @id, seq
+  end
+
+  def cget(option)
+    @c.itemcget @id, option
+  end
+
+  def configure(key, value=None)
+    @c.itemconfigure @id, key, value
+    self
+  end
+#  def configure(keys)
+#    @c.itemconfigure @id, keys
+#  end
+
+  def configinfo(key=nil)
+    @c.itemconfiginfo @id, key
+  end
+
+  def current_configinfo(key=nil)
+    @c.current_itemconfiginfo @id, key
+  end
+
+  def coords(*args)
+    @c.coords @id, *args
+  end
+
+  def dchars(first, last=None)
+    @c.dchars @id, first, last
+    self
+  end
+
+  def dtag(tag_to_del=None)
+    @c.dtag @id, tag_to_del
+    self
+  end
+
+  def find
+    @c.find 'withtag', @id
+  end
+  alias list find
+
+  def focus
+    @c.itemfocus @id
+  end
+
+  def gettags
+    @c.gettags @id
+  end
+
+  def icursor(index)
+    @c.icursor @id, index
+    self
+  end
+
+  def index(index)
+    @c.index @id, index
+  end
+
+  def insert(beforethis, string)
+    @c.insert @id, beforethis, string
+    self
+  end
+
+  def lower(belowthis=None)
+    @c.lower @id, belowthis
+    self
+  end
+
+  def move(xamount, yamount)
+    @c.move @id, xamount, yamount
+    self
+  end
+
+  def raise(abovethis=None)
+    @c.raise @id, abovethis
+    self
+  end
+
+  def scale(xorigin, yorigin, xscale, yscale)
+    @c.scale @id, xorigin, yorigin, xscale, yscale
+    self
+  end
+
+  def select_adjust(index)
+    @c.select('adjust', @id, index)
+    self
+  end
+  def select_from(index)
+    @c.select('from', @id, index)
+    self
+  end
+  def select_to(index)
+    @c.select('to', @id, index)
+    self
+  end
+
+  def itemtype
+    @c.itemtype @id
+  end
+
+  # Following operators support logical expressions of canvas tags
+  # (for Tk8.3+).
+  # If tag1.path is 't1' and tag2.path is 't2', then
+  #      ltag = tag1 & tag2; ltag.path => "(t1)&&(t2)"
+  #      ltag = tag1 | tag2; ltag.path => "(t1)||(t2)"
+  #      ltag = tag1 ^ tag2; ltag.path => "(t1)^(t2)"
+  #      ltag = - tag1;      ltag.path => "!(t1)"
+  def & (tag)
+    if tag.kind_of? TkObject
+      TkcTagString.new(@c, '(' + @id + ')&&(' + tag.path + ')')
+    else
+      TkcTagString.new(@c, '(' + @id + ')&&(' + tag.to_s + ')')
+    end
+  end
+
+  def | (tag)
+    if tag.kind_of? TkObject
+      TkcTagString.new(@c, '(' + @id + ')||(' + tag.path + ')')
+    else
+      TkcTagString.new(@c, '(' + @id + ')||(' + tag.to_s + ')')
+    end
+  end
+
+  def ^ (tag)
+    if tag.kind_of? TkObject
+      TkcTagString.new(@c, '(' + @id + ')^(' + tag.path + ')')
+    else
+      TkcTagString.new(@c, '(' + @id + ')^(' + tag.to_s + ')')
+    end
+  end
+
+  def -@
+    TkcTagString.new(@c, '!(' + @id + ')')
+  end
+end
+
+class TkcTag<TkObject
+  include TkcTagAccess
+
+  CTagID_TBL = TkCore::INTERP.create_table
+  Tk_CanvasTag_ID = ['ctag'.freeze, '00000'.taint].freeze
+
+  TkCore::INTERP.init_ip_env{ CTagID_TBL.clear }
+
+  def TkcTag.id2obj(canvas, id)
+    cpath = canvas.path
+    return id unless CTagID_TBL[cpath]
+    CTagID_TBL[cpath][id]? CTagID_TBL[cpath][id]: id
+  end
+
+  def initialize(parent, mode=nil, *args)
+    unless parent.kind_of?(TkCanvas)
+      fail ArguemntError, "expect TkCanvas for 1st argument"
+    end
+    @c = parent
+    @cpath = parent.path
+    @path = @id = Tk_CanvasTag_ID.join('')
+    CTagID_TBL[@cpath] = {} unless CTagID_TBL[@cpath]
+    CTagID_TBL[@cpath][@id] = self
+    Tk_CanvasTag_ID[1].succ!
+    if mode
+      tk_call_without_enc(@c.path, "addtag", @id, mode, *args)
+    end
+  end
+  def id
+    @id
+  end
+
+  def delete
+    @c.delete @id
+    CTagID_TBL[@cpath].delete(@id) if CTagID_TBL[@cpath]
+    self
+  end
+  alias remove  delete
+  alias destroy delete
+
+  def set_to_above(target)
+    @c.addtag_above(@id, target)
+    self
+  end
+  alias above set_to_above
+
+  def set_to_all
+    @c.addtag_all(@id)
+    self
+  end
+  alias all set_to_all
+
+  def set_to_below(target)
+    @c.addtag_below(@id, target)
+    self
+  end
+  alias below set_to_below
+
+  def set_to_closest(x, y, halo=None, start=None)
+    @c.addtag_closest(@id, x, y, halo, start)
+    self
+  end
+  alias closest set_to_closest
+
+  def set_to_enclosed(x1, y1, x2, y2)
+    @c.addtag_enclosed(@id, x1, y1, x2, y2)
+    self
+  end
+  alias enclosed set_to_enclosed
+
+  def set_to_overlapping(x1, y1, x2, y2)
+    @c.addtag_overlapping(@id, x1, y1, x2, y2)
+    self
+  end
+  alias overlapping set_to_overlapping
+
+  def set_to_withtag(target)
+    @c.addtag_withtag(@id, target)
+    self
+  end
+  alias withtag set_to_withtag
+end
+
+class TkcTagString<TkcTag
+  def self.new(parent, name, *args)
+    if CTagID_TBL[parent.path] && CTagID_TBL[parent.path][name]
+      return CTagID_TBL[parent.path][name]
+    else
+      super(parent, name, *args)
+    end
+  end
+
+  def initialize(parent, name, mode=nil, *args)
+    unless parent.kind_of?(TkCanvas)
+      fail ArguemntError, "expect TkCanvas for 1st argument"
+    end
+    @c = parent
+    @cpath = parent.path
+    @path = @id = name
+    CTagID_TBL[@cpath] = {} unless CTagID_TBL[@cpath]
+    CTagID_TBL[@cpath][@id] = self
+    if mode
+      tk_call_without_enc(@c.path, "addtag", @id, mode, *args)
+    end
+  end
+end
+TkcNamedTag = TkcTagString
+
+class TkcTagAll<TkcTag
+  def initialize(parent)
+    unless parent.kind_of?(TkCanvas)
+      fail ArguemntError, "expect TkCanvas for 1st argument"
+    end
+    @c = parent
+    @cpath = parent.path
+    @path = @id = 'all'
+    CTagID_TBL[@cpath] = {} unless CTagID_TBL[@cpath]
+    CTagID_TBL[@cpath][@id] = self
+  end
+end
+
+class TkcTagCurrent<TkcTag
+  def initialize(parent)
+    unless parent.kind_of?(TkCanvas)
+      fail ArguemntError, "expect TkCanvas for 1st argument"
+    end
+    @c = parent
+    @cpath = parent.path
+    @path = @id = 'current'
+    CTagID_TBL[@cpath] = {} unless CTagID_TBL[@cpath]
+    CTagID_TBL[@cpath][@id] = self
+  end
+end
+
+class TkcGroup<TkcTag
+  Tk_cGroup_ID = ['tkcg'.freeze, '00000'.taint].freeze
+  def create_self(parent, *args)
+    unless parent.kind_of?(TkCanvas)
+      fail ArguemntError, "expect TkCanvas for 1st argument"
+    end
+    @c = parent
+    @cpath = parent.path
+    @path = @id = Tk_cGroup_ID.join('')
+    CTagID_TBL[@cpath] = {} unless CTagID_TBL[@cpath]
+    CTagID_TBL[@cpath][@id] = self
+    Tk_cGroup_ID[1].succ!
+    add(*args) if args != []
+  end
+  private :create_self
+  
+  def include(*tags)
+    for i in tags
+      i.addtag @id
+    end
+    self
+  end
+
+  def exclude(*tags)
+    for i in tags
+      i.delete @id
+    end
+    self
+  end
+end

ext/tk/lib/tk/checkbutton.rb

@@ -0,0 +1,25 @@
+#
+# tk/checkbutton.rb : treat checkbutton widget
+#
+require 'tk'
+require 'tk/radiobutton'
+
+class TkCheckButton<TkRadioButton
+  TkCommandNames = ['checkbutton'.freeze].freeze
+  WidgetClassName = 'Checkbutton'.freeze
+  WidgetClassNames[WidgetClassName] = self
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('checkbutton', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('checkbutton', @path)
+    end
+  end
+  private :create_self
+
+  def toggle
+    tk_send_without_enc('toggle')
+    self
+  end
+end
+TkCheckbutton = TkCheckButton

ext/tk/lib/tk/clipboard.rb

@@ -0,0 +1,75 @@
+#
+# tk/clipboard.rb : methods to treat clipboard
+#
+require 'tk'
+
+module TkClipboard
+  include Tk
+  extend Tk
+
+  TkCommandNames = ['clipboard'.freeze].freeze
+
+  def self.clear(win=nil)
+    if win
+      tk_call_without_enc('clipboard', 'clear', '-displayof', win)
+    else
+      tk_call_without_enc('clipboard', 'clear')
+    end
+  end
+  def self.clear_on_display(win)
+    tk_call_without_enc('clipboard', 'clear', '-displayof', win)
+  end
+
+  def self.get(type=nil)
+    if type
+      tk_call_without_enc('clipboard', 'get', '-type', type)
+    else
+      tk_call_without_enc('clipboard', 'get')
+    end
+  end
+  def self.get_on_display(win, type=nil)
+    if type
+      tk_call_without_enc('clipboard', 'get', '-displayof', win, '-type', type)
+    else
+      tk_call_without_enc('clipboard', 'get', '-displayof', win)
+    end
+  end
+
+  def self.set(data, keys=nil)
+    clear
+    append(data, keys)
+  end
+  def self.set_on_display(win, data, keys=nil)
+    clear(win)
+    append_on_display(win, data, keys)
+  end
+
+  def self.append(data, keys=nil)
+    args = ['clipboard', 'append']
+    args.concat(hash_kv(keys))
+    args.concat(['--', data])
+    tk_call(*args)
+  end
+  def self.append_on_display(win, data, keys=nil)
+    args = ['clipboard', 'append', '-displayof', win]
+    args.concat(hash_kv(keys))
+    args.concat(['--', data])
+    tk_call(*args)
+  end
+
+  def clear
+    TkClipboard.clear_on_display(self)
+    self
+  end
+  def get(type=nil)
+    TkClipboard.get_on_display(self, type)
+  end
+  def set(data, keys=nil)
+    TkClipboard.set_on_display(self, data, keys)
+    self
+  end
+  def append(data, keys=nil)
+    TkClipboard.append_on_display(self, data, keys)
+    self
+  end
+end

ext/tk/lib/tk/clock.rb

@@ -0,0 +1,57 @@
+#
+# tk/clock.rb : methods for clock command
+#
+require 'tk'
+
+module Tk
+  module Clock
+    def self.clicks(ms=nil)
+      case ms
+      when nil
+	tk_call_without_enc('clock','clicks').to_i
+      when /^mic/
+	tk_call_without_enc('clock','clicks','-microseconds').to_i
+      when /^mil/
+	tk_call_without_enc('clock','clicks','-milliseconds').to_i
+      else
+	tk_call_without_enc('clock','clicks','-milliseconds').to_i
+      end
+    end
+
+    def self.format(clk, form=nil)
+      if form
+	tk_call('clock','format',clk,'-format',form)
+      else
+	tk_call('clock','format',clk)
+      end
+    end
+
+    def self.formatGMT(clk, form=nil)
+      if form
+	tk_call('clock','format',clk,'-format',form,'-gmt','1')
+      else
+	tk_call('clock','format',clk,'-gmt','1')
+      end
+    end
+
+    def self.scan(str, base=nil)
+      if base
+	tk_call('clock','scan',str,'-base',base).to_i
+      else
+	tk_call('clock','scan',str).to_i
+      end
+    end
+
+    def self.scanGMT(str, base=nil)
+      if base
+	tk_call('clock','scan',str,'-base',base,'-gmt','1').to_i
+      else
+	tk_call('clock','scan',str,'-gmt','1').to_i
+      end
+    end
+
+    def self.seconds
+      tk_call_without_enc('clock','seconds').to_i
+    end
+  end
+end

ext/tk/lib/tk/composite.rb

@@ -0,0 +1,64 @@
+#
+# tk/composite.rb : 
+#
+require 'tk'
+
+module TkComposite
+  include Tk
+  extend Tk
+
+  def initialize(parent=nil, *args)
+    @delegates = {} 
+
+    if parent.kind_of? Hash
+      keys = _symbolkey2str(parent)
+      parent = keys.delete('parent')
+      @frame = TkFrame.new(parent)
+      @delegates['DEFAULT'] = @frame
+      @path = @epath = @frame.path
+      initialize_composite(keys)
+    else
+      @frame = TkFrame.new(parent)
+      @delegates['DEFAULT'] = @frame
+      @path = @epath = @frame.path
+      initialize_composite(*args)
+    end
+  end
+
+  def epath
+    @epath
+  end
+
+  def initialize_composite(*args) end
+  private :initialize_composite
+
+  def delegate(option, *wins)
+    if @delegates[option].kind_of?(Array)
+      for i in wins
+	@delegates[option].push(i)
+      end
+    else
+      @delegates[option] = wins
+    end
+  end
+
+  def configure(slot, value=None)
+    if slot.kind_of? Hash
+      slot.each{|slot,value| configure slot, value}
+    else
+      if @delegates and @delegates[slot]
+	for i in @delegates[slot]
+	  if not i
+	    i = @delegates['DEFALUT']
+	    redo
+	  else
+	    last = i.configure(slot, value)
+	  end
+	end
+	last
+      else
+	super
+      end
+    end
+  end
+end

ext/tk/lib/tk/console.rb

@@ -0,0 +1,29 @@
+#
+#   tk/console.rb : control the console on system without a real console
+#
+require 'tk'
+
+module TkConsole
+  include Tk
+  extend Tk
+
+  TkCommandNames = ['console'.freeze].freeze
+
+  def self.title(str=None)
+    tk_call 'console', str
+  end
+  def self.hide
+    tk_call_without_enc('console', 'hide')
+  end
+  def self.show
+    tk_call_without_enc('console', 'show')
+  end
+  def self.eval(tcl_script)
+    #
+    # supports a Tcl script only
+    # I have no idea to support a Ruby script seamlessly.
+    #
+    _fromUTF8(tk_call_without_enc('console', 'eval', 
+				  _get_eval_enc_str(tcl_script)))
+  end
+end

ext/tk/lib/tk/dialog.rb

@@ -0,0 +1,290 @@
+#
+#   tk/dialog.rb : create dialog boxes
+#
+require 'tk'
+
+class TkDialog2 < TkWindow
+  extend Tk
+
+  TkCommandNames = ['tk_dialog'.freeze].freeze
+
+  def self.show(*args)
+    dlog = self.new(*args)
+    dlog.show
+    dlog
+  end
+
+  def _set_button_config(configs)
+    set_config = proc{|c,i|
+      if $VERBOSE && (c.has_key?('command') || c.has_key?(:command))
+	STDERR.print("Warning: cannot give a command option " + 
+		     "to the dialog button#{i}. It was removed.\n")
+      end
+      c.delete('command'); c.delete(:command)
+      # @config << Kernel.format("%s.button%s configure %s; ", 
+      # 			       @path, i, hash_kv(c).join(' '))
+      @config << @path+'.button'+i.to_s+'configure '+hash_kv(c).join(' ')+'; '
+    }
+    case configs
+    when Proc
+      @buttons.each_index{|i|
+	if (c = configs.call(i)).kind_of? Hash
+	  set_config.call(c,i)
+	end
+      }
+
+    when Array
+      @buttons.each_index{|i|
+	if (c = configs[i]).kind_of? Hash
+	  set_config.call(c,i)
+	end
+      }
+
+    when Hash
+      @buttons.each_with_index{|s,i|
+	if (c = configs[s]).kind_of? Hash
+	  set_config.call(c,i)
+	end
+      }
+    end
+    @config = 'after idle {' + @config + '};' if @config != ""
+  end
+  private :_set_button_config
+
+  # initialize tk_dialog
+  def create_self(keys)
+    #@var = TkVariable.new
+    @val = nil
+
+    @title   = title
+
+    @message = message
+    @message_config = message_config
+    @msgframe_config = msgframe_config
+
+    @bitmap  = bitmap
+    @bitmap_config = message_config
+
+    @default_button = default_button
+
+    @buttons = buttons
+    @button_configs = proc{|num| button_configs(num)}
+    @btnframe_config = btnframe_config
+
+    #@config = "puts [winfo children .w0000];"
+    @config = ""
+
+    @command = nil
+
+    if keys.kind_of? Hash
+      @title   = keys['title'] if keys.key? 'title'
+      @message = keys['message'] if keys.key? 'message'
+      @bitmap  = keys['bitmap'] if keys.key? 'bitmap'
+      @bitmap  = '{}' if @bitmap == nil || @bitmap == ""
+      @default_button = keys['default'] if keys.key? 'default'
+      @buttons = keys['buttons'] if keys.key? 'buttons'
+
+      @command = keys['prev_command']
+
+      @message_config = keys['message_config'] if keys.key? 'message_config'
+      @msgframe_config = keys['msgframe_config'] if keys.key? 'msgframe_config'
+      @bitmap_config  = keys['bitmap_config']  if keys.key? 'bitmap_config'
+      @button_configs = keys['button_configs'] if keys.key? 'button_configs'
+      @btnframe_config = keys['btnframe_config'] if keys.key? 'btnframe_config'
+    end
+
+    if @title.include? ?\s
+      @title = '{' + @title + '}'
+    end
+
+    if @buttons.kind_of? Array
+      _set_button_config(@buttons.collect{|cfg| 
+			   (cfg.kind_of? Array)? cfg[1]: nil})
+      @buttons = @buttons.collect{|cfg| (cfg.kind_of? Array)? cfg[0]: cfg}
+    end
+    if @buttons.kind_of? Hash 
+      _set_button_config(@buttons)
+      @buttons = @buttons.keys
+    end
+    @buttons = tk_split_simplelist(@buttons) if @buttons.kind_of? String
+    @buttons = @buttons.collect{|s|
+      if s.kind_of? Array
+	s = s.join(' ')
+      end
+      if s.include? ?\s
+	'{' + s + '}'
+      else
+	s
+      end
+    }
+
+    if @message_config.kind_of? Hash
+      # @config << Kernel.format("%s.msg configure %s;", 
+      # 		       @path, hash_kv(@message_config).join(' '))
+      @config << @path+'.msg configure '+hash_kv(@message_config).join(' ')+';'
+    end
+
+    if @msgframe_config.kind_of? Hash
+      # @config << Kernel.format("%s.top configure %s;", 
+      # 		       @path, hash_kv(@msgframe_config).join(' '))
+      @config << @path+'.top configure '+hash_kv(@msgframe_config).join(' ')+';'
+    end
+
+    if @btnframe_config.kind_of? Hash
+      # @config << Kernel.format("%s.bot configure %s;", 
+      # 		       @path, hash_kv(@btnframe_config).join(' '))
+      @config << @path+'.bot configure '+hash_kv(@btnframe_config).join(' ')+';'
+    end
+
+    if @bitmap_config.kind_of? Hash
+      # @config << Kernel.format("%s.bitmap configure %s;", 
+      # 		       @path, hash_kv(@bitmap_config).join(' '))
+      @config << @path+'.bitmap configure '+hash_kv(@bitmap_config).join(' ')+';'
+    end
+
+    _set_button_config(@button_configs) if @button_configs
+
+    if @command.kind_of? Proc
+      @command.call(self)
+    end
+  end
+  private :create_self
+
+  def show
+    if @default_button.kind_of? String
+      default_button = @buttons.index(@default_button)
+    else
+      default_button = @default_button
+    end
+    default_button = '{}' if default_button == nil
+    #Tk.ip_eval('eval {global '+@var.id+';'+@config+
+    #	       'set '+@var.id+' [tk_dialog '+ 
+    #	       @path+" "+@title+" {#{@message}} "+@bitmap+" "+
+    #	       String(default_button)+" "+@buttons.join(' ')+']}')
+    Tk.ip_eval(@config)
+    @val = Tk.ip_eval('tk_dialog ' + @path + ' ' + @title + 
+		      ' {' + @message + '} ' + @bitmap + ' ' + 
+		      String(default_button) + ' ' + @buttons.join(' ')).to_i
+  end
+
+  def value
+    # @var.value.to_i
+    @val
+  end
+  ######################################################
+  #                                                    #
+  # these methods must be overridden for each dialog   #
+  #                                                    #
+  ######################################################
+  private
+
+  def title
+    # returns a title string of the dialog window
+    return "DIALOG"
+  end
+  def message
+    # returns a message text to display on the dialog
+    return "MESSAGE"
+  end
+  def message_config
+    # returns a Hash {option=>value, ...} for the message text
+    return nil
+  end
+  def msgframe_config
+    # returns a Hash {option=>value, ...} for the message text frame
+    return nil
+  end
+  def bitmap
+    # returns a bitmap name or a bitmap file path 
+    # (@ + path ; e.g. '@/usr/share/bitmap/sample.xbm')
+    return "info"
+  end
+  def bitmap_config
+    # returns nil or a Hash {option=>value, ...} for the bitmap
+    return nil
+  end
+  def default_button
+    # returns a default button's number or name
+    # if nil or null string, set no-default
+    return 0
+  end
+  def buttons
+    #return "BUTTON1 BUTTON2"
+    return ["BUTTON1", "BUTTON2"]
+  end
+  def button_configs(num)
+    # returns nil / Proc / Array or Hash (see _set_button_config)
+    return nil
+  end
+  def btnframe_config
+    # returns nil or a Hash {option=>value, ...} for the button frame
+    return nil
+  end
+end
+
+
+#
+# TkDialog : with showing at initialize
+#
+class TkDialog < TkDialog2
+  def self.show(*args)
+    self.new(*args)
+  end
+
+  def initialize(*args)
+    super(*args)
+    show
+  end
+end
+
+
+#
+# dialog for warning
+#
+class TkWarning2 < TkDialog2
+  def initialize(parent = nil, mes = nil)
+    if !mes
+      if parent.kind_of? TkWindow
+	mes = ""
+      else
+	mes = parent.to_s
+	parent = nil
+      end
+    end
+    super(parent, :message=>mes)
+  end
+
+  def show(mes = nil)
+    mes_bup = @message
+    @message = mes if mes
+    ret = super()
+    @message = mes_bup
+    ret
+  end
+
+  #######
+  private
+
+  def title
+    return "WARNING";
+  end
+  def bitmap
+    return "warning";
+  end
+  def default_button
+    return 0;
+  end
+  def buttons
+    return "OK";
+  end
+end
+
+class TkWarning < TkWarning2
+  def self.show(*args)
+    self.new(*args)
+  end
+  def initialize(*args)
+    super(*args)
+    show
+  end
+end

ext/tk/lib/tk/encodedstr.rb

@@ -0,0 +1,107 @@
+#
+# tk/encodedstr.rb : Tk::EncodedString class
+#
+require 'tk'
+
+###########################################
+#  string with Tcl's encoding
+###########################################
+module Tk
+  class EncodedString < String
+    Encoding = nil
+
+    def self.subst_utf_backslash(str)
+      # str.gsub(/\\u([0-9A-Fa-f]{1,4})/){[$1.hex].pack('U')}
+      TclTkLib._subst_UTF_backslash(str)
+    end
+    def self.utf_backslash(str)
+      self.subst_utf_backslash(str)
+    end
+
+    def self.subst_tk_backslash(str)
+      TclTkLib._subst_Tcl_backslash(str)
+    end
+
+    def self.utf_to_backslash_sequence(str)
+      str.unpack('U*').collect{|c|
+	if c <= 0xFF  # ascii character
+	  c.chr
+	else
+	  format('\u%X', c)
+	end
+      }.join('')
+    end
+    def self.utf_to_backslash(str)
+      self.utf_to_backslash_sequence(str)
+    end
+
+    def self.to_backslash_sequence(str)
+      str.unpack('U*').collect{|c|
+	if c <= 0x1F  # control character
+	  case c
+	  when 0x07; '\a'
+	  when 0x08; '\b'
+	  when 0x09; '\t'
+	  when 0x0a; '\n'
+	  when 0x0b; '\v'
+	  when 0x0c; '\f'
+	  when 0x0d; '\r'
+	  else
+	    format('\x%02X', c)
+	  end
+	elsif c <= 0xFF  # ascii character
+	  c.chr
+	else
+	  format('\u%X', c)
+	end
+      }.join('')
+    end
+
+    def self.new_with_utf_backslash(str, enc = nil)
+      self.new('', enc).replace(self.subst_utf_backslash(str))
+    end
+
+    def self.new_without_utf_backslash(str, enc = nil)
+      self.new('', enc).replace(str)
+    end
+
+    def initialize(str, enc = nil)
+      super(str)
+      @encoding = ( enc || 
+		   ((self.class::Encoding)? 
+		       self.class::Encoding : Tk.encoding_system) )
+    end
+
+    attr_reader :encoding
+  end
+  # def Tk.EncodedString(str, enc = nil)
+  #   Tk::EncodedString.new(str, enc)
+  # end
+
+  ##################################
+
+  class BinaryString < EncodedString
+    Encoding = 'binary'.freeze
+  end
+  # def Tk.BinaryString(str)
+  #   Tk::BinaryString.new(str)
+  # end
+
+  ##################################
+
+  class UTF8_String < EncodedString
+    Encoding = 'utf-8'.freeze
+    def self.new(str)
+      super(self.subst_utf_backslash(str))
+    end
+
+    def to_backslash_sequence
+      Tk::EncodedString.utf_to_backslash_sequence(self)
+    end
+    alias to_backslash to_backslash_sequence
+  end
+  # def Tk.UTF8_String(str)
+  #   Tk::UTF8_String.new(str)
+  # end
+
+end

ext/tk/lib/tk/entry.rb

@@ -0,0 +1,114 @@
+#
+#		tk/entry.rb - Tk entry classes
+#			$Date$
+#			by Yukihiro Matsumoto <matz@caelum.co.jp>
+
+require 'tk'
+require 'tk/label'
+require 'tk/scrollable'
+require 'tk/validation'
+
+class TkEntry<TkLabel
+  include Scrollable
+  include TkValidation
+
+  TkCommandNames = ['entry'.freeze].freeze
+  WidgetClassName = 'Entry'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+
+  def create_self(keys)
+    tk_call_without_enc('entry', @path)
+    if keys and keys != None
+      configure(keys)
+    end
+  end
+  private :create_self
+
+  def bbox(index)
+    list(tk_send_without_enc('bbox', index))
+  end
+  def cursor
+    number(tk_send_without_enc('index', 'insert'))
+  end
+  def cursor=(index)
+    tk_send_without_enc('icursor', index)
+    #self
+    index
+  end
+  def index(index)
+    number(tk_send_without_enc('index', index))
+  end
+  def insert(pos,text)
+    tk_send_without_enc('insert', pos, _get_eval_enc_str(text))
+    self
+  end
+  def delete(first, last=None)
+    tk_send_without_enc('delete', first, last)
+    self
+  end
+  def mark(pos)
+    tk_send_without_enc('scan', 'mark', pos)
+    self
+  end
+  def dragto(pos)
+    tk_send_without_enc('scan', 'dragto', pos)
+    self
+  end
+  def selection_adjust(index)
+    tk_send_without_enc('selection', 'adjust', index)
+    self
+  end
+  def selection_clear
+    tk_send_without_enc('selection', 'clear')
+    self
+  end
+  def selection_from(index)
+    tk_send_without_enc('selection', 'from', index)
+    self
+  end
+  def selection_present()
+    bool(tk_send_without_enc('selection', 'present'))
+  end
+  def selection_range(s, e)
+    tk_send_without_enc('selection', 'range', s, e)
+    self
+  end
+  def selection_to(index)
+    tk_send_without_enc('selection', 'to', index)
+    self
+  end
+
+  def invoke_validate
+    bool(tk_send_without_enc('validate'))
+  end
+  def validate(mode = nil)
+    if mode
+      configure 'validate', mode
+    else
+      invoke_validate
+    end
+  end
+
+  def value
+    _fromUTF8(tk_send_without_enc('get'))
+  end
+  def value= (val)
+    tk_send_without_enc('delete', 0, 'end')
+    tk_send_without_enc('insert', 0, _get_eval_enc_str(val))
+    val
+  end
+  alias get value
+  alias set value=
+
+  def [](*args)
+    self.value[*args]
+  end
+  def []=(*args)
+    val = args.pop
+    str = self.value
+    str[*args] = val
+    self.value = str
+    val
+  end
+end

ext/tk/lib/tk/event.rb

@@ -0,0 +1,142 @@
+#
+#  tk/event.rb - module for event
+#
+require 'tk'
+
+module TkEvent
+  class Event < TkUtil::CallbackSubst
+    module TypeNum
+      KeyPress         =  2
+      KeyRelease       =  3
+      ButtonPress      =  4
+      ButtonRelease    =  5
+      MotionNotify     =  6
+      EnterNotify      =  7
+      LeaveNotify      =  8
+      FocusIn          =  9
+      FocusOut         = 10
+      KeymapNotify     = 11
+      Expose           = 12
+      GraphicsExpose   = 13
+      NoExpose         = 14
+      VisibilityNotify = 15
+      CreateNotify     = 16
+      DestroyNotify    = 17
+      UnmapNotify      = 18
+      MapNotify	       = 19
+      MapRequest       = 20
+      ReparentNotify   = 21
+      ConfigureNotify  = 22
+      ConfigureRequest = 23
+      GravityNotify    = 24
+      ResizeRequest    = 25
+      CirculateNotify  = 26
+      CirculateRequest = 27
+      PropertyNotify   = 28
+      SelectionClear   = 29
+      SelectionRequest = 30
+      SelectionNotify  = 31
+      ColormapNotify   = 32
+      ClientMessage    = 33
+      MappingNotify    = 34
+    end
+
+    # [ <'%' subst-key char>, <proc type char>, <instance var (accessor) name>]
+    key_tbl = [
+      [ ?#, ?n, :serial ], 
+      [ ?a, ?s, :above ], 
+      [ ?b, ?n, :num ], 
+      [ ?c, ?n, :count ], 
+      [ ?d, ?s, :detail ], 
+      [ ?f, ?b, :focus ], 
+      [ ?h, ?n, :height ], 
+      [ ?i, ?s, :win_hex ], 
+      [ ?k, ?n, :keycode ], 
+      [ ?m, ?s, :mode ], 
+      [ ?o, ?b, :override ], 
+      [ ?p, ?s, :place ], 
+      [ ?s, ?x, :state ], 
+      [ ?t, ?n, :time ], 
+      [ ?w, ?n, :width ], 
+      [ ?x, ?n, :x ], 
+      [ ?y, ?n, :y ], 
+      [ ?A, ?s, :char ], 
+      [ ?B, ?n, :borderwidth ], 
+      [ ?D, ?n, :wheel_delta ], 
+      [ ?E, ?b, :send_event ], 
+      [ ?K, ?s, :keysym ], 
+      [ ?N, ?n, :keysym_num ], 
+      [ ?R, ?s, :rootwin_id ], 
+      [ ?S, ?s, :subwindow ], 
+      [ ?T, ?n, :type ], 
+      [ ?W, ?w, :widget ], 
+      [ ?X, ?n, :x_root ], 
+      [ ?Y, ?n, :y_root ], 
+      nil
+    ]
+
+    # [ <proc type char>, <proc/method to convert tcl-str to ruby-obj>]
+    proc_tbl = [
+      [ ?n, TkComm.method(:num_or_str) ], 
+      [ ?s, TkComm.method(:string) ], 
+      [ ?b, TkComm.method(:bool) ], 
+      [ ?w, TkComm.method(:window) ], 
+
+      [ ?x, proc{|val|
+	  begin
+	    TkComm::number(val)
+	  rescue ArgumentError
+	    val
+	  end
+	}
+      ], 
+
+      nil
+    ]
+
+    # setup tables to be used by scan_args, _get_subst_key, _get_all_subst_keys
+    #
+    #     _get_subst_key() and _get_all_subst_keys() generates key-string 
+    #     which describe how to convert callback arguments to ruby objects. 
+    #     When binding parameters are given, use _get_subst_key(). 
+    #     But when no parameters are given, use _get_all_subst_keys() to 
+    #     create a Event class object as a callback parameter. 
+    #
+    #     scan_args() is used when doing callback. It convert arguments 
+    #     ( which are Tcl strings ) to ruby objects based on the key string 
+    #     that is generated by _get_subst_key() or _get_all_subst_keys(). 
+    #
+    _setup_subst_table(key_tbl, proc_tbl);
+  end
+
+  def install_bind(cmd, *args)
+    if args.compact.size > 0
+      args = args.join(' ')
+      keys = Event._get_subst_key(args)
+
+      if cmd.kind_of?(String)
+	id = cmd
+      elsif cmd.kind_of?(TkCallbackEntry)
+	id = install_cmd(cmd)
+      else
+	id = install_cmd(proc{|*arg|
+	  TkUtil.eval_cmd(cmd, *Event.scan_args(keys, arg))
+        })
+      end
+      id + ' ' + args
+    else
+      keys, args = Event._get_all_subst_keys
+
+      if cmd.kind_of?(String)
+	id = cmd
+      elsif cmd.kind_of?(TkCallbackEntry)
+	id = install_cmd(cmd)
+      else
+        id = install_cmd(proc{|*arg|
+	  TkUtil.eval_cmd(cmd, Event.new(*Event.scan_args(keys, arg)))
+        })
+      end
+      id + ' ' + args
+    end
+  end
+end

ext/tk/lib/tk/frame.rb

@@ -0,0 +1,123 @@
+#
+# tk/frame.rb : treat frame widget
+#
+require 'tk'
+
+class TkFrame<TkWindow
+  TkCommandNames = ['frame'.freeze].freeze
+  WidgetClassName = 'Frame'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+################# old version
+#  def initialize(parent=nil, keys=nil)
+#    if keys.kind_of? Hash
+#      keys = keys.dup
+#      @classname = keys.delete('classname') if keys.key?('classname')
+#      @colormap  = keys.delete('colormap')  if keys.key?('colormap')
+#      @container = keys.delete('container') if keys.key?('container')
+#      @visual    = keys.delete('visual')    if keys.key?('visual')
+#    end
+#    super(parent, keys)
+#  end
+#
+#  def create_self
+#    s = []
+#    s << "-class"     << @classname if @classname
+#    s << "-colormap"  << @colormap  if @colormap
+#    s << "-container" << @container if @container
+#    s << "-visual"    << @visual    if @visual
+#    tk_call 'frame', @path, *s
+#  end
+#################
+
+  def initialize(parent=nil, keys=nil)
+    my_class_name = nil
+    if self.class < WidgetClassNames[WidgetClassName]
+      my_class_name = self.class.name
+      my_class_name = nil if my_class_name == ''
+    end
+    if parent.kind_of? Hash
+      keys = _symbolkey2str(parent)
+    else
+      if keys
+        keys = _symbolkey2str(keys)
+        keys['parent'] = parent
+      else
+        keys = {'parent'=>parent}
+      end
+    end
+    if keys.key?('classname')
+       keys['class'] = keys.delete('classname')
+    end
+    @classname = keys['class']
+    @colormap  = keys['colormap']
+    @container = keys['container']
+    @visual    = keys['visual']
+    if !@classname && my_class_name
+      keys['class'] = @classname = my_class_name
+    end
+    if @classname.kind_of? TkBindTag
+      @db_class = @classname
+      @classname = @classname.id
+    elsif @classname
+      @db_class = TkDatabaseClass.new(@classname)
+    else
+      @db_class = self.class
+      @classname = @db_class::WidgetClassName
+    end
+    super(keys)
+  end
+
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('frame', @path, *hash_kv(keys))
+    else
+      tk_call_without_enc( 'frame', @path)
+    end
+  end
+  private :create_self
+
+  def database_classname
+    @classname
+  end
+
+  def self.database_class
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      self
+    else
+      TkDatabaseClass.new(self.name)
+    end
+  end
+  def self.database_classname
+    self.database_class.name
+  end
+
+  def self.bind(*args)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args)
+    else
+      TkDatabaseClass.new(self.name).bind(*args)
+    end
+  end
+  def self.bind_append(*args)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args)
+    else
+      TkDatabaseClass.new(self.name).bind_append(*args)
+    end
+  end
+  def self.bind_remove(*args)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args)
+    else
+      TkDatabaseClass.new(self.name).bind_remove(*args)
+    end
+  end
+  def self.bindinfo(*args)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args)
+    else
+      TkDatabaseClass.new(self.name).bindinfo(*args)
+    end
+  end
+end

ext/tk/lib/tk/grid.rb

@@ -0,0 +1,182 @@
+#
+# tk/grid.rb : control grid geometry manager
+#
+require 'tk'
+
+module TkGrid
+  include Tk
+  extend Tk
+
+  TkCommandNames = ['grid'.freeze].freeze
+
+  def anchor(master, anchor=None)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    tk_call_without_enc('grid', 'anchor', master, anchor)
+  end
+
+  def bbox(master, *args)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    args.unshift(master)
+    list(tk_call_without_enc('grid', 'bbox', *args))
+  end
+
+  def configure(win, *args)
+    if args[-1].kind_of?(Hash)
+      opts = args.pop
+    else
+      opts = {}
+    end
+    params = []
+    params.push(_epath(win))
+    args.each{|win|
+      case win
+      when '-', 'x', '^'  # RELATIVE PLACEMENT
+	params.push(win)
+      else
+	params.push(_epath(win))
+      end
+    }
+    opts.each{|k, v|
+      params.push("-#{k}")
+      params.push((v.kind_of?(TkObject))? v.epath: v)
+    }
+    tk_call_without_enc("grid", 'configure', *params)
+  end
+
+  def columnconfigure(master, index, args)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    tk_call_without_enc("grid", 'columnconfigure', 
+			master, index, *hash_kv(args))
+  end
+
+  def rowconfigure(master, index, args)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    tk_call_without_enc("grid", 'rowconfigure', master, index, *hash_kv(args))
+  end
+
+  def columnconfiginfo(master, index, slot=nil)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    if slot
+      num_or_str(tk_call_without_enc('grid', 'columnconfigure', 
+				     master, index, "-#{slot}"))
+    else
+      ilist = list(tk_call_without_enc('grid','columnconfigure',master,index))
+      info = {}
+      while key = ilist.shift
+	info[key[1..-1]] = ilist.shift
+      end
+      info
+    end
+  end
+
+  def rowconfiginfo(master, index, slot=nil)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    if slot
+      num_or_str(tk_call_without_enc('grid', 'rowconfigure', 
+				     master, index, "-#{slot}"))
+    else
+      ilist = list(tk_call_without_enc('grid', 'rowconfigure', master, index))
+      info = {}
+      while key = ilist.shift
+	info[key[1..-1]] = ilist.shift
+      end
+      info
+    end
+  end
+
+  def add(widget, *args)
+    configure(widget, *args)
+  end
+
+  def forget(*args)
+    return '' if args.size == 0
+    wins = args.collect{|win|
+      # (win.kind_of?(TkObject))? win.epath: win
+      _epath(win)
+    }
+    tk_call_without_enc('grid', 'forget', *wins)
+  end
+
+  def info(slave)
+    # slave = slave.epath if slave.kind_of?(TkObject)
+    slave = _epath(slave)
+    ilist = list(tk_call_without_enc('grid', 'info', slave))
+    info = {}
+    while key = ilist.shift
+      info[key[1..-1]] = ilist.shift
+    end
+    return info
+  end
+
+  def location(master, x, y)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    list(tk_call_without_enc('grid', 'location', master, x, y))
+  end
+
+  def propagate(master, bool=None)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    if bool == None
+      bool(tk_call_without_enc('grid', 'propagate', master))
+    else
+      tk_call_without_enc('grid', 'propagate', master, bool)
+    end
+  end
+
+  def remove(*args)
+    return '' if args.size == 0
+    wins = args.collect{|win|
+      # (win.kind_of?(TkObject))? win.epath: win
+      _epath(win)
+    }
+    tk_call_without_enc('grid', 'remove', *wins)
+  end
+
+  def size(master)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    list(tk_call_without_enc('grid', 'size', master))
+  end
+
+  def slaves(master, args)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    list(tk_call_without_enc('grid', 'slaves', master, *hash_kv(args)))
+  end
+
+  module_function :bbox, :forget, :propagate, :info
+  module_function :remove, :size, :slaves, :location
+  module_function :configure, :columnconfigure, :rowconfigure
+  module_function :columnconfiginfo, :rowconfiginfo
+end
+=begin
+def TkGrid(win, *args)
+  if args[-1].kind_of?(Hash)
+    opts = args.pop
+  else
+    opts = {}
+  end
+  params = []
+  params.push((win.kind_of?(TkObject))? win.epath: win)
+  args.each{|win|
+    case win
+    when '-', 'x', '^'  # RELATIVE PLACEMENT
+      params.push(win)
+    else
+      params.push((win.kind_of?(TkObject))? win.epath: win)
+    end
+  }
+  opts.each{|k, v|
+    params.push("-#{k}")
+    params.push((v.kind_of?(TkObject))? v.epath: v)
+  }
+  tk_call_without_enc("grid", *params)
+end
+=end

ext/tk/lib/tk/image.rb

@@ -0,0 +1,185 @@
+#
+# tk/image.rb : treat Tk image objects
+#
+
+require 'tk'
+
+class TkImage<TkObject
+  include Tk
+
+  TkCommandNames = ['image'.freeze].freeze
+
+  Tk_IMGTBL = TkCore::INTERP.create_table
+  Tk_Image_ID = ['i'.freeze, '00000'.taint].freeze
+
+  TkCore::INTERP.init_ip_env{ Tk_IMGTBL.clear }
+
+  def initialize(keys=nil)
+    @path = Tk_Image_ID.join('')
+    Tk_Image_ID[1].succ!
+    tk_call_without_enc('image', 'create', @type, @path, *hash_kv(keys, true))
+    Tk_IMGTBL[@path] = self
+  end
+
+  def delete
+    Tk_IMGTBL.delete(@id) if @id
+    tk_call_without_enc('image', 'delete', @path)
+    self
+  end
+  def height
+    number(tk_call_without_enc('image', 'height', @path))
+  end
+  def inuse
+    bool(tk_call_without_enc('image', 'inuse', @path))
+  end
+  def itemtype
+    tk_call_without_enc('image', 'type', @path)
+  end
+  def width
+    number(tk_call_without_enc('image', 'width', @path))
+  end
+
+  def TkImage.names
+    Tk.tk_call_without_enc('image', 'names').split.collect!{|id|
+      (Tk_IMGTBL[id])? Tk_IMGTBL[id] : id
+    }
+  end
+
+  def TkImage.types
+    Tk.tk_call_without_enc('image', 'types').split
+  end
+end
+
+class TkBitmapImage<TkImage
+  def initialize(*args)
+    @type = 'bitmap'
+    super
+  end
+end
+
+class TkPhotoImage<TkImage
+  NullArgOptionKeys = [ "shrink", "grayscale" ]
+
+  def _photo_hash_kv(keys)
+    keys = _symbolkey2str(keys)
+    NullArgOptionKeys.collect{|opt|
+      if keys[opt]
+	keys[opt] = None
+      else
+	keys.delete(opt)
+      end
+    }
+    hash_kv(keys).flatten
+  end
+  private :_photo_hash_kv
+
+  def initialize(*args)
+    @type = 'photo'
+    super
+  end
+
+  def blank
+    tk_send_without_enc('blank')
+    self
+  end
+
+  def cget(option)
+    case option.to_s
+    when 'data', 'file'
+      tk_send 'cget', option
+    else
+      tk_tcl2ruby(tk_send('cget', option))
+    end
+  end
+
+  def copy(src, *opts)
+    if opts.size == 0
+      tk_send('copy', src)
+    elsif opts.size == 1 && opts[0].kind_of?(Hash)
+      tk_send('copy', src, *_photo_hash_kv(opts[0]))
+    else
+      # for backward compatibility
+      args = opts.collect{|term|
+	if term.kind_of?(String) && term.include?(?\s)
+	  term.split
+	else
+	  term
+	end
+      }.flatten
+      tk_send('copy', source, *args)
+    end
+    self
+  end
+
+  def data(keys={})
+    #tk_send('data', *_photo_hash_kv(keys))
+    tk_split_list(tk_send('data', *_photo_hash_kv(keys)))
+  end
+
+  def get(x, y)
+    tk_send('get', x, y).split.collect{|n| n.to_i}
+  end
+
+  def put(data, *opts)
+    if opts == []
+      tk_send('put', data)
+    elsif opts.size == 1 && opts[0].kind_of?(Hash)
+      tk_send('put', data, *_photo_hash_kv(opts[0]))
+    else
+      # for backward compatibility
+      tk_send('put', data, '-to', *opts)
+    end
+    self
+  end
+
+  def read(file, *opts)
+    if opts.size == 0
+      tk_send('read', file)
+    elsif opts.size == 1 && opts[0].kind_of?(Hash)
+      tk_send('read', file, *_photo_hash_kv(opts[0]))
+    else
+      # for backward compatibility
+      args = opts.collect{|term|
+	if term.kind_of?(String) && term.include?(?\s)
+	  term.split
+	else
+	  term
+	end
+      }.flatten
+      tk_send('read', file, *args)
+    end
+    self
+  end
+
+  def redither
+    tk_send 'redither'
+    self
+  end
+
+  def get_transparency(x, y)
+    bool(tk_send('transparency', 'get', x, y))
+  end
+  def set_transparency(x, y, st)
+    tk_send('transparency', 'set', x, y, st)
+    self
+  end
+
+  def write(file, *opts)
+    if opts.size == 0
+      tk_send('write', file)
+    elsif opts.size == 1 && opts[0].kind_of?(Hash)
+      tk_send('write', file, *_photo_hash_kv(opts[0]))
+    else
+      # for backward compatibility
+      args = opts.collect{|term|
+	if term.kind_of?(String) && term.include?(?\s)
+	  term.split
+	else
+	  term
+	end
+      }.flatten
+      tk_send('write', file, *args)
+    end
+    self
+  end
+end

ext/tk/lib/tk/itemfont.rb

@@ -0,0 +1,185 @@
+#
+# tk/itemfont.rb : control font of widget items
+#
+require 'tk'
+
+module TkTreatItemFont
+  def __conf_cmd(idx)
+    raise NotImplementedError, "need to define `__conf_cmd'"
+  end
+  def __item_pathname(tagOrId)
+    raise NotImplementedError, "need to define `__item_pathname'"
+  end
+  private :__conf_cmd, :__item_pathname
+
+  def tagfont_configinfo(tagOrId, name = nil)
+    pathname = __item_pathname(tagOrId)
+    ret = TkFont.used_on(pathname)
+    if ret == nil
+=begin
+      if name
+	ret = name
+      else
+	ret = TkFont.init_widget_font(pathname, self.path, 
+				      __conf_cmd(0), __conf_cmd(1), tagOrId)
+      end
+=end
+      ret = TkFont.init_widget_font(pathname, self.path, 
+				    __conf_cmd(0), __conf_cmd(1), tagOrId)
+    end
+    ret
+  end
+  alias tagfontobj tagfont_configinfo
+
+  def tagfont_configure(tagOrId, slot)
+    pathname = __item_pathname(tagOrId)
+    slot = _symbolkey2str(slot)
+
+    if slot.key?('font')
+      fnt = slot.delete('font')
+      if fnt.kind_of? TkFont
+	return fnt.call_font_configure(pathname, self.path,
+				       __conf_cmd(0), __conf_cmd(1), 
+				       tagOrId, slot)
+      else
+	if fnt 
+	  if (slot.key?('kanjifont') || 
+	      slot.key?('latinfont') || 
+	      slot.key?('asciifont'))
+	    fnt = TkFont.new(fnt)
+
+	    lfnt = slot.delete('latinfont')
+	    lfnt = slot.delete('asciifont') if slot.key?('asciifont')
+	    kfnt = slot.delete('kanjifont')
+
+	    fnt.latin_replace(lfnt) if lfnt
+	    fnt.kanji_replace(kfnt) if kfnt
+	  end
+
+	  slot['font'] = fnt
+	  tk_call(self.path, __conf_cmd(0), __conf_cmd(1), 
+		  tagOrId, *hash_kv(slot))
+	end
+	return self
+      end
+    end
+
+    lfnt = slot.delete('latinfont')
+    lfnt = slot.delete('asciifont') if slot.key?('asciifont')
+    kfnt = slot.delete('kanjifont')
+
+    if lfnt && kfnt
+      return TkFont.new(lfnt, kfnt).call_font_configure(pathname, self.path,
+							__conf_cmd(0), 
+							__conf_cmd(1), 
+							tagOrId, slot)
+    end
+
+    latintagfont_configure(tagOrId, lfnt) if lfnt
+    kanjitagfont_configure(tagOrId, kfnt) if kfnt
+      
+    tk_call(self.path, __conf_cmd(0), __conf_cmd(1), 
+	    tagOrId, *hash_kv(slot)) if slot != {}
+    self
+  end
+
+  def latintagfont_configure(tagOrId, ltn, keys=nil)
+    pathname = __item_pathname(tagOrId)
+    if (fobj = TkFont.used_on(pathname))
+      fobj = TkFont.new(fobj)    # create a new TkFont object
+    elsif Tk::JAPANIZED_TK
+      fobj = tagfontobj(tagOrId) # create a new TkFont object
+    else
+      tk_call(self.path, __conf_cmd(0), __conf_cmd(1), tagOrId, '-font', ltn)
+      return self
+    end
+
+    if fobj.kind_of?(TkFont)
+      if ltn.kind_of? TkFont
+	conf = {}
+	ltn.latin_configinfo.each{|key,val| conf[key] = val}
+	if keys
+	  fobj.latin_configure(conf.update(keys))
+	else
+	  fobj.latin_configure(conf)
+	end
+      else
+	fobj.latin_replace(ltn)
+      end
+    end
+
+    return fobj.call_font_configure(pathname, self.path,
+				    __conf_cmd(0), __conf_cmd(1), tagOrId, {})
+  end
+  alias asciitagfont_configure latintagfont_configure
+
+  def kanjitagfont_configure(tagOrId, knj, keys=nil)
+    pathname = __item_pathname(tagOrId)
+    if (fobj = TkFont.used_on(pathname))
+      fobj = TkFont.new(fobj)    # create a new TkFont object
+    elsif Tk::JAPANIZED_TK
+      fobj = tagfontobj(tagOrId) # create a new TkFont object
+    else
+      tk_call(self.path, __conf_cmd(0), __conf_cmd(1), tagOrId, '-font', knj)
+      return self
+    end
+
+    if fobj.kind_of?(TkFont)
+      if knj.kind_of? TkFont
+	conf = {}
+	knj.kanji_configinfo.each{|key,val| conf[key] = val}
+	if keys
+	  fobj.kanji_configure(conf.update(keys))
+	else
+	  fobj.kanji_configure(conf)
+	end
+      else
+	fobj.kanji_replace(knj)
+      end
+    end
+
+    return fobj.call_font_configure(pathname, self.path,
+				    __conf_cmd(0), __conf_cmd(1), tagOrId, {})
+  end
+
+  def tagfont_copy(tagOrId, window, wintag=nil)
+    pathname = __item_pathname(tagOrId)
+    if wintag
+      fnt = window.tagfontobj(wintag).dup
+    else
+      fnt = window.fontobj.dup
+    end
+    fnt.call_font_configure(pathname, self.path, 
+			    __conf_cmd(0), __conf_cmd(1), tagOrId, {})
+    return self
+  end
+
+  def latintagfont_copy(tagOrId, window, wintag=nil)
+    pathname = __item_pathname(tagOrId)
+    tagfontobj(tagOrId).dup.call_font_configure(pathname, self.path, 
+						__conf_cmd(0), __conf_cmd(1), 
+						tagOrId, {})
+    if wintag
+      tagfontobj(tagOrId).
+	latin_replace(window.tagfontobj(wintag).latin_font_id)
+    else
+      tagfontobj(tagOrId).latin_replace(window.fontobj.latin_font_id)
+    end
+    self
+  end
+  alias asciitagfont_copy latintagfont_copy
+
+  def kanjitagfont_copy(tagOrId, window, wintag=nil)
+    pathname = __item_pathname(tagOrId)
+    tagfontobj(tagOrId).dup.call_font_configure(pathname, self.path, 
+						__conf_cmd(0), __conf_cmd(1), 
+						tagOrId, {})
+    if wintag
+      tagfontobj(tagOrId).
+	kanji_replace(window.tagfontobj(wintag).kanji_font_id)
+    else
+      tagfontobj(tagOrId).kanji_replace(window.fontobj.kanji_font_id)
+    end
+    self
+  end
+end

ext/tk/lib/tk/kinput.rb

@@ -0,0 +1,71 @@
+#
+# tk/kinput.rb : control kinput
+#
+require 'tk'
+
+module TkKinput
+  include Tk
+  extend Tk
+
+  TkCommandNames = [
+    'kinput_start'.freeze, 
+    'kinput_send_spot'.freeze, 
+    'kanjiInput'.freeze
+  ].freeze
+
+  def TkKinput.start(window, style=None)
+    tk_call('kinput_start', window, style)
+  end
+  def kinput_start(style=None)
+    TkKinput.start(self, style)
+  end
+
+  def TkKinput.send_spot(window)
+    tk_call('kinput_send_spot', window)
+  end
+  def kinput_send_spot
+    TkKinput.send_spot(self)
+  end
+
+  def TkKinput.input_start(window, keys=nil)
+    tk_call('kanjiInput', 'start', window, *hash_kv(keys))
+  end
+  def kanji_input_start(keys=nil)
+    TkKinput.input_start(self, keys)
+  end
+
+  def TkKinput.attribute_config(window, slot, value=None)
+    if slot.kind_of? Hash
+      tk_call('kanjiInput', 'attribute', window, *hash_kv(slot))
+    else
+      tk_call('kanjiInput', 'attribute', window, "-#{slot}", value)
+    end
+  end
+  def kinput_attribute_config(slot, value=None)
+    TkKinput.attribute_config(self, slot, value)
+  end
+
+  def TkKinput.attribute_info(window, slot=nil)
+    if slot
+      conf = tk_split_list(tk_call('kanjiInput', 'attribute', 
+				   window, "-#{slot}"))
+      conf[0] = conf[0][1..-1]
+      conf
+    else
+      tk_split_list(tk_call('kanjiInput', 'attribute', window)).collect{|conf|
+	conf[0] = conf[0][1..-1]
+	conf
+      }
+    end
+  end
+  def kinput_attribute_info(slot=nil)
+    TkKinput.attribute_info(self, slot)
+  end
+
+  def TkKinput.input_end(window)
+    tk_call('kanjiInput', 'end', window)
+  end
+  def kanji_input_end
+    TkKinput.input_end(self)
+  end
+end

ext/tk/lib/tk/label.rb

@@ -0,0 +1,22 @@
+#
+# tk/label.rb : treat label widget
+#
+require 'tk'
+
+class TkLabel<TkWindow
+  TkCommandNames = ['label'.freeze].freeze
+  WidgetClassName = 'Label'.freeze
+  WidgetClassNames[WidgetClassName] = self
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('label', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('label', @path)
+    end
+  end
+  private :create_self
+
+  def textvariable(v)
+    configure 'textvariable', tk_trace_variable(v)
+  end
+end

ext/tk/lib/tk/labelframe.rb

@@ -0,0 +1,20 @@
+#
+# tk/labelframe.rb : treat labelframe widget
+#
+require 'tk'
+require 'tk/frame'
+
+class TkLabelFrame<TkFrame
+  TkCommandNames = ['labelframe'.freeze].freeze
+  WidgetClassName = 'Labelframe'.freeze
+  WidgetClassNames[WidgetClassName] = self
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('labelframe', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('labelframe', @path)
+    end
+  end
+  private :create_self
+end
+TkLabelframe = TkLabelFrame

ext/tk/lib/tk/listbox.rb

@@ -0,0 +1,252 @@
+#
+# tk/listbox.rb : treat listbox widget
+#
+require 'tk'
+require 'tk/scrollable'
+require 'tk/txtwin_abst'
+
+module TkTreatListItemFont
+  include TkTreatItemFont
+
+  ItemCMD = ['itemconfigure'.freeze, TkComm::None].freeze
+  def __conf_cmd(idx)
+    ItemCMD[idx]
+  end
+
+  def __item_pathname(tagOrId)
+    self.path + ';' + tagOrId.to_s
+  end
+
+  private :__conf_cmd, :__item_pathname
+end
+
+
+class TkListbox<TkTextWin
+  include TkTreatListItemFont
+  include Scrollable
+
+  TkCommandNames = ['listbox'.freeze].freeze
+  WidgetClassName = 'Listbox'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('listbox', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('listbox', @path)
+    end
+  end
+  private :create_self
+
+  def activate(y)
+    tk_send_without_enc('activate', y)
+    self
+  end
+  def curselection
+    list(tk_send_without_enc('curselection'))
+  end
+  def get(first, last=nil)
+    if last
+      tk_split_simplelist(_fromUTF8(tk_send_without_enc('get', first, last)))
+    else
+      _fromUTF8(tk_send_without_enc('get', first))
+    end
+  end
+  def nearest(y)
+    tk_send_without_enc('nearest', y).to_i
+  end
+  def size
+    tk_send_without_enc('size').to_i
+  end
+  def selection_anchor(index)
+    tk_send_without_enc('selection', 'anchor', index)
+    self
+  end
+  def selection_clear(first, last=None)
+    tk_send_without_enc('selection', 'clear', first, last)
+    self
+  end
+  def selection_includes(index)
+    bool(tk_send_without_enc('selection', 'includes', index))
+  end
+  def selection_set(first, last=None)
+    tk_send_without_enc('selection', 'set', first, last)
+    self
+  end
+
+  def index(index)
+    tk_send_without_enc('index', index).to_i
+  end
+
+  def itemcget(index, key)
+    case key.to_s
+    when 'text', 'label', 'show'
+      _fromUTF8(tk_send_without_enc('itemcget', index, "-#{key}"))
+    when 'font', 'kanjifont'
+      #fnt = tk_tcl2ruby(tk_send('itemcget', index, "-#{key}"))
+      fnt = tk_tcl2ruby(_fromUTF8(tk_send_without_enc('itemcget', index, 
+						      '-font')))
+      unless fnt.kind_of?(TkFont)
+	fnt = tagfontobj(index, fnt)
+      end
+      if key.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
+	# obsolete; just for compatibility
+	fnt.kanji_font
+      else
+	fnt
+      end
+    else
+      tk_tcl2ruby(_fromUTF8(tk_send_without_enc('itemcget', index, "-#{key}")))
+    end
+  end
+  def itemconfigure(index, key, val=None)
+    if key.kind_of? Hash
+      if (key['font'] || key[:font] || 
+          key['kanjifont'] || key[:kanjifont] || 
+	  key['latinfont'] || key[:latinfont] || 
+          key['asciifont'] || key[:asciifont] )
+	tagfont_configure(index, _symbolkey2str(key))
+      else
+	tk_send_without_enc('itemconfigure', index, *hash_kv(key, true))
+      end
+
+    else
+      if (key == 'font' || key == :font || 
+          key == 'kanjifont' || key == :kanjifont || 
+	  key == 'latinfont' || key == :latinfont || 
+          key == 'asciifont' || key == :asciifont )
+	if val == None
+	  tagfontobj(index)
+	else
+	  tagfont_configure(index, {key=>val})
+	end
+      else
+	tk_call('itemconfigure', index, "-#{key}", val)
+      end
+    end
+    self
+  end
+
+  def itemconfiginfo(index, key=nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+	case key.to_s
+	when 'text', 'label', 'show'
+	  conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('itemconfigure',index,"-#{key}")))
+	when 'font', 'kanjifont'
+	  conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('itemconfigure',index,"-#{key}")))
+	  conf[4] = tagfont_configinfo(index, conf[4])
+	else
+	  conf = tk_split_list(_fromUTF8(tk_send_without_enc('itemconfigure',index,"-#{key}")))
+	end
+	conf[0] = conf[0][1..-1]
+	conf
+      else
+	ret = tk_split_simplelist(_fromUTF8(tk_send_without_enc('itemconfigure', index))).collect{|conflist|
+	  conf = tk_split_simplelist(conflist)
+	  conf[0] = conf[0][1..-1]
+	  case conf[0]
+	  when 'text', 'label', 'show'
+	  else
+	    if conf[3]
+	      if conf[3].index('{')
+		conf[3] = tk_split_list(conf[3]) 
+	      else
+		conf[3] = tk_tcl2ruby(conf[3]) 
+	      end
+	    end
+	    if conf[4]
+	      if conf[4].index('{')
+		conf[4] = tk_split_list(conf[4]) 
+	      else
+		conf[4] = tk_tcl2ruby(conf[4]) 
+	      end
+	    end
+	  end
+	  conf[1] = conf[1][1..-1] if conf.size == 2 # alias info
+	  conf
+	}
+	fontconf = ret.assoc('font')
+	if fontconf
+	  ret.delete_if{|item| item[0] == 'font' || item[0] == 'kanjifont'}
+	  fontconf[4] = tagfont_configinfo(index, fontconf[4])
+	  ret.push(fontconf)
+	else
+	  ret
+	end
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+	case key.to_s
+	when 'text', 'label', 'show'
+	  conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('itemconfigure',index,"-#{key}")))
+	when 'font', 'kanjifont'
+	  conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('itemconfigure',index,"-#{key}")))
+	  conf[4] = tagfont_configinfo(index, conf[4])
+	else
+	  conf = tk_split_list(_fromUTF8(tk_send_without_enc('itemconfigure',index,"-#{key}")))
+	end
+	key = conf.shift[1..-1]
+	{ key => conf }
+      else
+	ret = {}
+	tk_split_simplelist(_fromUTF8(tk_send_without_enc('itemconfigure', index))).each{|conflist|
+	  conf = tk_split_simplelist(conflist)
+	  key = conf.shift[1..-1]
+	  case key
+	  when 'text', 'label', 'show'
+	  else
+	    if conf[2]
+	      if conf[2].index('{')
+		conf[2] = tk_split_list(conf[2]) 
+	      else
+		conf[2] = tk_tcl2ruby(conf[2]) 
+	      end
+	    end
+	    if conf[3]
+	      if conf[3].index('{')
+		conf[3] = tk_split_list(conf[3]) 
+	      else
+		conf[3] = tk_tcl2ruby(conf[3]) 
+	      end
+	    end
+	  end
+	  if conf.size == 1
+	    ret[key] = conf[0][1..-1]  # alias info
+	  else
+	    ret[key] = conf
+	  end
+	}
+	fontconf = ret['font']
+	if fontconf
+	  ret.delete('font')
+	  ret.delete('kanjifont')
+	  fontconf[3] = tagfont_configinfo(index, fontconf[3])
+	  ret['font'] = fontconf
+	end
+	ret
+      end
+    end
+  end
+
+  def current_itemconfiginfo(index, key=nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+	conf = itemconfiginfo(index, key)
+	{conf[0] => conf[4]}
+      else
+	ret = {}
+	itemconfiginfo(index).each{|conf|
+	  ret[conf[0]] = conf[4] if conf.size > 2
+	}
+	ret
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      ret = {}
+      itemconfiginfo(index, key).each{|k, conf|
+	ret[k] = conf[-1] if conf.kind_of?(Array)
+      }
+      ret
+    end
+  end
+end

ext/tk/lib/tk/macpkg.rb

@@ -0,0 +1,68 @@
+#
+#   tk/macpkg.rb : methods for Tcl/Tk packages for Macintosh
+#                     2000/11/22 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+#     ATTENTION !!
+#         This is NOT TESTED. Because I have no test-environment.
+#
+#
+require 'tk'
+
+module Tk
+  def Tk.load_tclscript_rsrc(resource_name, file=None)
+    # Mac only
+    tk_call('source', '-rsrc', resource_name, file)
+  end
+
+  def Tk.load_tclscript_rsrcid(resource_id, file=None)
+    # Mac only
+    tk_call('source', '-rsrcid', resource_id, file)
+  end
+end
+
+module TkMacResource
+  extend Tk
+  extend TkMacResource
+
+  TkCommandNames = ['resource'.freeze].freeze
+
+  tk_call_without_enc('package', 'require', 'resource')
+
+  def close(rsrcRef)
+    tk_call('resource', 'close', rsrcRef)
+  end
+
+  def delete(rsrcType, opts=nil)
+    tk_call('resource', 'delete', *(hash_kv(opts) << rsrcType))
+  end
+
+  def files(rsrcRef=nil)
+    if rsrcRef
+      tk_call('resource', 'files', rsrcRef)
+    else
+      tk_split_simplelist(tk_call('resource', 'files'))
+    end
+  end
+
+  def list(rsrcType, rsrcRef=nil)
+    tk_split_simplelist(tk_call('resource', 'list', rsrcType, rsrcRef))
+  end
+
+  def open(fname, access=nil)
+    tk_call('resource', 'open', fname, access)
+  end
+
+  def read(rsrcType, rsrcID, rsrcRef=nil)
+    tk_call('resource', 'read', rsrcType, rsrcID, rsrcRef)
+  end
+
+  def types(rsrcRef=nil)
+    tk_split_simplelist(tk_call('resource', 'types', rsrcRef))
+  end
+
+  def write(rsrcType, data, opts=nil)
+    tk_call('resource', 'write', *(hash_kv(opts) << rsrcType << data))
+  end
+
+  module_function :close, :delete, :files, :list, :open, :read, :types, :write
+end

ext/tk/lib/tk/menu.rb

@@ -0,0 +1,460 @@
+#
+# tk/menu.rb : treat menu and menubutton
+#
+require 'tk'
+
+module TkTreatMenuEntryFont
+  include TkTreatItemFont
+
+  ItemCMD = ['entryconfigure'.freeze, TkComm::None].freeze
+  def __conf_cmd(idx)
+    ItemCMD[idx]
+  end
+  
+  def __item_pathname(tagOrId)
+    self.path + ';' + tagOrId.to_s
+  end
+
+  private :__conf_cmd, :__item_pathname
+end
+
+class TkMenu<TkWindow
+  include TkTreatMenuEntryFont
+
+  TkCommandNames = ['menu'.freeze].freeze
+  WidgetClassName = 'Menu'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('menu', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('menu', @path)
+    end
+  end
+  private :create_self
+
+  def activate(index)
+    tk_send_without_enc('activate', _get_eval_enc_str(index))
+    self
+  end
+  def add(type, keys=nil)
+    tk_send_without_enc('add', type, *hash_kv(keys, true))
+    self
+  end
+  def add_cascade(keys=nil)
+    add('cascade', keys)
+  end
+  def add_checkbutton(keys=nil)
+    add('checkbutton', keys)
+  end
+  def add_command(keys=nil)
+    add('command', keys)
+  end
+  def add_radiobutton(keys=nil)
+    add('radiobutton', keys)
+  end
+  def add_separator(keys=nil)
+    add('separator', keys)
+  end
+  def index(index)
+    ret = tk_send_without_enc('index', _get_eval_enc_str(index))
+    (ret == 'none')? nil: number(ret)
+  end
+  def invoke(index)
+    _fromUTF8(tk_send_without_enc('invoke', _get_eval_enc_str(index)))
+  end
+  def insert(index, type, keys=nil)
+    tk_send_without_enc('insert', _get_eval_enc_str(index), 
+			type, *hash_kv(keys, true))
+    self
+  end
+  def delete(first, last=nil)
+    if last
+      tk_send_without_enc('delete', _get_eval_enc_str(first), 
+			  _get_eval_enc_str(last))
+    else
+      tk_send_without_enc('delete', _get_eval_enc_str(first))
+    end
+    self
+  end
+  def popup(x, y, index=nil)
+    if index
+      tk_call_without_enc('tk_popup', path, x, y, 
+			  _get_eval_enc_str(index))
+    else
+      tk_call_without_enc('tk_popup', path, x, y)
+    end
+    self
+  end
+  def post(x, y)
+    _fromUTF8(tk_send_without_enc('post', x, y))
+  end
+  def postcascade(index)
+    tk_send_without_enc('postcascade', _get_eval_enc_str(index))
+    self
+  end
+  def postcommand(cmd=Proc.new)
+    configure_cmd 'postcommand', cmd
+    self
+  end
+  def set_focus
+    tk_call_without_enc('tk_menuSetFocus', path)
+    self
+  end
+  def tearoffcommand(cmd=Proc.new)
+    configure_cmd 'tearoffcommand', cmd
+    self
+  end
+  def menutype(index)
+    tk_send_without_enc('type', _get_eval_enc_str(index))
+  end
+  def unpost
+    tk_send_without_enc('unpost')
+    self
+  end
+  def yposition(index)
+    number(tk_send_without_enc('yposition', _get_eval_enc_str(index)))
+  end
+  def entrycget(index, key)
+    case key.to_s
+    when 'text', 'label', 'show'
+      _fromUTF8(tk_send_without_enc('entrycget', 
+				    _get_eval_enc_str(index), "-#{key}"))
+    when 'font', 'kanjifont'
+      #fnt = tk_tcl2ruby(tk_send('entrycget', index, "-#{key}"))
+      fnt = tk_tcl2ruby(_fromUTF8(tk_send_without_enc('entrycget', _get_eval_enc_str(index), '-font')))
+      unless fnt.kind_of?(TkFont)
+	fnt = tagfontobj(index, fnt)
+      end
+      if key.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
+	# obsolete; just for compatibility
+	fnt.kanji_font
+      else
+	fnt
+      end
+    else
+      tk_tcl2ruby(_fromUTF8(tk_send_without_enc('entrycget', _get_eval_enc_str(index), "-#{key}")))
+    end
+  end
+  def entryconfigure(index, key, val=None)
+    if key.kind_of? Hash
+      if (key['font'] || key[:font] || 
+          key['kanjifont'] || key[:kanjifont] || 
+	  key['latinfont'] || key[:latinfont] || 
+          key['asciifont'] || key[:asciifont])
+	tagfont_configure(index, _symbolkey2str(key))
+      else
+	tk_send_without_enc('entryconfigure', _get_eval_enc_str(index), 
+			    *hash_kv(key, true))
+      end
+
+    else
+      if (key == 'font' || key == :font || 
+          key == 'kanjifont' || key == :kanjifont || 
+	  key == 'latinfont' || key == :latinfont || 
+          key == 'asciifont' || key == :asciifont )
+	if val == None
+	  tagfontobj(index)
+	else
+	  tagfont_configure(index, {key=>val})
+	end
+      else
+	tk_call('entryconfigure', index, "-#{key}", val)
+      end
+    end
+    self
+  end
+
+  def entryconfiginfo(index, key=nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+	case key.to_s
+	when 'text', 'label', 'show'
+	  conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('entryconfigure',_get_eval_enc_str(index),"-#{key}")))
+	when 'font', 'kanjifont'
+	  conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('entryconfigure',_get_eval_enc_str(index),"-#{key}")))
+	  conf[4] = tagfont_configinfo(index, conf[4])
+	else
+	  conf = tk_split_list(_fromUTF8(tk_send_without_enc('entryconfigure',_get_eval_enc_str(index),"-#{key}")))
+	end
+	conf[0] = conf[0][1..-1]
+	conf
+      else
+	ret = tk_split_simplelist(_fromUTF8(tk_send_without_enc('entryconfigure', _get_eval_enc_str(index)))).collect{|conflist|
+	  conf = tk_split_simplelist(conflist)
+	  conf[0] = conf[0][1..-1]
+	  case conf[0]
+	  when 'text', 'label', 'show'
+	  else
+	    if conf[3]
+	      if conf[3].index('{')
+		conf[3] = tk_split_list(conf[3]) 
+	      else
+		conf[3] = tk_tcl2ruby(conf[3]) 
+	      end
+	    end
+	    if conf[4]
+	      if conf[4].index('{')
+		conf[4] = tk_split_list(conf[4]) 
+	      else
+		conf[4] = tk_tcl2ruby(conf[4]) 
+	      end
+	    end
+	  end
+	  conf[1] = conf[1][1..-1] if conf.size == 2 # alias info
+	  conf
+	}
+	if fontconf
+	  ret.delete_if{|item| item[0] == 'font' || item[0] == 'kanjifont'}
+	  fontconf[4] = tagfont_configinfo(index, fontconf[4])
+	  ret.push(fontconf)
+	else
+	  ret
+	end
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+	case key.to_s
+	when 'text', 'label', 'show'
+	  conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('entryconfigure',_get_eval_enc_str(index),"-#{key}")))
+	when 'font', 'kanjifont'
+	  conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('entryconfigure',_get_eval_enc_str(index),"-#{key}")))
+	  conf[4] = tagfont_configinfo(index, conf[4])
+	else
+	  conf = tk_split_list(_fromUTF8(tk_send_without_enc('entryconfigure',_get_eval_enc_str(index),"-#{key}")))
+	end
+	key = conf.shift[1..-1]
+	{ key => conf }
+      else
+	ret = {}
+	tk_split_simplelist(_fromUTF8(tk_send_without_enc('entryconfigure', _get_eval_enc_str(index)))).each{|conflist|
+	  conf = tk_split_simplelist(conflist)
+	  key = conf.shift[1..-1]
+	  case key
+	  when 'text', 'label', 'show'
+	  else
+	    if conf[2]
+	      if conf[2].index('{')
+		conf[2] = tk_split_list(conf[2]) 
+	      else
+		conf[2] = tk_tcl2ruby(conf[2]) 
+	      end
+	    end
+	    if conf[3]
+	      if conf[3].index('{')
+		conf[3] = tk_split_list(conf[3]) 
+	      else
+		conf[3] = tk_tcl2ruby(conf[3]) 
+	      end
+	    end
+	  end
+	  if conf.size == 1
+	    ret[key] = conf[0][1..-1]  # alias info
+	  else
+	    ret[key] = conf
+	  end
+	}
+	fontconf = ret['font']
+	if fontconf
+	  ret.delete('font')
+	  ret.delete('kanjifont')
+	  fontconf[3] = tagfont_configinfo(index, fontconf[3])
+	  ret['font'] = fontconf
+	end
+	ret
+      end
+    end
+  end
+
+  def current_entryconfiginfo(index, key=nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+	conf = entryconfiginfo(index, key)
+	{conf[0] => conf[4]}
+      else
+	ret = {}
+	entryconfiginfo(index).each{|conf|
+	  ret[conf[0]] = conf[4] if conf.size > 2
+	}
+	ret
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      ret = {}
+      entryconfiginfo(index, key).each{|k, conf|
+	ret[k] = conf[-1] if conf.kind_of?(Array)
+      }
+      ret
+    end
+  end
+end
+
+
+class TkMenuClone<TkMenu
+  def initialize(parent, type=None)
+    widgetname = nil
+    if parent.kind_of? Hash
+      keys = _symbolkey2str(parent)
+      parent = keys.delete('parent')
+      widgetname = keys.delete('widgetname')
+      type = keys.delete('type'); type = None unless type
+    end
+    unless parent.kind_of?(TkMenu)
+      fail ArgumentError, "parent must be TkMenu"
+    end
+    @parent = parent
+    install_win(@parent.path, widgetname)
+    tk_call_without_enc(@parent.path, 'clone', @path, type)
+  end
+end
+
+
+module TkSystemMenu
+  def initialize(parent, keys=nil)
+    if parent.kind_of? Hash
+      keys = _symbolkey2str(parent)
+      parent = keys.delete('parent')
+    end
+    unless parent.kind_of? TkMenu
+      fail ArgumentError, "parent must be a TkMenu object"
+    end
+    # @path = Kernel.format("%s.%s", parent.path, self.class::SYSMENU_NAME)
+    @path = parent_path + '.' + self.class::SYSMENU_NAME
+    #TkComm::Tk_WINDOWS[@path] = self
+    TkCore::INTERP.tk_windows[@path] = self
+    if self.method(:create_self).arity == 0
+      p 'create_self has no arg' if $DEBUG
+      create_self
+      configure(keys) if keys
+    else
+      p 'create_self has an arg' if $DEBUG
+      create_self(keys)
+    end
+  end
+end
+
+
+class TkSysMenu_Help<TkMenu
+  # for all platform
+  include TkSystemMenu
+  SYSMENU_NAME = 'help'
+end
+
+
+class TkSysMenu_System<TkMenu
+  # for Windows
+  include TkSystemMenu
+  SYSMENU_NAME = 'system'
+end
+
+
+class TkSysMenu_Apple<TkMenu
+  # for Machintosh
+  include TkSystemMenu
+  SYSMENU_NAME = 'apple'
+end
+
+
+class TkMenubutton<TkLabel
+  TkCommandNames = ['menubutton'.freeze].freeze
+  WidgetClassName = 'Menubutton'.freeze
+  WidgetClassNames[WidgetClassName] = self
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('menubutton', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('menubutton', @path)
+    end
+  end
+  private :create_self
+end
+
+
+class TkOptionMenubutton<TkMenubutton
+  TkCommandNames = ['tk_optionMenu'.freeze].freeze
+
+  class OptionMenu<TkMenu
+    def initialize(path)  #==> return value of tk_optionMenu
+      @path = path
+      #TkComm::Tk_WINDOWS[@path] = self
+      TkCore::INTERP.tk_windows[@path] = self
+    end
+  end
+
+  def initialize(parent=nil, var=TkVariable.new, firstval=nil, *vals)
+    if parent.kind_of? Hash
+       keys = _symbolkey2str(parent)
+       parent = keys['parent']
+       var = keys['variable'] if keys['variable']
+       firstval, *vals = keys['values']
+    end
+    fail 'variable option must be TkVariable' unless var.kind_of? TkVariable
+    @variable = var
+    firstval = @variable.value unless firstval
+    @variable.value = firstval
+    install_win(if parent then parent.path end)
+    @menu = OptionMenu.new(tk_call('tk_optionMenu', @path, @variable.id, 
+				   firstval, *vals))
+  end
+
+  def value
+    @variable.value
+  end
+
+  def activate(index)
+    @menu.activate(index)
+    self
+  end
+  def add(value)
+    @menu.add('radiobutton', 'variable'=>@variable, 
+	      'label'=>value, 'value'=>value)
+    self
+  end
+  def index(index)
+    @menu.index(index)
+  end
+  def invoke(index)
+    @menu.invoke(index)
+  end
+  def insert(index, value)
+    @menu.add(index, 'radiobutton', 'variable'=>@variable, 
+	      'label'=>value, 'value'=>value)
+    self
+  end
+  def delete(index, last=None)
+    @menu.delete(index, last)
+    self
+  end
+  def yposition(index)
+    @menu.yposition(index)
+  end
+  def menu
+    @menu
+  end
+  def menucget(key)
+    @menu.cget(key)
+  end
+  def menuconfigure(key, val=None)
+    @menu.configure(key, val)
+    self
+  end
+  def menuconfiginfo(key=nil)
+    @menu.configinfo(key)
+  end
+  def current_menuconfiginfo(key=nil)
+    @menu.current_configinfo(key)
+  end
+  def entrycget(index, key)
+    @menu.entrycget(index, key)
+  end
+  def entryconfigure(index, key, val=None)
+    @menu.entryconfigure(index, key, val)
+    self
+  end
+  def entryconfiginfo(index, key=nil)
+    @menu.entryconfiginfo(index, key)
+  end
+  def current_entryconfiginfo(index, key=nil)
+    @menu.current_entryconfiginfo(index, key)
+  end
+end

ext/tk/lib/tk/menubar.rb

@@ -0,0 +1,144 @@
+#
+# tk/menubar.rb
+#
+# Copyright (C) 1998 maeda shugo. All rights reserved. 
+# This file can be distributed under the terms of the Ruby.
+
+# Usage:
+#
+# menu_spec = [
+#   [['File', 0],
+#     ['Open', proc{puts('Open clicked')}, 0],
+#     '---',
+#     ['Quit', proc{exit}, 0]],
+#   [['Edit', 0],
+#     ['Cut', proc{puts('Cut clicked')}, 2],
+#     ['Copy', proc{puts('Copy clicked')}, 0],
+#     ['Paste', proc{puts('Paste clicked')}, 0]]
+# ]
+# menubar = TkMenubar.new(nil, menu_spec,
+# 			'tearoff'=>false,
+# 			'foreground'=>'grey40',
+# 			'activeforeground'=>'red',
+# 			'font'=>'-adobe-helvetica-bold-r-*--12-*-iso8859-1')
+# menubar.pack('side'=>'top', 'fill'=>'x')
+#
+#
+# OR
+#
+#
+# menubar = TkMenubar.new
+# menubar.add_menu([['File', 0],
+# 		   ['Open', proc{puts('Open clicked')}, 0],
+# 		   '---',
+# 		   ['Quit', proc{exit}, 0]])
+# menubar.add_menu([['Edit', 0],
+# 		   ['Cut', proc{puts('Cut clicked')}, 2],
+# 		   ['Copy', proc{puts('Copy clicked')}, 0],
+# 		   ['Paste', proc{puts('Paste clicked')}, 0]])
+# menubar.configure('tearoff', false)
+# menubar.configure('foreground', 'grey40')
+# menubar.configure('activeforeground', 'red')
+# menubar.configure('font', '-adobe-helvetica-bold-r-*--12-*-iso8859-1')
+# menubar.pack('side'=>'top', 'fill'=>'x')
+
+# The format of the menu_spec is:
+# [
+#   [
+#     [button text, underline, accelerator],
+#     [menu label, command, underline, accelerator],
+#     '---', # separator
+#     ...
+#   ],
+#   ...
+# ]
+
+# underline and accelerator are optional parameters.
+# Hashes are OK instead of Arrays.
+
+# To use add_menu, configuration must be done by calling configure after
+# adding all menus by add_menu, not by the constructor arguments.
+
+require 'tk'
+require 'tk/frame'
+
+class TkMenubar<TkFrame
+  
+  include TkComposite
+  
+  def initialize(parent = nil, spec = nil, options = nil)
+    if parent.kind_of? Hash
+      options = _symbolkey2str(parent)
+      spec = options.delete('spec')
+      super(options)
+    else
+      super(parent, options)
+    end
+
+    @menus = []
+    
+    if spec
+      for menu_info in spec
+	add_menu(menu_info)
+      end
+    end
+    
+    if options
+      for key, value in options
+	configure(key, value)
+      end
+    end
+  end
+
+  def add_menu(menu_info)
+    btn_info = menu_info.shift
+    mbtn = TkMenubutton.new(@frame)
+    
+    if btn_info.kind_of?(Hash)
+      for key, value in btn_info
+	mbtn.configure(key, value)
+      end
+    elsif btn_info.kind_of?(Array)
+      mbtn.configure('text', btn_info[0]) if btn_info[0]
+      mbtn.configure('underline', btn_info[1]) if btn_info[1]
+      mbtn.configure('accelerator', btn_info[2]) if btn_info[2]
+    else
+      mbtn.configure('text', btn_info)
+    end
+    
+    menu = TkMenu.new(mbtn)
+    
+    for item_info in menu_info
+      if item_info.kind_of?(Hash)
+	menu.add('command', item_info)
+      elsif item_info.kind_of?(Array)
+	options = {}
+	options['label'] = item_info[0] if item_info[0]
+	options['command'] = item_info[1] if item_info[1]
+	options['underline'] = item_info[2] if item_info[2]
+	options['accelerator'] = item_info[3] if item_info[3]
+	menu.add('command', options)
+      elsif /^-+$/ =~ item_info
+	menu.add('sep')
+      else
+	menu.add('command', 'label' => item_info)
+      end
+    end
+    
+    mbtn.menu(menu)
+    @menus.push([mbtn, menu])
+    delegate('tearoff', menu)
+    delegate('foreground', mbtn, menu)
+    delegate('background', mbtn, menu)
+    delegate('disabledforeground', mbtn, menu)
+    delegate('activeforeground', mbtn, menu)
+    delegate('activebackground', mbtn, menu)
+    delegate('font', mbtn, menu)
+    delegate('kanjifont', mbtn, menu)
+    mbtn.pack('side' => 'left')
+  end
+  
+  def [](index)
+    return @menus[index]
+  end
+end

ext/tk/lib/tk/message.rb

@@ -0,0 +1,19 @@
+#
+# tk/message.rb : treat message widget
+#
+require 'tk'
+require 'tk/label'
+
+class TkMessage<TkLabel
+  TkCommandNames = ['message'.freeze].freeze
+  WidgetClassName = 'Message'.freeze
+  WidgetClassNames[WidgetClassName] = self
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('message', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('message', @path)
+    end
+  end
+  private :create_self
+end

ext/tk/lib/tk/mngfocus.rb

@@ -0,0 +1,33 @@
+#
+#   tk/mngfocus.rb : methods for Tcl/Tk standard library 'focus.tcl'
+#                           by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+require 'tk'
+
+module TkManageFocus
+  extend Tk
+
+  TkCommandNames = [
+    'tk_focusFollowMouse'.freeze, 
+    'tk_focusNext'.freeze, 
+    'tk_focusPrev'.freeze
+  ].freeze
+
+  def TkManageFocus.followsMouse
+    tk_call_without_enc('tk_focusFollowsMouse')
+  end
+
+  def TkManageFocus.next(window)
+    tk_tcl2ruby(tk_call('tk_focusNext', window))
+  end
+  def focusNext
+    TkManageFocus.next(self)
+  end
+
+  def TkManageFocus.prev(window)
+    tk_tcl2ruby(tk_call('tk_focusPrev', window))
+  end
+  def focusPrev
+    TkManageFocus.prev(self)
+  end
+end

ext/tk/lib/tk/msgcat.rb

@@ -0,0 +1,268 @@
+#
+#   tk/msgcat.rb : methods for Tcl message catalog
+#                     by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+require 'tk'
+
+#class TkMsgCatalog
+class TkMsgCatalog < TkObject
+  include TkCore
+  extend Tk
+  #extend TkMsgCatalog
+
+  TkCommandNames = [
+    '::msgcat::mc'.freeze, 
+    '::msgcat::mcmax'.freeze, 
+    '::msgcat::mclocale'.freeze, 
+    '::msgcat::mcpreferences'.freeze, 
+    '::msgcat::mcload'.freeze, 
+    '::msgcat::mcset'.freeze, 
+    '::msgcat::mcmset'.freeze, 
+    '::msgcat::mcunknown'.freeze
+  ].freeze
+
+  tk_call_without_enc('package', 'require', 'Tcl', '8.2')
+
+  if self.const_defined? :FORCE_VERSION
+    tk_call_without_enc('package', 'require', 'msgcat', FORCE_VERSION)
+  else
+    tk_call_without_enc('package', 'require', 'msgcat')
+  end
+
+  MSGCAT_EXT = '.msg'
+
+  UNKNOWN_CBTBL = Hash.new{|hash,key| hash[key] = {}}.taint
+
+  TkCore::INTERP.add_tk_procs('::msgcat::mcunknown', 'args', <<-'EOL')
+    if {[set st [catch {eval {ruby_cmd TkMsgCatalog callback} [namespace current] $args} ret]] != 0} {
+       #return -code $st $ret
+       set idx [string first "\n\n" $ret]
+       if {$idx > 0} {
+          return -code $st \
+                 -errorinfo [string range $ret [expr $idx + 2] \
+                                               [string length $ret]] \
+                 [string range $ret 0 [expr $idx - 1]]
+       } else {
+          return -code $st $ret
+       }
+    } else {
+	return $ret
+    }
+  EOL
+
+  def self.callback(namespace, locale, src_str)
+    cmd_tbl = TkMsgCatalog::UNKNOWN_CBTBL[TkCore::INTERP.__getip]
+    cmd = cmd_tbl[namespace]
+    cmd = cmd_tbl['::'] unless cmd  # use global scope as interp default
+    return src_str unless cmd       # no cmd -> return src-str (default action)
+    begin
+      cmd.call(locale, src_str)
+    rescue Exception => e
+      begin
+	msg = _toUTF8(e.class.inspect) + ': ' + 
+	      _toUTF8(e.message) + "\n" + 
+	      "\n---< backtrace of Ruby side >-----\n" + 
+	      _toUTF8(e.backtrace.join("\n")) + 
+	      "\n---< backtrace of Tk side >-------"
+	msg.instance_variable_set(:@encoding, 'utf-8')
+      rescue Exception
+	msg = e.class.inspect + ': ' + e.message + "\n" + 
+	      "\n---< backtrace of Ruby side >-----\n" + 
+	      e.backtrace.join("\n") + 
+	      "\n---< backtrace of Tk side >-------"
+      end
+      fail(e, msg)
+    end
+  end
+
+  def initialize(namespace = nil)
+    if namespace.kind_of?(TkNamespace)
+      @namespace = namespace
+    elsif namespace == nil
+      @namespace = TkNamespace.new('::')  # global namespace
+    else
+      @namespace = TkNamespace.new(namespace)
+    end
+    @path = @namespace.path
+
+    @msgcat_ext = '.msg'
+  end
+  attr_accessor :msgcat_ext
+
+  def method_missing(id, *args)
+    # locale(src, trans) ==> set_translation(locale, src, trans)
+    loc = id.id2name
+    case args.length
+    when 0 # set locale
+      self.locale=(loc)
+
+    when 1 # src only, or trans_list
+      if args[0].kind_of?(Array)
+	# trans_list
+	#list = args[0].collect{|src, trans|
+	#  [ Tk::UTF8_String.new(src), Tk::UTF8_String.new(trans) ]
+	#}
+	self.set_translation_list(loc, args[0])
+      else
+	# src
+	#self.set_translation(loc, Tk::UTF8_String.new(args[0]))
+	self.set_translation(loc, args[0])
+      end
+
+    when 2 # src and trans, or, trans_list and enc
+      if args[0].kind_of?(Array)
+      else
+	#self.set_translation(loc, args[0], Tk::UTF8_String.new(args[1]))
+	self.set_translation(loc, *args)
+      end
+
+    when 3 # src and trans and enc
+      self.set_translation(loc, *args)
+
+    else
+      fail NameError, "undefined method `#{name}' for #{self.to_s}", error_at
+
+    end
+  end
+
+  # *args ::= form, arg, arg, ...
+  def self.translate(*args)
+    dst = args.collect{|src|
+      tk_call_without_enc('::msgcat::mc', _get_eval_string(src, true))
+    }
+    Tk.UTF8_String(sprintf(*dst))
+  end
+  class << self
+    alias mc translate
+    alias [] translate
+  end
+  def translate(*args)
+    dst = args.collect{|src|
+      @namespace.eval{tk_call_without_enc('::msgcat::mc', 
+					  _get_eval_string(src, true))}
+    }
+    Tk.UTF8_String(sprintf(*dst))
+  end
+  alias mc translate
+  alias [] translate
+
+  def self.maxlen(*src_strings)
+    tk_call('::msgcat::mcmax', *src_strings).to_i
+  end
+  def maxlen(*src_strings)
+    @namespace.eval{tk_call('::msgcat::mcmax', *src_strings).to_i}
+  end
+
+  def self.locale
+    tk_call('::msgcat::mclocale')
+  end
+  def locale
+    @namespace.eval{tk_call('::msgcat::mclocale')}
+  end
+
+  def self.locale=(locale)
+    tk_call('::msgcat::mclocale', locale)
+  end
+  def locale=(locale)
+    @namespace.eval{tk_call('::msgcat::mclocale', locale)}
+  end
+
+  def self.preferences
+    tk_split_simplelist(tk_call('::msgcat::mcpreferences'))
+  end
+  def preferences
+    tk_split_simplelist(@namespace.eval{tk_call('::msgcat::mcpreferences')})
+  end
+
+  def self.load_tk(dir)
+    number(tk_call('::msgcat::mcload', dir))
+  end
+
+  def self.load_rb(dir)
+    count = 0
+    preferences().each{|loc|
+      file = File.join(dir, loc + self::MSGCAT_EXT)
+      if File.readable?(file)
+	count += 1
+	eval(open(file){|f| f.read})
+      end
+    }
+    count
+  end
+
+  def load_tk(dir)
+    number(@namespace.eval{tk_call('::msgcat::mcload', dir)})
+  end
+
+  def load_rb(dir)
+    count = 0
+    preferences().each{|loc|
+      file = File.join(dir, loc + @msgcat_ext)
+      if File.readable?(file)
+	count += 1
+	@namespace.eval(open(file){|f| f.read})
+      end
+    }
+    count
+  end
+
+  def self.load(dir)
+    self.load_rb(dir)
+  end
+  alias load load_rb
+
+  def self.set_translation(locale, src_str, trans_str=None, enc='utf-8')
+    trans_str = Tk.UTF8_String(_toUTF8(trans_str, enc)) if trans_str != None
+    Tk.UTF8_String(tk_call_without_enc('::msgcat::mcset', 
+				       locale, 
+				       _get_eval_string(src_str, true), 
+				       trans_str))
+  end
+  def set_translation(locale, src_str, trans_str=None, enc='utf-8')
+    trans_str = Tk.UTF8_String(_toUTF8(trans_str, enc)) if trans_str != None
+    Tk.UTF8_String(@namespace.eval{
+		     tk_call_without_enc('::msgcat::mcset', 
+					 locale, 
+					 _get_eval_string(src_str, true), 
+					 trans_str)
+		   })
+  end
+
+  def self.set_translation_list(locale, trans_list, enc='utf-8')
+    # trans_list ::= [ [src, trans], [src, trans], ... ]
+    list = []
+    trans_list.each{|src, trans|
+      if trans && trans != None
+	list << _get_eval_string(src, true) 
+	list << Tk.UTF8_Stirng(_toUTF8(trans, enc))
+      else
+	list << _get_eval_string(src, true) << ''
+      end
+    }
+    number(tk_call_without_enc('::msgcat::mcmset', locale, list))
+  end
+  def set_translation_list(locale, trans_list, enc='utf-8')
+    # trans_list ::= [ [src, trans], [src, trans], ... ]
+    list = []
+    trans_list.each{|src, trans|
+      if trans && trans != None
+	list << _get_eval_string(src, true) 
+	list << Tk.UTF8_String(_toUTF8(trans, enc))
+      else
+	list << _get_eval_string(src, true) << ''
+      end
+    }
+    number(@namespace.eval{
+	     tk_call_without_enc('::msgcat::mcmset', locale, list)
+	   })
+  end
+
+  def self.def_unknown_proc(cmd=Proc.new)
+    TkMsgCatalog::UNKNOWN_CBTBL[TkCore::INTERP.__getip]['::'] = cmd
+  end
+  def def_unknown_proc(cmd=Proc.new)
+    TkMsgCatalog::UNKNOWN_CBTBL[TkCore::INTERP.__getip][@namespace.path] = cmd
+  end
+end
+
+TkMsgCat = TkMsgCatalog

ext/tk/lib/tk/namespace.rb

@@ -0,0 +1,293 @@
+#
+#   tk/namespace.rb : methods to manipulate Tcl/Tk namespace
+#                           by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+require 'tk'
+
+class TkNamespace < TkObject
+  extend Tk
+
+  TkCommandNames = [
+    'namespace'.freeze, 
+  ].freeze
+
+  Tk_Namespace_ID_TBL = TkCore::INTERP.create_table
+  Tk_Namespace_ID = ["ns".freeze, "00000".taint].freeze
+
+  class ScopeArgs < Array
+    include Tk
+
+    # alias __tk_call             tk_call
+    # alias __tk_call_without_enc tk_call_without_enc
+    # alias __tk_call_with_enc    tk_call_with_enc
+    def tk_call(*args)
+      #super('namespace', 'eval', @namespace, *args)
+      args = args.collect{|arg| (s = _get_eval_string(arg))? s: ''}
+      super('namespace', 'eval', @namespace, 
+	    TkCore::INTERP._merge_tklist(*args))
+    end
+    def tk_call_without_enc(*args)
+      #super('namespace', 'eval', @namespace, *args)
+      args = args.collect{|arg| (s = _get_eval_string(arg))? s: ''}
+      super('namespace', 'eval', @namespace, 
+	    TkCore::INTERP._merge_tklist(*args))
+    end
+    def tk_call_with_enc(*args)
+      #super('namespace', 'eval', @namespace, *args)
+      args = args.collect{|arg| (s = _get_eval_string(arg))? s: ''}
+      super('namespace', 'eval', @namespace, 
+	    TkCore::INTERP._merge_tklist(*args))
+    end
+
+    def initialize(namespace, *args)
+      @namespace = namespace
+      super(args.size)
+      self.replace(args)
+    end
+  end
+
+  class NsCode < TkObject
+    def initialize(scope)
+      @scope = scope + ' '
+    end
+    def path
+      @scope
+    end
+    def to_eval
+      @scope
+    end
+    def call(*args)
+      TkCore::INTERP._eval_without_enc(@scope + array2tk_list(args))
+    end
+  end
+
+  alias __tk_call             tk_call
+  alias __tk_call_without_enc tk_call_without_enc
+  alias __tk_call_with_enc    tk_call_with_enc
+  def tk_call(*args)
+    #super('namespace', 'eval', @fullname, *args)
+    args = args.collect{|arg| (s = _get_eval_string(arg))? s: ''}
+    super('namespace', 'eval', @fullname, 
+	  TkCore::INTERP._merge_tklist(*args))
+  end
+  def tk_call_without_enc(*args)
+    #super('namespace', 'eval', @fullname, *args)
+    args = args.collect{|arg| (s = _get_eval_string(arg))? s: ''}
+    super('namespace', 'eval', @fullname,  
+	  TkCore::INTERP._merge_tklist(*args))
+  end
+  def tk_call_with_enc(*args)
+    #super('namespace', 'eval', @fullname, *args)
+    args = args.collect{|arg| (s = _get_eval_string(arg))? s: ''}
+    super('namespace', 'eval', @fullname, 
+	  TkCore::INTERP._merge_tklist(*args))
+  end
+  alias ns_tk_call             tk_call
+  alias ns_tk_call_without_enc tk_call_without_enc
+  alias ns_tk_call_with_enc    tk_call_with_enc
+
+  def initialize(name = nil, parent = nil)
+    unless name
+      name = Tk_Namespace_ID.join('')
+      Tk_Namespace_ID[1].succ!
+    end
+    name = __tk_call('namespace', 'current') if name == ''
+    if parent
+      if parent =~ /^::/
+	if name =~ /^::/
+	  @fullname = parent + name
+	else
+	  @fullname = parent +'::'+ name
+	end
+      else
+	ancestor = __tk_call('namespace', 'current')
+	ancestor = '' if ancestor == '::'
+	if name =~ /^::/
+	  @fullname = ancestor + '::' + parent + name
+	else
+	  @fullname = ancestor + '::'+ parent +'::'+ name
+	end
+      end
+    else # parent == nil
+      ancestor = __tk_call('namespace', 'current')
+      ancestor = '' if ancestor == '::'
+      if name =~ /^::/
+	@fullname = name
+      else
+	@fullname = ancestor + '::' + name
+      end
+    end
+    @path = @fullname
+    @parent = __tk_call('namespace', 'qualifiers', @fullname)
+    @name = __tk_call('namespace', 'tail', @fullname)
+
+    # create namespace
+    __tk_call('namespace', 'eval', @fullname, '')
+
+    Tk_Namespace_ID_TBL[@fullname] = self
+  end
+
+  def self.children(*args)
+    # args ::= [<namespace>] [<pattern>]
+    # <pattern> must be glob-style pattern
+    tk_split_simplelist(tk_call('namespace', 'children', *args)).collect{|ns|
+      # ns is fullname
+      if Tk_Namesapce_ID.key?(ns)
+	Tk_Namesapce_ID[ns]
+      else
+	ns
+      end
+    }
+  end
+  def children(pattern=None)
+    TkNamespace.children(@fullname, pattern)
+  end
+
+  def self.code(script = Proc.new)
+    TkNamespace.new('').code(script)
+  end
+  def code(script = Proc.new)
+    if script.kind_of?(String)
+      cmd = proc{|*args| ScopeArgs.new(@fullname,*args).instance_eval(script)}
+    elsif script.kind_of?(Proc)
+      cmd = proc{|*args| ScopeArgs.new(@fullname,*args).instance_eval(&script)}
+    else
+      fail ArgumentError, "String or Proc is expected"
+    end
+    TkNamespace::NsCode.new(tk_call_without_enc('namespace', 'code', 
+						_get_eval_string(cmd, false)))
+  end
+
+  def self.current
+    tk_call('namespace', 'current')
+  end
+  def current_namespace
+    # ns_tk_call('namespace', 'current')
+    @fullname
+  end
+  alias current current_namespace
+
+  def self.delete(*ns_list)
+    tk_call('namespace', 'delete', *ns_list)
+  end
+  def delete
+    TkNamespece.delete(@fullname)
+  end
+
+  def self.ensemble_create(*keys)
+    tk_call('namespace', 'ensemble', 'create', *hash_kv(keys))
+  end
+  def self.ensemble_configure(cmd, slot, value=None)
+    if slot.kind_of?(Hash)
+      tk_call('namespace', 'ensemble', 'configure', cmd, *hash_kv(slot))
+    else
+      tk_call('namespace', 'ensemble', 'configure', cmd, '-'+slot.to_s, value)
+    end
+  end
+  def self.ensemble_configinfo(cmd, slot = nil)
+    if slot
+      tk_call('namespace', 'ensemble', 'configure', cmd, '-' + slot.to_s)
+    else
+      inf = {}
+      Hash(*tk_split_simplelist(tk_call('namespace', 'ensemble', 'configure', cmd))).each{|k, v| inf[k[1..-1]] = v}
+      inf
+    end
+  end
+  def self.ensemble_exist?(cmd)
+    bool(tk_call('namespace', 'ensemble', 'exists', cmd))
+  end
+
+  def self.eval(namespace, cmd = Proc.new, *args)
+    #tk_call('namespace', 'eval', namespace, cmd, *args)
+    TkNamespace.new(namespece).eval(cmd, *args)
+  end
+  def eval(cmd = Proc.new, *args)
+    #TkNamespace.eval(@fullname, cmd, *args)
+    #ns_tk_call(cmd, *args)
+    code_obj = code(cmd)
+    ret = code_obj.call(*args)
+    uninstall_cmd(TkCore::INTERP._split_tklist(code_obj.path)[-1])
+    ret
+  end
+
+  def self.exist?(ns)
+    bool(tk_call('namespace', 'exists', ns))
+  end
+  def exist?
+    TkNamespece.delete(@fullname)
+  end
+
+  def self.export(*patterns)
+    tk_call('namespace', 'export', *patterns)
+  end
+  def self.export_with_clear(*patterns)
+    tk_call('namespace', 'export', '-clear', *patterns)
+  end
+  def export
+    TkNamespace.export(@fullname)
+  end
+  def export_with_clear
+    TkNamespace.export_with_clear(@fullname)
+  end
+
+  def self.forget(*patterns)
+    tk_call('namespace', 'forget', *patterns)
+  end
+  def forget
+    TkNamespace.forget(@fullname)
+  end
+
+  def self.import(*patterns)
+    tk_call('namespace', 'import', *patterns)
+  end
+  def self.force_import(*patterns)
+    tk_call('namespace', 'import', '-force', *patterns)
+  end
+  def import
+    TkNamespace.import(@fullname)
+  end
+  def force_import
+    TkNamespace.force_import(@fullname)
+  end
+
+  def self.inscope(namespace, script, *args)
+    tk_call('namespace', 'inscope', namespace, script, *args)
+  end
+  def inscope(script, *args)
+    TkNamespace(@fullname, script, *args)
+  end
+
+  def self.origin(cmd)
+    tk_call('namespace', 'origin', cmd)
+  end
+
+  def self.parent(namespace=None)
+    ns = tk_call('namespace', 'parent', namespace)
+    if Tk_Namesapce_ID.key?(ns)
+      Tk_Namesapce_ID[ns]
+    else
+      ns
+    end
+  end
+  def parent
+    tk_call('namespace', 'parent', @fullname)
+  end
+
+  def self.qualifiers(str)
+    tk_call('namespace', 'qualifiers', str)
+  end
+
+  def self.tail(str)
+    tk_call('namespace', 'tail', str)
+  end
+
+  def self.which(name)
+    tk_call('namespace', 'which', name)
+  end
+  def self.which_command(name)
+    tk_call('namespace', 'which', '-command', name)
+  end
+  def self.which_variable(name)
+    tk_call('namespace', 'which', '-variable', name)
+  end
+end

ext/tk/lib/tk/optiondb.rb

@@ -0,0 +1,297 @@
+#
+# tk/optiondb.rb : treat option database
+#
+require 'tk'
+
+module TkOptionDB
+  include Tk
+  extend Tk
+
+  TkCommandNames = ['option'.freeze].freeze
+
+  module Priority
+    WidgetDefault = 20
+    StartupFile   = 40
+    UserDefault   = 60
+    Interactive   = 80
+  end
+
+  def add(pat, value, pri=None)
+    if $SAFE >= 4
+      fail SecurityError, "can't call 'TkOptionDB.add' at $SAFE >= 4"
+    end
+    tk_call('option', 'add', pat, value, pri)
+  end
+  def clear
+    if $SAFE >= 4
+      fail SecurityError, "can't call 'TkOptionDB.crear' at $SAFE >= 4"
+    end
+    tk_call_without_enc('option', 'clear')
+  end
+  def get(win, name, klass)
+    tk_call('option', 'get', win ,name, klass)
+  end
+  def readfile(file, pri=None)
+    tk_call('option', 'readfile', file, pri)
+  end
+  module_function :add, :clear, :get, :readfile
+
+  def read_entries(file, f_enc=nil)
+    if TkCore::INTERP.safe?
+      fail SecurityError, 
+	"can't call 'TkOptionDB.read_entries' on a safe interpreter"
+    end
+
+    i_enc = Tk.encoding()
+
+    unless f_enc
+      f_enc = i_enc
+    end
+
+    ent = []
+    cline = ''
+    open(file, 'r') {|f|
+      while line = f.gets
+	cline += line.chomp!
+	case cline
+	when /\\$/    # continue
+	  cline.chop!
+	  next
+	when /^\s*(!|#)/     # coment
+	  cline = ''
+	  next
+	when /^([^:]+):(.*)$/
+	  pat = $1.strip
+	  val = $2.lstrip
+	  p "ResourceDB: #{[pat, val].inspect}" if $DEBUG
+	  pat = TkCore::INTERP._toUTF8(pat, f_enc)
+	  pat = TkCore::INTERP._fromUTF8(pat, i_enc)
+	  val = TkCore::INTERP._toUTF8(val, f_enc)
+	  val = TkCore::INTERP._fromUTF8(val, i_enc)
+	  ent << [pat, val]
+	  cline = ''
+	else          # unknown --> ignore
+	  cline = ''
+	  next
+	end
+      end
+    }
+    ent
+  end
+  module_function :read_entries
+      
+  def read_with_encoding(file, f_enc=nil, pri=None)
+    # try to read the file as an OptionDB file
+    read_entries(file, f_enc).each{|pat, val|
+      add(pat, val, pri)
+    }
+
+=begin
+    i_enc = Tk.encoding()
+
+    unless f_enc
+      f_enc = i_enc
+    end
+
+    cline = ''
+    open(file, 'r') {|f|
+      while line = f.gets
+	cline += line.chomp!
+	case cline
+	when /\\$/    # continue
+	  cline.chop!
+	  next
+	when /^\s*!/     # coment
+	  cline = ''
+	  next
+	when /^([^:]+):\s(.*)$/
+	  pat = $1
+	  val = $2
+	  p "ResourceDB: #{[pat, val].inspect}" if $DEBUG
+	  pat = TkCore::INTERP._toUTF8(pat, f_enc)
+	  pat = TkCore::INTERP._fromUTF8(pat, i_enc)
+	  val = TkCore::INTERP._toUTF8(val, f_enc)
+	  val = TkCore::INTERP._fromUTF8(val, i_enc)
+	  add(pat, val, pri)
+	  cline = ''
+	else          # unknown --> ignore
+	  cline = ''
+	  next
+	end
+      end
+    }
+=end
+  end
+  module_function :read_with_encoding
+
+  # support procs on the resource database
+  @@resource_proc_class = Class.new
+  class << @@resource_proc_class
+    private :new
+ 
+    CARRIER    = '.'.freeze
+    METHOD_TBL = TkCore::INTERP.create_table
+    ADD_METHOD = false
+    SAFE_MODE  = 4
+
+=begin
+    def __closed_block_check__(str)
+      depth = 0
+      str.scan(/[{}]/){|x|
+	if x == "{"
+	  depth += 1
+	elsif x == "}"
+	  depth -= 1
+	end
+	if depth <= 0 && !($' =~ /\A\s*\Z/)
+	  fail RuntimeError, "bad string for procedure : #{str.inspect}"
+	end
+      }
+      str
+    end
+    private :__closed_block_check__
+=end
+
+    def __check_proc_string__(str)
+      # If you want to check the proc_string, do it in this method.
+      # Please define this in the block given to 'new_proc_class' method. 
+      str
+    end
+
+    def method_missing(id, *args)
+      res_proc, proc_str = self::METHOD_TBL[id]
+
+      proc_source = TkOptionDB.get(self::CARRIER, id.id2name, '').strip
+      res_proc = nil if proc_str != proc_source # resource is changed
+
+      unless res_proc.kind_of? Proc
+        if id == :new || !(self::METHOD_TBL.has_key?(id) || self::ADD_METHOD)
+          raise NoMethodError, 
+                "not support resource-proc '#{id.id2name}' for #{self.name}"
+        end
+	proc_str = proc_source
+        proc_str = '{' + proc_str + '}' unless /\A\{.*\}\Z/ =~ proc_str
+	#proc_str = __closed_block_check__(proc_str)
+        proc_str = __check_proc_string__(proc_str)
+        res_proc = proc{ 
+	  begin
+	    eval("$SAFE = #{self::SAFE_MODE};\nProc.new" + proc_str)
+	  rescue SyntaxError=>err
+	    raise SyntaxError, 
+	      TkCore::INTERP._toUTF8(err.message.gsub(/\(eval\):\d:/, 
+						      "(#{id.id2name}):"))
+	  end
+	}.call
+        self::METHOD_TBL[id] = [res_proc, proc_source]
+      end
+      res_proc.call(*args)
+    end
+
+    private :__check_proc_string__, :method_missing
+  end
+  @@resource_proc_class.freeze
+
+  def __create_new_class(klass, func, safe = 4, add = false, parent = nil)
+    klass = klass.to_s if klass.kind_of? Symbol
+    unless (?A..?Z) === klass[0]
+      fail ArgumentError, "bad string '#{klass}' for class name"
+    end
+    unless func.kind_of? Array
+      fail ArgumentError, "method-list must be Array"
+    end
+    func_str = func.join(' ')
+    if parent == nil
+      install_win(parent)
+    elsif parent <= @@resource_proc_class
+      install_win(parent::CARRIER)
+    else
+      fail ArgumentError, "parent must be Resource-Proc class"
+    end
+    carrier = Tk.tk_call_without_enc('frame', @path, '-class', klass)
+
+    body = <<-"EOD"
+      class #{klass} < TkOptionDB.module_eval('@@resource_proc_class')
+        CARRIER    = '#{carrier}'.freeze
+        METHOD_TBL = TkCore::INTERP.create_table
+        ADD_METHOD = #{add}
+        SAFE_MODE  = #{safe}
+        %w(#{func_str}).each{|f| METHOD_TBL[f.intern] = nil }
+      end
+    EOD
+
+    if parent.kind_of?(Class) && parent <= @@resource_proc_class
+      parent.class_eval(body)
+      eval(parent.name + '::' + klass)
+    else
+      eval(body)
+      eval('TkOptionDB::' + klass)
+    end
+  end
+  module_function :__create_new_class
+  private_class_method :__create_new_class
+
+  def __remove_methods_of_proc_class(klass)
+    # for security, make these methods invalid
+    class << klass
+      attr_reader :class_eval, :name, :superclass, 
+	:ancestors, :const_defined?, :const_get, :const_set, 
+	:constants, :included_modules, :instance_methods, 
+	:method_defined?, :module_eval, :private_instance_methods, 
+	:protected_instance_methods, :public_instance_methods, 
+	:remove_const, :remove_method, :undef_method, 
+	:to_s, :inspect, :display, :method, :methods, 
+	:instance_eval, :instance_variables, :kind_of?, :is_a?,
+	:private_methods, :protected_methods, :public_methods
+    end
+  end
+  module_function :__remove_methods_of_proc_class
+  private_class_method :__remove_methods_of_proc_class
+
+  RAND_BASE_CNT = [0]
+  RAND_BASE_HEAD = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+  RAND_BASE_CHAR = RAND_BASE_HEAD + 'abcdefghijklmnopqrstuvwxyz0123456789_'
+  def __get_random_basename
+    name = '%s%03d' % [RAND_BASE_HEAD[rand(RAND_BASE_HEAD.size),1], 
+                       RAND_BASE_CNT[0]]
+    len = RAND_BASE_CHAR.size
+    (6+rand(10)).times{
+      name << RAND_BASE_CHAR[rand(len),1]
+    }
+    RAND_BASE_CNT[0] = RAND_BASE_CNT[0] + 1
+    name
+  end
+  module_function :__get_random_basename
+  private_class_method :__get_random_basename
+
+  # define new proc class :
+  # If you want to modify the new class or create a new subclass, 
+  # you must do such operation in the block parameter. 
+  # Because the created class is flozen after evaluating the block. 
+  def new_proc_class(klass, func, safe = 4, add = false, parent = nil, &b)
+    new_klass = __create_new_class(klass, func, safe, add, parent)
+    new_klass.class_eval(&b) if block_given?
+    __remove_methods_of_proc_class(new_klass)
+    new_klass.freeze
+    new_klass
+  end
+  module_function :new_proc_class
+
+  def eval_under_random_base(parent = nil, &b)
+    new_klass = __create_new_class(__get_random_basename(), 
+				   [], 4, false, parent)
+    ret = new_klass.class_eval(&b) if block_given?
+    __remove_methods_of_proc_class(new_klass)
+    new_klass.freeze
+    ret
+  end
+  module_function :eval_under_random_base
+
+  def new_proc_class_random(klass, func, safe = 4, add = false, &b)
+    eval_under_random_base(){
+      TkOption.new_proc_class(klass, func, safe, add, self, &b)
+    }
+  end
+  module_function :new_proc_class_random
+end
+TkOption = TkOptionDB
+TkResourceDB = TkOptionDB

ext/tk/lib/tk/pack.rb

@@ -0,0 +1,89 @@
+#
+# tk/pack.rb : control pack geometry manager
+#
+require 'tk'
+
+module TkPack
+  include Tk
+  extend Tk
+
+  TkCommandNames = ['pack'.freeze].freeze
+
+  def configure(win, *args)
+    if args[-1].kind_of?(Hash)
+      opts = args.pop
+    else
+      opts = {}
+    end
+    params = []
+    # params.push((win.kind_of?(TkObject))? win.epath: win)
+    params.push(_epath(win))
+    args.each{|win|
+      # params.push((win.kind_of?(TkObject))? win.epath: win)
+      params.push(_epath(win))
+    }
+    opts.each{|k, v|
+      params.push("-#{k}")
+      # params.push((v.kind_of?(TkObject))? v.epath: v)
+      params.push(_epath(v))
+    }
+    tk_call_without_enc("pack", 'configure', *params)
+  end
+
+  def forget(*args)
+    return '' if args.size == 0
+    wins = args.collect{|win|
+      # (win.kind_of?(TkObject))? win.epath: win
+      _epath(win)
+    }
+    tk_call_without_enc('pack', 'forget', *wins)
+  end
+
+  def info(slave)
+    # slave = slave.epath if slave.kind_of?(TkObject)
+    slave = _epath(slave)
+    ilist = list(tk_call_without_enc('pack', 'info', slave))
+    info = {}
+    while key = ilist.shift
+      info[key[1..-1]] = ilist.shift
+    end
+    return info
+  end
+
+  def propagate(master, bool=None)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    if bool == None
+      bool(tk_call_without_enc('pack', 'propagate', master))
+    else
+      tk_call_without_enc('pack', 'propagate', master, bool)
+    end
+  end
+
+  def slaves(master)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    list(tk_call_without_enc('pack', 'slaves', master))
+  end
+
+  module_function :configure, :forget, :info, :propagate, :slaves
+end
+=begin
+def TkPack(win, *args)
+  if args[-1].kind_of?(Hash)
+    opts = args.pop
+  else
+    opts = {}
+  end
+  params = []
+  params.push((win.kind_of?(TkObject))? win.epath: win)
+  args.each{|win|
+    params.push((win.kind_of?(TkObject))? win.epath: win)
+  }
+  opts.each{|k, v|
+    params.push("-#{k}")
+    params.push((v.kind_of?(TkObject))? v.epath: v)
+  }
+  tk_call_without_enc("pack", *params)
+end
+=end

ext/tk/lib/tk/package.rb

@@ -0,0 +1,61 @@
+#
+# tk/package.rb : package command
+#
+require 'tk'
+
+module TkPackage
+  include TkCore
+  extend TkPackage
+
+  TkCommandNames = ['package'.freeze].freeze
+
+  def add_path(path)
+    Tk::AUTO_PATH.value = Tk::AUTO_PATH.to_a << path
+  end
+
+  def forget(package)
+    tk_call('package', 'forget', package)
+    nil
+  end
+
+  def names
+    tk_split_simplelist(tk_call('package', 'names'))
+  end
+
+  def provide(package, version=nil)
+    if version
+      tk_call('package', 'provide', package, version)
+      nil
+    else
+      tk_call('package', 'provide', package)
+    end
+  end
+
+  def present(package, version=None)
+    tk_call('package', 'present', package, version)
+  end
+
+  def present_exact(package, version)
+    tk_call('package', 'present', '-exact', package, version)
+  end
+
+  def require(package, version=None)
+    tk_call('package', 'require', package, version)
+  end
+
+  def require_exact(package, version)
+    tk_call('package', 'require', '-exact', package, version)
+  end
+
+  def versions(package)
+    tk_split_simplelist(tk_call('package', 'versions', package))
+  end
+
+  def vcompare(version1, version2)
+    number(tk_call('package', 'vcompare', version1, version2))
+  end
+
+  def vsatisfies(version1, version2)
+    bool(tk_call('package', 'vsatisfies', version1, version2))
+  end
+end

ext/tk/lib/tk/palette.rb

@@ -0,0 +1,54 @@
+#
+#   tk/palette.rb : methods for Tcl/Tk standard library 'palette.tcl'
+#                     1998/06/21 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+require 'tk'
+
+module TkPalette
+  include Tk
+  extend Tk
+
+  TkCommandNames = [
+    'tk_setPalette'.freeze, 
+    'tk_bisque'.freeze, 
+    'tkDarken'.freeze
+  ].freeze
+
+  def TkPalette.set(*args)
+    args = args.to_a.flatten if args.kind_of? Hash
+    tk_call('tk_setPalette', *args)
+  end
+  def TkPalette.setPalette(*args)
+    TkPalette.set(*args)
+  end
+
+  def TkPalette.bisque
+    tk_call('tk_bisque')
+  end
+
+  def TkPalette.darken(color, percent)
+    tk_call('tkDarken', color, percent)
+  end
+
+  def TkPalette.recolorTree(window, colors)
+    if not colors.kind_of?(Hash)
+      fail "2nd arg need to be Hash"
+    end
+
+    colors.each{|key, value|
+      begin
+	if window.cget(key) == tk_call('set', "tkPalette(#{key})")
+	  window[key] = colors[key]
+	end
+      rescue
+	# ignore
+      end
+    }
+
+    TkWinfo.children(window).each{|w| TkPalette.recolorTree(w, colors)}
+  end
+
+  def recolorTree(colors)
+    TkPalette.recolorTree(self, colors)
+  end
+end

ext/tk/lib/tk/panedwindow.rb

@@ -0,0 +1,204 @@
+#
+# tk/panedwindow.rb : treat panedwindow
+#
+require 'tk'
+
+class TkPanedWindow<TkWindow
+  TkCommandNames = ['panedwindow'.freeze].freeze
+  WidgetClassName = 'Panedwindow'.freeze
+  WidgetClassNames[WidgetClassName] = self
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('panedwindow', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('panedwindow', @path)
+    end
+  end
+  private :create_self
+
+  def add(*args)
+    keys = args.pop
+    fail ArgumentError, "no window in arguments" unless keys
+    if keys && keys.kind_of?(Hash)
+      fail ArgumentError, "no window in arguments" if args == []
+      # args = args.collect{|w| (w.kind_of?(TkObject))? w.epath: w }
+      args = args.collect{|w| _epath(w) }
+      #args.push(hash_kv(keys))
+      args.concat(hash_kv(keys))
+    else
+      args.push(keys) if keys
+      # args = args.collect{|w| (w.kind_of?(TkObject))? w.epath: w }
+      args = args.collect{|w| _epath(w) }
+    end
+    tk_send_without_enc('add', *args)
+    self
+  end
+
+  def forget(win, *wins)
+    wins.unshift(win)
+    # tk_send_without_enc('forget', *((w.kind_of?(TkObject))? w.epath: w))
+    tk_send_without_enc('forget', *(wins.collect{|w| _epath(w)}))
+    self
+  end
+  alias del forget
+  alias delete forget
+  alias remove forget
+
+  def identify(x, y)
+    list(tk_send_without_enc('identify', x, y))
+  end
+
+  def proxy_coord
+    list(tk_send_without_enc('proxy', 'coord'))
+  end
+  def proxy_forget
+    tk_send_without_enc('proxy', 'forget')
+    self
+  end
+  def proxy_place(x, y)
+    tk_send_without_enc('proxy', 'place', x, y)
+    self
+  end
+
+  def sash_coord(index)
+    list(tk_send('sash', 'coord', index))
+  end
+  def sash_dragto(index)
+    tk_send('sash', 'dragto', index, x, y)
+    self
+  end
+  def sash_mark(index, x, y)
+    tk_send('sash', 'mark', index, x, y)
+    self
+  end
+  def sash_place(index, x, y)
+    tk_send('sash', 'place', index, x, y)
+    self
+  end
+
+  def panecget(win, key)
+    # win = win.epath if win.kind_of?(TkObject)
+    win = _epath(win)
+    tk_tcl2ruby(tk_send_without_enc('panecget', win, "-#{key}"))
+  end
+
+  def paneconfigure(win, key, value=nil)
+    # win = win.epath if win.kind_of?(TkObject)
+    win = _epath(win)
+    if key.kind_of? Hash
+      params = []
+      key.each{|k, v|
+	params.push("-#{k}")
+	# params.push((v.kind_of?(TkObject))? v.epath: v)
+	params.push(_epath(v))
+      }
+      tk_send_without_enc('paneconfigure', win, *params)
+    else
+      # value = value.epath if value.kind_of?(TkObject)
+      value = _epath(value)
+      tk_send_without_enc('paneconfigure', win, "-#{key}", value)
+    end
+    self
+  end
+  alias pane_config paneconfigure
+
+  def paneconfiginfo(win, key=nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      # win = win.epath if win.kind_of?(TkObject)
+      win = _epath(win)
+      if key
+	conf = tk_split_list(tk_send_without_enc('paneconfigure', 
+						 win, "-#{key}"))
+	conf[0] = conf[0][1..-1]
+	conf
+      else
+	tk_split_simplelist(tk_send_without_enc('paneconfigure', 
+						win)).collect{|conflist|
+	  conf = tk_split_simplelist(conflist)
+	  conf[0] = conf[0][1..-1]
+	  if conf[3]
+	    if conf[3].index('{')
+	      conf[3] = tk_split_list(conf[3]) 
+	    else
+	      conf[3] = tk_tcl2ruby(conf[3]) 
+	    end
+	  end
+	  if conf[4]
+	    if conf[4].index('{')
+	      conf[4] = tk_split_list(conf[4]) 
+	    else
+	      conf[4] = tk_tcl2ruby(conf[4]) 
+	    end
+	  end
+	  conf[1] = conf[1][1..-1] if conf.size == 2 # alias info
+	  conf
+	}
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      # win = win.epath if win.kind_of?(TkObject)
+      win = _epath(win)
+      if key
+	conf = tk_split_list(tk_send_without_enc('paneconfigure', 
+						 win, "-#{key}"))
+	key = conf.shift[1..-1]
+	{ key => conf }
+      else
+	ret = {}
+	tk_split_simplelist(tk_send_without_enc('paneconfigure', 
+						win)).each{|conflist|
+	  conf = tk_split_simplelist(conflist)
+	  key = conf.shift[1..-1]
+	  if key
+	    if conf[2].index('{')
+	      conf[2] = tk_split_list(conf[2]) 
+	    else
+	      conf[2] = tk_tcl2ruby(conf[2]) 
+	    end
+	  end
+	  if conf[3]
+	    if conf[3].index('{')
+	      conf[3] = tk_split_list(conf[3]) 
+	    else
+	      conf[3] = tk_tcl2ruby(conf[3]) 
+	    end
+	  end
+	  if conf.size == 1
+	    ret[key] = conf[0][1..-1]  # alias info
+	  else
+	    ret[key] = conf
+	  end
+	}
+	ret
+      end
+    end
+  end
+  alias pane_configinfo paneconfiginfo
+
+  def current_paneconfiginfo(win, key=nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+	conf = paneconfiginfo(win, key)
+	{conf[0] => conf[4]}
+      else
+	ret = {}
+	paneconfiginfo(win).each{|conf|
+	  ret[conf[0]] = conf[4] if conf.size > 2
+	}
+	ret
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      ret = {}
+      paneconfiginfo(win, key).each{|k, conf|
+	ret[k] = conf[-1] if conf.kind_of?(Array)
+      }
+      ret
+    end
+  end
+
+  alias current_pane_configinfo current_paneconfiginfo
+
+  def panes
+    list(tk_send_without_enc('panes'))
+  end
+end
+TkPanedwindow = TkPanedWindow

ext/tk/lib/tk/place.rb

@@ -0,0 +1,110 @@
+#
+# tk/place.rb : control place geometry manager
+#
+require 'tk'
+
+module TkPlace
+  include Tk
+  extend Tk
+
+  TkCommandNames = ['place'.freeze].freeze
+
+  def configure(win, slot, value=None)
+    # for >= Tk8.4a2 ?
+    # win = win.epath if win.kind_of?(TkObject)
+    win = _epath(win)
+    if slot.kind_of? Hash
+      params = []
+      slot.each{|k, v|
+	params.push("-#{k}")
+	# params.push((v.kind_of?(TkObject))? v.epath: v)
+	params.push(_epath(v))
+      }
+      tk_call_without_enc('place', 'configure', win, *params)
+    else
+      # value = value.epath if value.kind_of?(TkObject)
+      value = _epath(value)
+      tk_call_without_enc('place', 'configure', win, "-#{slot}", value)
+    end
+  end
+
+  def configinfo(win, slot = nil)
+    # for >= Tk8.4a2 ?
+    if TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
+      # win = win.epath if win.kind_of?(TkObject)
+      win = _epath(win)
+      if slot
+	conf = tk_split_list(tk_call_without_enc('place', 'configure', 
+						 win, "-#{slot}") )
+	conf[0] = conf[0][1..-1]
+	conf
+      else
+	tk_split_simplelist(tk_call_without_enc('place', 'configure', 
+						win)).collect{|conflist|
+	  conf = list(conflist)
+	  conf[0] = conf[0][1..-1]
+	  conf
+	}
+      end
+    else # ! TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
+      current_configinfo(win, slot)
+    end
+  end
+
+  def current_configinfo(win, slot = nil)
+    # win = win.epath if win.kind_of?(TkObject)
+    win = _epath(win)
+    if slot
+      conf = tk_split_list(tk_call_without_enc('place', 'configure', 
+					       win, "-#{slot}") )
+      { conf[0][1..-1] => conf[1] }
+    else
+      ret = {}
+      tk_split_list(tk_call_without_enc('place','configure',win)).each{|conf|
+	ret[conf[0][1..-1]] = conf[1]
+      }
+      ret
+    end
+  end
+
+  def forget(win)
+    # win = win.epath if win.kind_of?(TkObject)
+    win = _epath(win)
+    tk_call_without_enc('place', 'forget', win)
+  end
+
+  def info(win)
+    # win = win.epath if win.kind_of?(TkObject)
+    win = _epath(win)
+    ilist = list(tk_call_without_enc('place', 'info', win))
+    info = {}
+    while key = ilist.shift
+      info[key[1..-1]] = ilist.shift
+    end
+    return info
+  end
+
+  def slaves(master)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    list(tk_call('place', 'slaves', master))
+  end
+
+  module_function :configure, :configinfo, :forget, :info, :slaves
+end
+=begin
+def TkPlace(win, slot, value=None)
+  win = win.epath if win.kind_of?(TkObject)
+  if slot.kind_of? Hash
+    params = []
+    slot.each{|k, v|
+      params.push("-#{k}")
+      params.push((v.kind_of?(TkObject))? v.epath: v)
+    }
+    tk_call_without_enc('place', win, *params)
+  else
+    value = value.epath if value.kind_of?(TkObject)
+    tk_call_without_enc('place', win, "-#{slot}", value)
+  end
+end
+=end

ext/tk/lib/tk/radiobutton.rb

@@ -0,0 +1,32 @@
+#
+# tk/radiobutton.rb : treat radiobutton widget
+#
+require 'tk'
+require 'tk/button'
+
+class TkRadioButton<TkButton
+  TkCommandNames = ['radiobutton'.freeze].freeze
+  WidgetClassName = 'Radiobutton'.freeze
+  WidgetClassNames[WidgetClassName] = self
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('radiobutton', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('radiobutton', @path)
+    end
+  end
+  private :create_self
+
+  def deselect
+    tk_send_without_enc('deselect')
+    self
+  end
+  def select
+    tk_send_without_enc('select')
+    self
+  end
+  def variable(v)
+    configure 'variable', tk_trace_variable(v)
+  end
+end
+TkRadiobutton = TkRadioButton

ext/tk/lib/tk/root.rb

@@ -0,0 +1,65 @@
+#
+# tk/root.rb : treat root widget
+#
+require 'tk'
+require 'tk/wm'
+
+class TkRoot<TkWindow
+  include Wm
+
+=begin
+  ROOT = []
+  def TkRoot.new(keys=nil)
+    if ROOT[0]
+      Tk_WINDOWS["."] = ROOT[0]
+      return ROOT[0]
+    end
+    new = super(:without_creating=>true, :widgetname=>'.')
+    if keys  # wm commands
+      keys.each{|k,v|
+	if v.kind_of? Array
+	  new.send(k,*v)
+	else
+	  new.send(k,v)
+	end
+      }
+    end
+    ROOT[0] = new
+    Tk_WINDOWS["."] = new
+  end
+=end
+  def TkRoot.new(keys=nil, &b)
+    unless TkCore::INTERP.tk_windows['.']
+      TkCore::INTERP.tk_windows['.'] = 
+	super(:without_creating=>true, :widgetname=>'.'){}
+    end
+    root = TkCore::INTERP.tk_windows['.']
+    if keys  # wm commands
+      keys.each{|k,v|
+	if v.kind_of? Array
+	  root.send(k,*v)
+	else
+	  root.send(k,v)
+	end
+      }
+    end
+    root.instance_eval(&b) if block_given?
+    root
+  end
+
+  WidgetClassName = 'Tk'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+  def create_self
+    @path = '.'
+  end
+  private :create_self
+
+  def path
+    "."
+  end
+
+  def TkRoot.destroy
+    TkCore::INTERP._invoke('destroy', '.')
+  end
+end

ext/tk/lib/tk/scale.rb

@@ -0,0 +1,78 @@
+#
+# tk/scale.rb : treat scale widget
+#
+require 'tk'
+
+class TkScale<TkWindow
+  TkCommandNames = ['scale'.freeze].freeze
+  WidgetClassName = 'Scale'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+  def create_self(keys)
+    if keys and keys != None
+      if keys.key?('command')
+	cmd = keys.delete('command')
+	keys['command'] = proc{|val| cmd.call(val.to_f)}
+      end
+      tk_call_without_enc('scale', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('scale', @path)
+    end
+  end
+  private :create_self
+
+  def _wrap_command_arg(cmd)
+    proc{|val|
+      if val.kind_of?(String)
+	cmd.call(number(val))
+      else
+	cmd.call(val)
+      end
+    }
+  end
+  private :_wrap_command_arg
+
+  def configure_cmd(slot, value)
+    configure(slot=>value)
+  end
+
+  def configure(slot, value=None)
+    if (slot == 'command' || slot == :command)
+      configure('command'=>value)
+    elsif slot.kind_of?(Hash) && 
+	(slot.key?('command') || slot.key?(:command))
+      slot = _symbolkey2str(slot)
+      slot['command'] = _wrap_command_arg(slot.delete('command'))
+    end
+    super(slot, value)
+  end
+
+  def command(cmd=Proc.new)
+    configure('command'=>cmd)
+  end
+
+  def get(x=None, y=None)
+    number(tk_send_without_enc('get', x, y))
+  end
+
+  def coords(val=None)
+    tk_split_list(tk_send_without_enc('coords', val))
+  end
+
+  def identify(x, y)
+    tk_send_without_enc('identify', x, y)
+  end
+
+  def set(val)
+    tk_send_without_enc('set', val)
+  end
+
+  def value
+    get
+  end
+
+  def value= (val)
+    set(val)
+    val
+  end
+end

ext/tk/lib/tk/scrollable.rb

@@ -0,0 +1,49 @@
+#
+# tk/scrollable.rb : module for scrollable widget
+#
+require 'tk'
+
+module Tk
+  module Scrollable
+    def xscrollcommand(cmd=Proc.new)
+      configure_cmd 'xscrollcommand', cmd
+    end
+    def yscrollcommand(cmd=Proc.new)
+      configure_cmd 'yscrollcommand', cmd
+    end
+    def xview(*index)
+      if index.size == 0
+	list(tk_send_without_enc('xview'))
+      else
+	tk_send_without_enc('xview', *index)
+	self
+      end
+    end
+    def yview(*index)
+      if index.size == 0
+	list(tk_send_without_enc('yview'))
+      else
+	tk_send_without_enc('yview', *index)
+	self
+      end
+    end
+    def xscrollbar(bar=nil)
+      if bar
+	@xscrollbar = bar
+	@xscrollbar.orient 'horizontal'
+	self.xscrollcommand {|*arg| @xscrollbar.set(*arg)}
+	@xscrollbar.command {|*arg| self.xview(*arg)}
+      end
+      @xscrollbar
+    end
+    def yscrollbar(bar=nil)
+      if bar
+	@yscrollbar = bar
+	@yscrollbar.orient 'vertical'
+	self.yscrollcommand {|*arg| @yscrollbar.set(*arg)}
+	@yscrollbar.command {|*arg| self.yview(*arg)}
+      end
+      @yscrollbar
+    end
+  end
+end

ext/tk/lib/tk/scrollbar.rb

@@ -0,0 +1,105 @@
+#
+# tk/scrollbar.rb : treat scrollbar widget
+#
+require 'tk'
+
+class TkScrollbar<TkWindow
+  TkCommandNames = ['scrollbar'.freeze].freeze
+  WidgetClassName = 'Scrollbar'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+  def create_self(keys)
+    @assigned = []
+    @scroll_proc = proc{|*args| 
+      if self.orient == 'horizontal'
+	@assigned.each{|w| w.xview(*args)}
+      else # 'vertical'
+	@assigned.each{|w| w.yview(*args)}
+      end
+    }
+
+    if keys and keys != None
+      tk_call_without_enc('scrollbar', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('scrollbar', @path)
+    end
+  end
+  private :create_self
+
+  def assign(*wins)
+    begin
+      self.command(@scroll_proc) if self.cget('command').cmd != @scroll_proc
+    rescue Exception
+      self.command(@scroll_proc)
+    end
+    orient = self.orient
+    wins.each{|w|
+      @assigned << w unless @assigned.index(w)
+      if orient == 'horizontal'
+	w.xscrollcommand proc{|first, last| self.set(first, last)}
+      else # 'vertical'
+	w.yscrollcommand proc{|first, last| self.set(first, last)}
+      end
+    }
+    self
+  end
+
+  def assigned_list
+    begin
+      return @assigned.dup if self.cget('command').cmd == @scroll_proc
+    rescue Exception
+    end
+    fail RuntimeError, "not depend on the assigned_list"
+  end
+
+  #def delta(deltax=None, deltay=None)
+  def delta(deltax, deltay)
+    number(tk_send_without_enc('delta', deltax, deltay))
+  end
+
+  #def fraction(x=None, y=None)
+  def fraction(x, y)
+    number(tk_send_without_enc('fraction', x, y))
+  end
+
+  def identify(x, y)
+    tk_send_without_enc('identify', x, y)
+  end
+
+  def get
+    #ary1 = tk_send('get').split
+    #ary2 = []
+    #for i in ary1
+    #  ary2.push number(i)
+    #end
+    #ary2
+    list(tk_send_without_enc('get'))
+  end
+
+  def set(first, last)
+    tk_send_without_enc('set', first, last)
+    self
+  end
+
+  def activate(element=None)
+    tk_send_without_enc('activate', element)
+  end
+end
+
+class TkXScrollbar<TkScrollbar
+  def create_self(keys)
+    keys = {} unless keys
+    keys['orient'] = 'horizontal'
+    super(keys)
+  end
+  private :create_self
+end
+
+class TkYScrollbar<TkScrollbar
+  def create_self(keys)
+    keys = {} unless keys
+    keys['orient'] = 'vertical'
+    super(keys)
+  end
+  private :create_self
+end

ext/tk/lib/tk/scrollbox.rb

@@ -0,0 +1,31 @@
+#
+#		tk/scrollbox.rb - Tk Listbox with Scrollbar
+#                                 as an example of Composite Widget
+#			$Date$
+#			by Yukihiro Matsumoto <matz@netlab.co.jp>
+#
+require 'tk'
+require 'tk/listbox'
+
+class TkScrollbox<TkListbox
+  include TkComposite
+  def initialize_composite(keys=nil)
+    list = TkListbox.new(@frame)
+    scroll = TkScrollbar.new(@frame)
+    @path = list.path
+
+    list.configure 'yscroll', scroll.path+" set"
+    list.pack 'side'=>'left','fill'=>'both','expand'=>'yes'
+    scroll.configure 'command', list.path+" yview"
+    scroll.pack 'side'=>'right','fill'=>'y'
+
+    delegate('DEFAULT', list)
+    delegate('foreground', list)
+    delegate('background', list, scroll)
+    delegate('borderwidth', @frame)
+    delegate('relief', @frame)
+
+    configure keys if keys
+  end
+  private :initialize_composite
+end

ext/tk/lib/tk/selection.rb

@@ -0,0 +1,86 @@
+#
+# tk/selection.rb : control selection
+#
+require 'tk'
+
+module TkSelection
+  include Tk
+  extend Tk
+
+  TkCommandNames = ['selection'.freeze].freeze
+
+  def self.clear(sel=nil)
+    if sel
+      tk_call_without_enc('selection', 'clear', '-selection', sel)
+    else
+      tk_call_without_enc('selection', 'clear')
+    end
+  end
+  def self.clear_on_display(win, sel=nil)
+    if sel
+      tk_call_without_enc('selection', 'clear', 
+			  '-displayof', win, '-selection', sel)
+    else
+      tk_call_without_enc('selection', 'clear', '-displayof', win)
+    end
+  end
+  def clear(sel=nil)
+    TkSelection.clear_on_display(self, sel)
+    self
+  end
+
+  def self.get(keys=nil)
+    #tk_call('selection', 'get', *hash_kv(keys))
+    _fromUTF8(tk_call_without_enc('selection', 'get', *hash_kv(keys)))
+  end
+  def self.get_on_display(win, keys=nil)
+    #tk_call('selection', 'get', '-displayof', win, *hash_kv(keys))
+    _fromUTF8(tk_call_without_enc('selection', 'get', '-displayof', 
+				  win, *hash_kv(keys)))
+  end
+  def get(keys=nil)
+    TkSelection.get_on_display(self, sel)
+  end
+
+  def self.handle(win, func=Proc.new, keys=nil, &b)
+    if func.kind_of?(Hash) && keys == nil
+      keys = func
+      func = Proc.new(&b)
+    end
+    args = ['selection', 'handle']
+    args.concat(hash_kv(keys))
+    args.concat([win, func])
+    tk_call_without_enc(*args)
+  end
+  def handle(func=Proc.new, keys=nil, &b)
+    TkSelection.handle(self, func, keys, &b)
+  end
+
+  def self.get_owner(sel=nil)
+    if sel
+      window(tk_call_without_enc('selection', 'own', '-selection', sel))
+    else
+      window(tk_call_without_enc('selection', 'own'))
+    end
+  end
+  def self.get_owner_on_display(win, sel=nil)
+    if sel
+      window(tk_call_without_enc('selection', 'own', 
+				 '-displayof', win, '-selection', sel))
+    else
+      window(tk_call_without_enc('selection', 'own', '-displayof', win))
+    end
+  end
+  def get_owner(sel=nil)
+    TkSelection.get_owner_on_display(self, sel)
+    self
+  end
+
+  def self.set_owner(win, keys=nil)
+    tk_call_without_enc('selection', 'own', *(hash_kv(keys) << win))
+  end
+  def set_owner(keys=nil)
+    TkSelection.set_owner(self, keys)
+    self
+  end
+end

ext/tk/lib/tk/spinbox.rb

@@ -0,0 +1,39 @@
+#
+#		tk/spinbox.rb - Tk spinbox classes
+#			$Date$
+#			by Yukihiro Matsumoto <matz@caelum.co.jp>
+#
+require 'tk'
+require 'tk/entry'
+
+class TkSpinbox<TkEntry
+  TkCommandNames = ['spinbox'.freeze].freeze
+  WidgetClassName = 'Spinbox'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+  def create_self(keys)
+    tk_call_without_enc('spinbox', @path)
+    if keys and keys != None
+      configure(keys)
+    end
+  end
+  private :create_self
+
+  def identify(x, y)
+    tk_send_without_enc('identify', x, y)
+  end
+
+  def spinup
+    tk_send_without_enc('invoke', 'spinup')
+    self
+  end
+
+  def spindown
+    tk_send_without_enc('invoke', 'spindown')
+    self
+  end
+
+  def set(str)
+    _freomUTF8(tk_send_without_enc('set', _get_eval_enc_str(str)))
+  end
+end

ext/tk/lib/tk/tagfont.rb

@@ -0,0 +1,43 @@
+#
+# tk/tagfont.rb : control font of tags
+#
+require 'tk'
+
+module TkTreatTagFont
+  def font_configinfo
+    @parent.tagfont_configinfo(@id)
+  end
+#  alias font font_configinfo
+
+  def font_configure(slot)
+    @parent.tagfont_configure(@id, slot)
+    self
+  end
+
+  def latinfont_configure(ltn, keys=nil)
+    @parent.latintagfont_configure(@id, ltn, keys)
+    self
+  end
+  alias asciifont_configure latinfont_configure
+
+  def kanjifont_configure(knj, keys=nil)
+    @parent.kanjitagfont_configure(@id, ltn, keys)
+    self
+  end
+
+  def font_copy(window, wintag=nil)
+    @parent.tagfont_copy(@id, window, wintag)
+    self
+  end
+
+  def latinfont_copy(window, wintag=nil)
+    @parent.latintagfont_copy(@id, window, wintag)
+    self
+  end
+  alias asciifont_copy latinfont_copy
+
+  def kanjifont_copy(window, wintag=nil)
+    @parent.kanjitagfont_copy(@id, window, wintag)
+    self
+  end
+end

ext/tk/lib/tk/textimage.rb

@@ -0,0 +1,72 @@
+#
+# tk/textimage.rb - treat Tk text image object
+#
+require 'tk'
+require 'tk/text'
+
+class TkTextImage<TkObject
+  def initialize(parent, index, keys)
+    unless parent.kind_of?(TkText)
+      fail ArguemntError, "expect TkText for 1st argument"
+    end
+    @t = parent
+    if index == 'end'
+      @path = TkTextMark.new(@t, tk_call(@t.path, 'index', 'end - 1 chars'))
+    elsif index.kind_of? TkTextMark
+      if tk_call_without_enc(@t.path,'index',index.path) == tk_call_without_enc(@t.path,'index','end')
+	@path = TkTextMark.new(@t, tk_call_without_enc(@t.path, 'index', 
+						       'end - 1 chars'))
+      else
+	@path = TkTextMark.new(@t, tk_call_without_enc(@t.path, 'index', 
+						       index.path))
+      end
+    else
+      @path = TkTextMark.new(@t, tk_call_without_enc(@t.path, 'index', 
+						     _get_eval_enc_str(index)))
+    end
+    @path.gravity = 'left'
+    @index = @path.path
+    @id = tk_call_without_enc(@t.path, 'image', 'create', @index, 
+			      *hash_kv(keys, true))
+  end
+
+  def [](slot)
+    cget(slot)
+  end
+  def []=(slot, value)
+    configure(slot, value)
+    value
+  end
+
+  def cget(slot)
+    @t.image_cget(@index, slot)
+  end
+
+  def configure(slot, value=None)
+    @t.image_configure(@index, slot, value)
+    self
+  end
+#  def configure(slot, value)
+#    tk_call @t.path, 'image', 'configure', @index, "-#{slot}", value
+#  end
+
+  def configinfo(slot = nil)
+    @t.image_configinfo(@index, slot)
+  end
+
+  def current_configinfo(slot = nil)
+    @t.current_image_configinfo(@index, slot)
+  end
+
+  def image
+    img = tk_call_without_enc(@t.path, 'image', 'configure', @index, '-image')
+    TkImage::Tk_IMGTBL[img]? TkImage::Tk_IMGTBL[img] : img
+  end
+
+  def image=(value)
+    tk_call_without_enc(@t.path, 'image', 'configure', @index, '-image', 
+			_get_eval_enc_str(value))
+    #self
+    value
+  end
+end

ext/tk/lib/tk/textmark.rb

@@ -0,0 +1,126 @@
+#
+# tk/textmark.rb - methods for treating text marks
+#
+require 'tk'
+require 'tk/text'
+
+class TkTextMark<TkObject
+  TMarkID_TBL = TkCore::INTERP.create_table
+  Tk_TextMark_ID = ['mark'.freeze, '00000'.taint].freeze
+
+  TkCore::INTERP.init_ip_env{ TMarkID_TBL.clear }
+
+  def TkTextMark.id2obj(text, id)
+    tpath = text.path
+    return id unless TMarkID_TBL[tpath]
+    TMarkID_TBL[tpath][id]? TMarkID_TBL[tpath][id]: id
+  end
+
+  def initialize(parent, index)
+    unless parent.kind_of?(TkText)
+      fail ArguemntError, "expect TkText for 1st argument"
+    end
+    @parent = @t = parent
+    @tpath = parent.path
+    @path = @id = Tk_TextMark_ID.join('')
+    TMarkID_TBL[@id] = self
+    TMarkID_TBL[@tpath] = {} unless TMarkID_TBL[@tpath]
+    TMarkID_TBL[@tpath][@id] = self
+    Tk_TextMark_ID[1].succ!
+    tk_call_without_enc(@t.path, 'mark', 'set', @id, 
+			_get_eval_enc_str(index))
+    @t._addtag id, self
+  end
+
+  def id
+    @id
+  end
+
+  def +(mod)
+    @id + ' + ' + mod
+  end
+  def -(mod)
+    @id + ' - ' + mod
+  end
+
+  def set(where)
+    tk_call_without_enc(@t.path, 'mark', 'set', @id, 
+			_get_eval_enc_str(where))
+    self
+  end
+
+  def unset
+    tk_call_without_enc(@t.path, 'mark', 'unset', @id)
+    self
+  end
+  alias destroy unset
+
+  def gravity
+    tk_call_without_enc(@t.path, 'mark', 'gravity', @id)
+  end
+
+  def gravity=(direction)
+    tk_call_without_enc(@t.path, 'mark', 'gravity', @id, direction)
+    #self
+    direction
+  end
+
+  def next(index = nil)
+    if index
+      @t.tagid2obj(_fromUTF8(tk_call_without_enc(@t.path, 'mark', 'next', _get_eval_enc_str(index))))
+    else
+      @t.tagid2obj(_fromUTF8(tk_call_without_enc(@t.path, 'mark', 'next', @id)))
+    end
+  end
+
+  def previous(index = nil)
+    if index
+      @t.tagid2obj(_fromUTF8(tk_call_without_enc(@t.path, 'mark', 'previous', _get_eval_enc_str(index))))
+    else
+      @t.tagid2obj(_fromUTF8(tk_call_without_enc(@t.path, 'mark', 'previous', @id)))
+    end
+  end
+end
+
+class TkTextNamedMark<TkTextMark
+  def self.new(parent, name, *args)
+    if TMarkID_TBL[parent.path] && TMarkID_TBL[parent.path][name]
+      return TMarkID_TBL[parent.path][name]
+    else
+      super(parent, name, *args)
+    end
+  end
+
+  def initialize(parent, name, index=nil)
+    unless parent.kind_of?(TkText)
+      fail ArguemntError, "expect TkText for 1st argument"
+    end
+    @parent = @t = parent
+    @tpath = parent.path
+    @path = @id = name
+    TMarkID_TBL[@id] = self
+    TMarkID_TBL[@tpath] = {} unless TMarkID_TBL[@tpath]
+    TMarkID_TBL[@tpath][@id] = self unless TMarkID_TBL[@tpath][@id]
+    tk_call_without_enc(@t.path, 'mark', 'set', @id, 
+			_get_eval_enc_str(index)) if index
+    @t._addtag id, self
+  end
+end
+
+class TkTextMarkInsert<TkTextNamedMark
+  def self.new(parent,*args)
+    super(parent, 'insert', *args)
+  end
+end
+
+class TkTextMarkCurrent<TkTextMark
+  def self.new(parent,*args)
+    super(parent, 'current', *args)
+  end
+end
+
+class TkTextMarkAnchor<TkTextMark
+  def self.new(parent,*args)
+    super(parent, 'anchor', *args)
+  end
+end

ext/tk/lib/tk/texttag.rb

@@ -0,0 +1,239 @@
+#
+# tk/texttag.rb - methods for treating text tags
+#
+require 'tk'
+require 'tk/text'
+require 'tk/tagfont'
+
+class TkTextTag<TkObject
+  include TkTreatTagFont
+
+  TTagID_TBL = TkCore::INTERP.create_table
+  Tk_TextTag_ID = ['tag'.freeze, '00000'.taint].freeze
+
+  TkCore::INTERP.init_ip_env{ TTagID_TBL.clear }
+
+  def TkTextTag.id2obj(text, id)
+    tpath = text.path
+    return id unless TTagID_TBL[tpath]
+    TTagID_TBL[tpath][id]? TTagID_TBL[tpath][id]: id
+  end
+
+  def initialize(parent, *args)
+    unless parent.kind_of?(TkText)
+      fail ArguemntError, "expect TkText for 1st argument"
+    end
+    @parent = @t = parent
+    @tpath = parent.path
+    @path = @id = Tk_TextTag_ID.join('')
+    TTagID_TBL[@id] = self
+    TTagID_TBL[@tpath] = {} unless TTagID_TBL[@tpath]
+    TTagID_TBL[@tpath][@id] = self
+    Tk_TextTag_ID[1].succ!
+    #tk_call @t.path, "tag", "configure", @id, *hash_kv(keys)
+    if args != [] then
+      keys = args.pop
+      if keys.kind_of? Hash then
+	add(*args) if args != []
+	configure(keys)
+      else
+	args.push keys
+	add(*args)
+      end
+    end
+    @t._addtag id, self
+  end
+
+  def id
+    @id
+  end
+
+  def first
+    @id + '.first'
+  end
+
+  def last
+    @id + '.last'
+  end
+
+  def add(*indices)
+    tk_call_without_enc(@t.path, 'tag', 'add', @id, 
+			*(indices.collect{|idx| _get_eval_enc_str(idx)}))
+    self
+  end
+
+  def remove(*indices)
+    tk_call_without_enc(@t.path, 'tag', 'remove', @id, 
+			*(indices.collect{|idx| _get_eval_enc_str(idx)}))
+    self
+  end
+
+  def ranges
+    l = tk_split_simplelist(tk_call_without_enc(@t.path, 'tag', 'ranges', @id))
+    r = []
+    while key=l.shift
+      r.push [key, l.shift]
+    end
+    r
+  end
+
+  def nextrange(first, last=None)
+    tk_split_list(tk_call_without_enc(@t.path, 'tag', 'nextrange', @id, 
+				      _get_eval_enc_str(first), 
+				      _get_eval_enc_str(last)))
+  end
+
+  def prevrange(first, last=None)
+    tk_split_list(tk_call_without_enc(@t.path, 'tag', 'prevrange', @id, 
+				      _get_eval_enc_str(first), 
+				      _get_eval_enc_str(last)))
+  end
+
+  def [](key)
+    cget key
+  end
+
+  def []=(key,val)
+    configure key, val
+    val
+  end
+
+  def cget(key)
+    case key.to_s
+    when 'text', 'label', 'show', 'data', 'file'
+      _fromUTF8(tk_call_without_enc(@t.path, 'tag', 'cget', @id, "-#{key}"))
+    when 'font', 'kanjifont'
+      #fnt = tk_tcl2ruby(tk_call(@t.path, 'tag', 'cget', @id, "-#{key}"))
+      fnt = tk_tcl2ruby(_fromUTF8(tk_call_without_enc(@t.path, 'tag', 'cget', 
+						      @id, '-font')))
+      unless fnt.kind_of?(TkFont)
+	fnt = tagfontobj(@id, fnt)
+      end
+      if key.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
+	# obsolete; just for compatibility
+	fnt.kanji_font
+      else
+	fnt
+      end
+    else
+      tk_tcl2ruby(_fromUTF8(tk_call_without_enc(@t.path, 'tag', 'cget', 
+						@id, "-#{key}")))
+    end
+  end
+
+  def configure(key, val=None)
+    @t.tag_configure @id, key, val
+  end
+#  def configure(key, val=None)
+#    if key.kind_of? Hash
+#      tk_call @t.path, 'tag', 'configure', @id, *hash_kv(key)
+#    else
+#      tk_call @t.path, 'tag', 'configure', @id, "-#{key}", val
+#    end
+#  end
+#  def configure(key, value)
+#    if value == FALSE
+#      value = "0"
+#    elsif value.kind_of? Proc
+#      value = install_cmd(value)
+#    end
+#    tk_call @t.path, 'tag', 'configure', @id, "-#{key}", value
+#  end
+
+  def configinfo(key=nil)
+    @t.tag_configinfo @id, key
+  end
+
+  def current_configinfo(key=nil)
+    @t.current_tag_configinfo @id, key
+  end
+
+  def bind(seq, cmd=Proc.new, args=nil)
+    _bind([@t.path, 'tag', 'bind', @id], seq, cmd, args)
+    self
+  end
+
+  def bind_append(seq, cmd=Proc.new, args=nil)
+    _bind_append([@t.path, 'tag', 'bind', @id], seq, cmd, args)
+    self
+  end
+
+  def bind_remove(seq)
+    _bind_remove([@t.path, 'tag', 'bind', @id], seq)
+    self
+  end
+
+  def bindinfo(context=nil)
+    _bindinfo([@t.path, 'tag', 'bind', @id], context)
+  end
+
+  def raise(above=None)
+    tk_call_without_enc(@t.path, 'tag', 'raise', @id, 
+			_get_eval_enc_str(above))
+    self
+  end
+
+  def lower(below=None)
+    tk_call_without_enc(@t.path, 'tag', 'lower', @id, 
+			_get_eval_enc_str(below))
+    self
+  end
+
+  def destroy
+    tk_call_without_enc(@t.path, 'tag', 'delete', @id)
+    TTagID_TBL[@tpath].delete(@id) if TTagID_TBL[@tpath]
+    self
+  end
+end
+
+class TkTextNamedTag<TkTextTag
+  def self.new(parent, name, *args)
+    if TTagID_TBL[parent.path] && TTagID_TBL[parent.path][name]
+      tagobj = TTagID_TBL[parent.path][name]
+      if args != [] then
+	keys = args.pop
+	if keys.kind_of? Hash then
+	  tagobj.add(*args) if args != []
+	  tagobj.configure(keys)
+	else
+	  args.push keys
+	  tagobj.add(*args)
+	end
+      end
+      return tagobj
+    else
+      super(parent, name, *args)
+    end
+  end
+
+  def initialize(parent, name, *args)
+    unless parent.kind_of?(TkText)
+      fail ArguemntError, "expect TkText for 1st argument"
+    end
+    @parent = @t = parent
+    @tpath = parent.path
+    @path = @id = name
+    TTagID_TBL[@tpath] = {} unless TTagID_TBL[@tpath]
+    TTagID_TBL[@tpath][@id] = self unless TTagID_TBL[@tpath][@id]
+    #if mode
+    #  tk_call @t.path, "addtag", @id, *args
+    #end
+    if args != [] then
+      keys = args.pop
+      if keys.kind_of? Hash then
+	add(*args) if args != []
+	configure(keys)
+      else
+	args.push keys
+	add(*args)
+      end
+    end
+    @t._addtag id, self
+  end
+end
+
+class TkTextTagSel<TkTextNamedTag
+  def self.new(parent, *args)
+    super(parent, 'sel', *args)
+  end
+end

ext/tk/lib/tk/textwindow.rb

@@ -0,0 +1,137 @@
+#
+# tk/textwindow.rb - treat Tk text window object
+#
+require 'tk'
+require 'tk/text'
+
+class TkTextWindow<TkObject
+  def initialize(parent, index, keys)
+    unless parent.kind_of?(TkText)
+      fail ArguemntError, "expect TkText for 1st argument"
+    end
+    @t = parent
+    if index == 'end'
+      @path = TkTextMark.new(@t, tk_call_without_enc(@t.path, 'index', 
+						     'end - 1 chars'))
+    elsif index.kind_of? TkTextMark
+      if tk_call_without_enc(@t.path,'index',index.path) == tk_call_without_enc(@t.path,'index','end')
+	@path = TkTextMark.new(@t, tk_call_without_enc(@t.path, 'index', 
+						       'end - 1 chars'))
+      else
+	@path = TkTextMark.new(@t, tk_call_without_enc(@t.path, 'index', 
+						       index.path))
+      end
+    else
+      @path = TkTextMark.new(@t, tk_call_without_enc(@t.path, 'index', _get_eval_enc_str(index)))
+    end
+    @path.gravity = 'left'
+    @index = @path.path
+    keys = _symbolkey2str(keys)
+    @id = keys['window']
+    # keys['window'] = @id.epath if @id.kind_of?(TkWindow)
+    keys['window'] = _epath(@id) if @id
+    if keys['create']
+      @p_create = keys['create']
+      if @p_create.kind_of? Proc
+=begin
+	keys['create'] = install_cmd(proc{
+				       @id = @p_create.call
+				       if @id.kind_of?(TkWindow)
+					 @id.epath
+				       else
+					 @id
+				       end
+				     })
+=end
+	keys['create'] = install_cmd(proc{@id = @p_create.call; _epath(@id)})
+      end
+    end
+    tk_call_without_enc(@t.path, 'window', 'create', @index, 
+			*hash_kv(keys, true))
+  end
+
+  def [](slot)
+    cget(slot)
+  end
+  def []=(slot, value)
+    configure(slot, value)
+    value
+  end
+
+  def cget(slot)
+    @t.window_cget(@index, slot)
+  end
+
+  def configure(slot, value=None)
+    if slot.kind_of? Hash
+      slot = _symbolkey2str(slot)
+      if slot['window']
+	@id = slot['window'] 
+	# slot['window'] = @id.epath if @id.kind_of?(TkWindow)
+	slot['window'] = _epath(@id) if @id
+      end
+      if slot['create']
+	self.create=slot.delete('create')
+      end
+      if slot.size > 0
+	tk_call_without_enc(@t.path, 'window', 'configure', @index, 
+			    *hash_kv(slot, true))
+      end
+    else
+      if slot == 'window' || slot == :window
+	@id = value 
+	# value = @id.epath if @id.kind_of?(TkWindow)
+	value = _epath(@id) if @id
+      end
+      if slot == 'create' || slot == :create
+	self.create=value
+      else
+	tk_call_without_enc(@t.path, 'window', 'configure', @index, 
+			    "-#{slot}", _get_eval_enc_str(value))
+      end
+    end
+    self
+  end
+
+  def configinfo(slot = nil)
+    @t.window_configinfo(@index, slot)
+  end
+
+  def current_configinfo(slot = nil)
+    @t.current_window_configinfo(@index, slot)
+  end
+
+  def window
+    @id
+  end
+
+  def window=(value)
+    @id = value
+    # value = @id.epath if @id.kind_of?(TkWindow)
+    value = _epath(@id) if @id
+    tk_call_without_enc(@t.path, 'window', 'configure', @index, 
+			'-window', _get_eval_enc_str(value))
+    value
+  end
+
+  def create
+    @p_create
+  end
+
+  def create=(value)
+    @p_create = value
+    if @p_create.kind_of? Proc
+      value = install_cmd(proc{
+			    @id = @p_create.call
+			    if @id.kind_of?(TkWindow)
+			      @id.epath
+			    else
+			      @id
+			    end
+			  })
+    end
+    tk_call_without_enc(@t.path, 'window', 'configure', @index, 
+			'-create', _get_eval_enc_str(value))
+    value
+  end
+end

ext/tk/lib/tk/timer.rb

@@ -0,0 +1,441 @@
+#
+#   tk/timer.rb : methods for Tcl/Tk after command
+#
+#   $Id$
+#
+require 'tk'
+
+class TkTimer
+  include TkCore
+  extend TkCore
+
+  TkCommandNames = ['after'.freeze].freeze
+
+  Tk_CBID = ['a'.freeze, '00000'.taint].freeze
+  Tk_CBTBL = {}.taint
+
+  TkCore::INTERP.add_tk_procs('rb_after', 'id', <<-'EOL')
+    if {[set st [catch {eval {ruby_cmd TkTimer callback} $id} ret]] != 0} {
+	return -code $st $ret
+    } {
+	return $ret
+    }
+  EOL
+
+  DEFAULT_IGNORE_EXCEPTIONS = [ NameError, RuntimeError ].freeze
+
+  ###############################
+  # class methods
+  ###############################
+  def self.callback(obj_id)
+    @after_id = nil
+    ex_obj = Tk_CBTBL[obj_id]
+    return "" if ex_obj == nil; # canceled
+    ex_obj.cb_call
+  end
+
+  def self.info(obj = nil)
+    if obj
+      if obj.kind_of?(TkTimer)
+	if obj.after_id
+	  inf = tk_split_list(tk_call_without_enc('after','info',obj.after_id))
+	  [Tk_CBTBL[inf[0][1]], inf[1]]
+	else
+	  nil
+	end
+      else
+	fail ArgumentError, "TkTimer object is expected"
+      end
+    else
+      tk_call_without_enc('after', 'info').split(' ').collect!{|id|
+	ret = Tk_CBTBL.find{|key,val| val.after_id == id}
+	(ret == nil)? id: ret[1]
+      }
+    end
+  end
+
+  ###############################
+  # instance methods
+  ###############################
+  def do_callback
+    @in_callback = true
+    begin
+      @return_value = @current_proc.call(self)
+    rescue Exception => e
+      if @cancel_on_exception && 
+	  @cancel_on_exception.find{|exc| e.kind_of?(exc)}
+	cancel
+	@return_value = e
+	return e
+      else
+	fail e
+      end
+    end
+    if @set_next
+      set_next_callback(@current_args)
+    else
+      @set_next = true
+    end
+    @in_callback = false
+    @return_value
+  end
+
+  def set_callback(sleep, args=nil)
+    @after_script = "rb_after #{@id}"
+    @after_id = tk_call_without_enc('after', sleep, @after_script)
+    @current_args = args
+    @current_script = [sleep, @after_script]
+    self
+  end
+
+  def set_next_callback(args)
+    if @running == false || @proc_max == 0 || @do_loop == 0
+      Tk_CBTBL.delete(@id) ;# for GC
+      @running = false
+      @wait_var.value = 0
+      return
+    end
+    if @current_pos >= @proc_max
+      if @do_loop < 0 || (@do_loop -= 1) > 0
+	@current_pos = 0
+      else
+	Tk_CBTBL.delete(@id) ;# for GC
+	@running = false
+	@wait_var.value = 0
+	return
+      end
+    end
+
+    @current_args = args
+
+    if @sleep_time.kind_of? Proc
+      sleep = @sleep_time.call(self)
+    else
+      sleep = @sleep_time
+    end
+    @current_sleep = sleep
+
+    cmd, *cmd_args = @loop_proc[@current_pos]
+    @current_pos += 1
+    @current_proc = cmd
+
+    set_callback(sleep, cmd_args)
+  end
+
+  def initialize(*args)
+    @id = Tk_CBID.join('')
+    Tk_CBID[1].succ!
+
+    @wait_var = TkVariable.new(0)
+
+    @cb_cmd = TkCore::INTERP.get_cb_entry(self.method(:do_callback))
+
+    @set_next = true
+
+    @init_sleep = 0
+    @init_proc = nil
+    @init_args = []
+
+    @current_script = []
+    @current_proc = nil
+    @current_args = nil
+    @return_value = nil
+
+    @sleep_time = 0
+    @current_sleep = 0
+    @loop_exec = 0
+    @do_loop = 0
+    @loop_proc = []
+    @proc_max = 0
+    @current_pos = 0
+
+    @after_id = nil
+    @after_script = nil
+
+    @cancel_on_exception = DEFAULT_IGNORE_EXCEPTIONS
+    # Unless @cancel_on_exception, Ruby/Tk shows an error dialog box when 
+    # an excepsion is raised on TkTimer callback procedure. 
+    # If @cancel_on_exception is an array of exception classes and the raised 
+    # exception is included in the array, Ruby/Tk cancels executing TkTimer 
+    # callback procedures silently (TkTimer#cancel is called and no dialog is 
+    # shown). 
+
+    set_procs(*args) if args != []
+
+    @running = false
+    @in_callback = false
+  end
+
+  attr :after_id
+  attr :after_script
+  attr :current_proc
+  attr :current_args
+  attr :current_sleep
+  alias :current_interval :current_sleep
+  attr :return_value
+
+  attr_accessor :loop_exec
+
+  def cb_call
+    @cb_cmd.call
+  end
+
+  def get_procs
+    [@init_sleep, @init_proc, @init_args, @sleep_time, @loop_exec, @loop_proc]
+  end
+
+  def current_status
+    [@running, @current_sleep, @current_proc, @current_args, 
+      @do_loop, @cancel_on_exception]
+  end
+
+  def cancel_on_exception?
+    @cancel_on_exception
+  end
+
+  def cancel_on_exception=(mode)
+    if mode.kind_of?(Array)
+      @cancel_on_exception = mode
+    elsif mode
+      @cancel_on_exception = DEFAULT_IGNORE_EXCEPTIONS
+    else
+      @cancel_on_exception = false
+    end
+    #self
+  end
+
+  def running?
+    @running
+  end
+
+  def loop_rest
+    @do_loop
+  end
+
+  def loop_rest=(rest)
+    @do_loop = rest
+    #self
+  end
+
+  def set_procs(interval, loop_exec, *procs)
+    if !interval == 'idle' \
+       && !interval.kind_of?(Integer) && !interval.kind_of?(Proc)
+      fail ArguemntError, "expect Integer or Proc for 1st argument"
+    end
+    @sleep_time = interval
+
+    @loop_proc = []
+    procs.each{|e|
+      if e.kind_of? Proc
+	@loop_proc.push([e])
+      else
+	@loop_proc.push(e)
+      end
+    }
+    @proc_max = @loop_proc.size
+    @current_pos = 0
+
+    @do_loop = 0
+    if loop_exec
+      if loop_exec.kind_of?(Integer) && loop_exec < 0
+	@loop_exec = -1
+      elsif loop_exec == nil || loop_exec == false || loop_exec == 0
+	@loop_exec = 1
+      else
+	if not loop_exec.kind_of?(Integer)
+	  fail ArguemntError, "expect Integer for 2nd argument"
+	end
+	@loop_exec = loop_exec
+      end
+      @do_loop = @loop_exec
+    end
+
+    self
+  end
+
+  def add_procs(*procs)
+    procs.each{|e|
+      if e.kind_of? Proc
+	@loop_proc.push([e])
+      else
+	@loop_proc.push(e)
+      end
+    }
+    @proc_max = @loop_proc.size
+
+    self
+  end
+
+  def delete_procs(*procs)
+    procs.each{|e|
+      if e.kind_of? Proc
+	@loop_proc.delete([e])
+      else
+	@loop_proc.delete(e)
+      end
+    }
+    @proc_max = @loop_proc.size
+
+    cancel if @proc_max == 0
+
+    self
+  end
+
+  def delete_at(n)
+    @loop_proc.delete_at(n)
+    @proc_max = @loop_proc.size
+    cancel if @proc_max == 0
+    self
+  end
+
+  def set_start_proc(sleep, init_proc, *init_args)
+    if !sleep == 'idle' && !sleep.kind_of?(Integer)
+      fail ArguemntError, "expect Integer or 'idle' for 1st argument"
+    end
+    @init_sleep = sleep
+    @init_proc = init_proc
+    @init_args = init_args
+    self
+  end
+
+  def start(*init_args)
+    return nil if @running
+
+    Tk_CBTBL[@id] = self
+    @do_loop = @loop_exec
+    @current_pos = 0
+
+    argc = init_args.size
+    if argc > 0
+      sleep = init_args.shift
+      if !sleep == 'idle' && !sleep.kind_of?(Integer)
+	fail ArguemntError, "expect Integer or 'idle' for 1st argument"
+      end
+      @init_sleep = sleep
+    end
+    @init_proc = init_args.shift if argc > 1
+    @init_args = init_args if argc > 0
+
+    @current_sleep = @init_sleep
+    @running = true
+    if @init_proc
+      if not @init_proc.kind_of? Proc
+	fail ArgumentError, "Argument '#{@init_proc}' need to be Proc"
+      end
+      @current_proc = @init_proc
+      set_callback(@init_sleep, @init_args)
+      @set_next = false if @in_callback
+    else
+      set_next_callback(@init_args)
+    end
+
+    self
+  end
+
+  def reset(*reset_args)
+    restart() if @running
+
+    if @init_proc
+      @return_value = @init_proc.call(self)
+    else
+      @return_value = nil
+    end
+
+    @current_pos   = 0
+    @current_args  = @init_args
+    @set_next = false if @in_callback
+
+    self
+  end
+
+  def restart(*restart_args)
+    cancel if @running
+    if restart_args == []
+      start(@init_sleep, @init_proc, *@init_args)
+    else
+      start(*restart_args)
+    end
+  end
+
+  def cancel
+    @running = false
+    @wait_var.value = 0
+    tk_call 'after', 'cancel', @after_id if @after_id
+    @after_id = nil
+    Tk_CBTBL.delete(@id) ;# for GC
+    self
+  end
+  alias stop cancel
+
+  def continue(wait=nil)
+    fail RuntimeError, "is already running" if @running
+    sleep, cmd = @current_script
+    fail RuntimeError, "no procedure to continue" unless cmd
+    if wait
+      unless wait.kind_of? Integer
+	fail ArguemntError, "expect Integer for 1st argument"
+      end
+      sleep = wait
+    end
+    Tk_CBTBL[@id] = self
+    @running = true
+    @after_id = tk_call_without_enc('after', sleep, cmd)
+    self
+  end
+
+  def skip
+    fail RuntimeError, "is not running now" unless @running
+    cancel
+    Tk_CBTBL[@id] = self
+    @running = true
+    set_next_callback(@current_args)
+    self
+  end
+
+  def info
+    if @after_id
+      inf = tk_split_list(tk_call_without_enc('after', 'info', @after_id))
+      [Tk_CBTBL[inf[0][1]], inf[1]]
+    else
+      nil
+    end
+  end
+
+  def wait(on_thread = true, check_root = false)
+    if $SAFE >= 4
+      fail SecurityError, "can't wait timer at $SAFE >= 4"
+    end
+
+    unless @running
+      if @return_value.kind_of?(Exception)
+	fail @return_value 
+      else
+	return @return_value 
+      end
+    end
+
+    @wait_var.wait(on_thread, check_root)
+    if @return_value.kind_of?(Exception)
+      fail @return_value 
+    else
+      @return_value 
+    end
+  end
+  def eventloop_wait(check_root = false)
+    wait(false, check_root)
+  end
+  def thread_wait(check_root = false)
+    wait(true, check_root)
+  end
+  def tkwait(on_thread = true)
+    wait(on_thread, true)
+  end
+  def eventloop_tkwait
+    wait(false, true)
+  end
+  def thread_tkwait
+    wait(true, true)
+  end
+end
+
+TkAfter = TkTimer

ext/tk/lib/tk/toplevel.rb

@@ -0,0 +1,211 @@
+#
+# tk/toplevel.rb : treat toplevel widget
+#
+require 'tk'
+require 'tk/wm'
+
+class TkToplevel<TkWindow
+  include Wm
+
+  TkCommandNames = ['toplevel'.freeze].freeze
+  WidgetClassName = 'Toplevel'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+################# old version
+#  def initialize(parent=nil, screen=nil, classname=nil, keys=nil)
+#    if screen.kind_of? Hash
+#      keys = screen.dup
+#    else
+#      @screen = screen
+#    end
+#    @classname = classname
+#    if keys.kind_of? Hash
+#      keys = keys.dup
+#      @classname = keys.delete('classname') if keys.key?('classname')
+#      @colormap  = keys.delete('colormap')  if keys.key?('colormap')
+#      @container = keys.delete('container') if keys.key?('container')
+#      @screen    = keys.delete('screen')    if keys.key?('screen')
+#      @use       = keys.delete('use')       if keys.key?('use')
+#      @visual    = keys.delete('visual')    if keys.key?('visual')
+#    end
+#    super(parent, keys)
+#  end
+#
+#  def create_self
+#    s = []
+#    s << "-class"     << @classname if @classname
+#    s << "-colormap"  << @colormap  if @colormap
+#    s << "-container" << @container if @container
+#    s << "-screen"    << @screen    if @screen 
+#    s << "-use"       << @use       if @use
+#    s << "-visual"    << @visual    if @visual
+#    tk_call 'toplevel', @path, *s
+#  end
+#################
+
+  def _wm_command_option_chk(keys)
+    keys = {} unless keys
+    new_keys = {}
+    wm_cmds = {}
+    keys.each{|k,v|
+      if Wm.method_defined?(k)
+	case k
+	when 'screen','class','colormap','container','use','visual'
+	  new_keys[k] = v
+	else
+	  case self.method(k).arity
+	  when -1,1
+	    wm_cmds[k] = v
+	  else
+	    new_keys[k] = v
+	  end
+	end
+      else
+	new_keys[k] = v
+      end
+    }
+    [new_keys, wm_cmds]
+  end
+  private :_wm_command_option_chk
+
+  def initialize(parent=nil, screen=nil, classname=nil, keys=nil)
+    my_class_name = nil
+    if self.class < WidgetClassNames[WidgetClassName]
+      my_class_name = self.class.name
+      my_class_name = nil if my_class_name == ''
+    end
+    if parent.kind_of? Hash
+      keys = _symbolkey2str(parent)
+      if keys.key?('classname')
+	keys['class'] = keys.delete('classname')
+      end
+      @classname = keys['class']
+      @colormap  = keys['colormap']
+      @container = keys['container']
+      @screen    = keys['screen']
+      @use       = keys['use']
+      @visual    = keys['visual']
+      if !@classname && my_class_name
+	keys['class'] = @classname = my_class_name 
+      end
+      if @classname.kind_of? TkBindTag
+	@db_class = @classname
+	@classname = @classname.id
+      elsif @classname
+	@db_class = TkDatabaseClass.new(@classname)
+      else
+	@db_class = self.class
+	@classname = @db_class::WidgetClassName
+      end
+      keys, cmds = _wm_command_option_chk(keys)
+      super(keys)
+      cmds.each{|k,v| 
+	if v.kind_of? Array
+	  self.send(k,*v)
+	else
+	  self.send(k,v)
+	end
+      }
+      return
+    end
+
+    if screen.kind_of? Hash
+      keys = screen
+    else
+      @screen = screen
+      if classname.kind_of? Hash
+	keys = classname
+      else
+	@classname = classname
+      end
+    end
+    if keys.kind_of? Hash
+      keys = _symbolkey2str(keys)
+      if keys.key?('classname')
+	keys['class'] = keys.delete('classname')
+      end
+      @classname = keys['class']  unless @classname
+      @colormap  = keys['colormap']
+      @container = keys['container']
+      @screen    = keys['screen'] unless @screen
+      @use       = keys['use']
+      @visual    = keys['visual']
+    else
+      keys = {}
+    end
+    if !@classname && my_class_name
+      keys['class'] = @classname = my_class_name 
+    end
+    if @classname.kind_of? TkBindTag
+      @db_class = @classname
+      @classname = @classname.id
+    elsif @classname
+      @db_class = TkDatabaseClass.new(@classname)
+    else
+      @db_class = self.class
+      @classname = @db_class::WidgetClassName
+    end
+    keys, cmds = _wm_command_option_chk(keys)
+    super(parent, keys)
+    cmds.each{|k,v| 
+      if v.kind_of? Array
+	self.send(k,*v)
+      else
+	self.send(k,v)
+      end
+    }
+  end
+
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc('toplevel', @path, *hash_kv(keys, true))
+    else
+      tk_call_without_enc('toplevel', @path)
+    end
+  end
+  private :create_self
+
+  def specific_class
+    @classname
+  end
+
+  def self.database_class
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      self
+    else
+      TkDatabaseClass.new(self.name)
+    end
+  end
+  def self.database_classname
+    self.database_class.name
+  end
+
+  def self.bind(*args)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args)
+    else
+      TkDatabaseClass.new(self.name).bind(*args)
+    end
+  end
+  def self.bind_append(*args)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args)
+    else
+      TkDatabaseClass.new(self.name).bind_append(*args)
+    end
+  end
+  def self.bind_remove(*args)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args)
+    else
+      TkDatabaseClass.new(self.name).bind_remove(*args)
+    end
+  end
+  def self.bindinfo(*args)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args)
+    else
+      TkDatabaseClass.new(self.name).bindinfo(*args)
+    end
+  end
+end

ext/tk/lib/tk/txtwin_abst.rb

@@ -0,0 +1,38 @@
+#
+# tk/txtwin_abst.rb : TkTextWin abstruct class
+#
+require 'tk'
+
+class TkTextWin<TkWindow
+  def create_self
+    fail RuntimeError, "TkTextWin is an abstract class"
+  end
+  private :create_self
+
+  def bbox(index)
+    list(tk_send_without_enc('bbox', index))
+  end
+  def delete(first, last=None)
+    tk_send_without_enc('delete', first, last)
+    self
+  end
+  def get(*index)
+    _fromUTF8(tk_send_without_enc('get', *index))
+  end
+  def insert(index, *args)
+    tk_send('insert', index, *args)
+    self
+  end
+  def scan_mark(x, y)
+    tk_send_without_enc('scan', 'mark', x, y)
+    self
+  end
+  def scan_dragto(x, y)
+    tk_send_without_enc('scan', 'dragto', x, y)
+    self
+  end
+  def see(index)
+    tk_send_without_enc('see', index)
+    self
+  end
+end

ext/tk/lib/tk/validation.rb

@@ -0,0 +1,166 @@
+#
+#  tk/validation.rb - validation support module for entry, spinbox, and so on
+#
+require 'tk'
+
+module TkValidation
+  class ValidateCmd
+    include TkComm
+
+    module Action
+      Insert = 1
+      Delete = 0
+      Others = -1
+      Focus  = -1
+      Forced = -1
+      Textvariable = -1
+      TextVariable = -1
+    end
+
+    class ValidateArgs < TkUtil::CallbackSubst
+      key_tbl = [
+	[ ?d, ?n, :action ], 
+	[ ?i, ?x, :index ], 
+	[ ?s, ?e, :current ], 
+	[ ?v, ?s, :type ], 
+	[ ?P, ?e, :value ], 
+	[ ?S, ?e, :string ], 
+	[ ?V, ?s, :triggered ], 
+	[ ?W, ?w, :widget ], 
+	nil
+      ]
+
+      proc_tbl = [
+	[ ?n, TkComm.method(:number) ], 
+	[ ?s, TkComm.method(:string) ], 
+	[ ?w, TkComm.method(:window) ], 
+
+	[ ?e, proc{|val|
+	    enc = Tk.encoding
+	    if enc
+	      Tk.fromUTF8(TkComm::string(val), enc)
+	    else
+	      TkComm::string(val)
+	    end
+	  }
+	], 
+
+	[ ?x, proc{|val|
+	    idx = TkComm::number(val)
+	    if idx < 0
+	      nil
+	    else
+	      idx
+	    end
+	  }
+	], 
+
+	nil
+      ]
+
+      _setup_subst_table(key_tbl, proc_tbl);
+    end
+
+    def initialize(cmd = Proc.new, *args)
+      if args.compact.size > 0
+	args = args.join(' ')
+	keys = ValidateArgs._get_subst_key(args)
+	if cmd.kind_of?(String)
+	  id = cmd
+	elsif cmd.kind_of?(TkCallbackEntry)
+	  @id = install_cmd(cmd)
+	else
+	  @id = install_cmd(proc{|*arg|
+	     (cmd.call(*ValidateArgs.scan_args(keys, arg)))? '1':'0'
+	  }) + ' ' + args
+	end
+      else
+	keys, args = ValidateArgs._get_all_subst_keys
+	if cmd.kind_of?(String)
+	  id = cmd
+	elsif cmd.kind_of?(TkCallbackEntry)
+	  @id = install_cmd(cmd)
+	else
+	  @id = install_cmd(proc{|*arg|
+	     (cmd.call(
+                ValidateArgs.new(*ValidateArgs.scan_args(keys,arg)))
+             )? '1': '0'
+	  }) + ' ' + args
+	end
+      end
+    end
+
+    def to_eval
+      @id
+    end
+  end
+
+  #####################################
+
+  def configure(slot, value=TkComm::None)
+    if slot.kind_of? Hash
+      slot = _symbolkey2str(slot)
+      if slot['vcmd'].kind_of? Array
+	cmd, *args = slot['vcmd']
+	slot['vcmd'] = ValidateCmd.new(cmd, args.join(' '))
+      elsif slot['vcmd'].kind_of? Proc
+	slot['vcmd'] = ValidateCmd.new(slot['vcmd'])
+      end
+      if slot['validatecommand'].kind_of? Array
+	cmd, *args = slot['validatecommand']
+	slot['validatecommand'] = ValidateCmd.new(cmd, args.join(' '))
+      elsif slot['validatecommand'].kind_of? Proc
+	slot['validatecommand'] = ValidateCmd.new(slot['validatecommand'])
+      end
+      if slot['invcmd'].kind_of? Array
+	cmd, *args = slot['invcmd']
+	slot['invcmd'] = ValidateCmd.new(cmd, args.join(' '))
+      elsif slot['invcmd'].kind_of? Proc
+	slot['invcmd'] = ValidateCmd.new(slot['invcmd'])
+      end
+      if slot['invalidcommand'].kind_of? Array
+	cmd, *args = slot['invalidcommand']
+	slot['invalidcommand'] = ValidateCmd.new(cmd, args.join(' '))
+      elsif slot['invalidcommand'].kind_of? Proc
+	slot['invalidcommand'] = ValidateCmd.new(slot['invalidcommand'])
+      end
+      super(slot)
+    else
+      if (slot == 'vcmd' || slot == :vcmd || 
+          slot == 'validatecommand' || slot == :validatecommand || 
+	  slot == 'invcmd' || slot == :invcmd || 
+          slot == 'invalidcommand' || slot == :invalidcommand)
+	if value.kind_of? Array
+	  cmd, *args = value
+	  value = ValidateCmd.new(cmd, args.join(' '))
+	elsif value.kind_of? Proc
+	  value = ValidateCmd.new(value)
+	end
+      end
+      super(slot, value)
+    end
+    self
+  end
+
+  def validatecommand(cmd = Proc.new, args = nil)
+    if cmd.kind_of?(ValidateCmd)
+      configure('validatecommand', cmd)
+    elsif args
+      configure('validatecommand', [cmd, args])
+    else
+      configure('validatecommand', cmd)
+    end
+  end
+  alias vcmd validatecommand
+
+  def invalidcommand(cmd = Proc.new, args = nil)
+    if cmd.kind_of?(ValidateCmd)
+      configure('invalidcommand', cmd)
+    elsif args
+      configure('invalidcommand', [cmd, args])
+    else
+      configure('invalidcommand', cmd)
+    end
+  end
+  alias invcmd invalidcommand
+end

ext/tk/lib/tk/variable.rb

@@ -0,0 +1,847 @@
+#
+# tk/variable.rb : treat Tk variable object
+#
+require 'tk'
+
+class TkVariable
+  include Tk
+  extend TkCore
+
+  include Comparable
+
+  #TkCommandNames = ['tkwait'.freeze].freeze
+  TkCommandNames = ['vwait'.freeze].freeze
+
+  #TkVar_CB_TBL = {}
+  #TkVar_ID_TBL = {}
+  TkVar_CB_TBL = TkCore::INTERP.create_table
+  TkVar_ID_TBL = TkCore::INTERP.create_table
+  Tk_VARIABLE_ID = ["v".freeze, "00000".taint].freeze
+
+  #TkCore::INTERP.add_tk_procs('rb_var', 'args', 
+  #	"ruby [format \"TkVariable.callback %%Q!%s!\" $args]")
+TkCore::INTERP.add_tk_procs('rb_var', 'args', <<-'EOL')
+    if {[set st [catch {eval {ruby_cmd TkVariable callback} $args} ret]] != 0} {
+       set idx [string first "\n\n" $ret]
+       if {$idx > 0} {
+	  global errorInfo
+	  set tcl_backtrace $errorInfo
+	  set errorInfo [string range $ret [expr $idx + 2] \
+                                           [string length $ret]]
+          append errorInfo "\n" $tcl_backtrace
+	  bgerror [string range $ret 0 [expr $idx - 1]]
+       } else {
+          bgerror $ret
+       }
+       return ""
+       #return -code $st $ret
+    } else {
+	return $ret
+    }
+  EOL
+
+  #def TkVariable.callback(args)
+  def TkVariable.callback(name1, name2, op)
+    #name1,name2,op = tk_split_list(args)
+    #name1,name2,op = tk_split_simplelist(args)
+    if TkVar_CB_TBL[name1]
+      #_get_eval_string(TkVar_CB_TBL[name1].trace_callback(name2,op))
+      begin
+	_get_eval_string(TkVar_CB_TBL[name1].trace_callback(name2, op))
+      rescue Exception => e
+	begin
+	  msg = _toUTF8(e.class.inspect) + ': ' + 
+	        _toUTF8(e.message) + "\n" + 
+	        "\n---< backtrace of Ruby side >-----\n" + 
+	        _toUTF8(e.backtrace.join("\n")) + 
+	        "\n---< backtrace of Tk side >-------"
+	  msg.instance_variable_set(:@encoding, 'utf-8')
+	rescue Exception
+	  msg = e.class.inspect + ': ' + e.message + "\n" + 
+	        "\n---< backtrace of Ruby side >-----\n" + 
+	        e.backtrace.join("\n") + 
+	        "\n---< backtrace of Tk side >-------"
+	end
+	fail(e, msg)
+      end
+=begin
+      begin
+	raise 'check backtrace'
+      rescue
+	# ignore backtrace before 'callback'
+	pos = -($!.backtrace.size)
+      end
+      begin
+	_get_eval_string(TkVar_CB_TBL[name1].trace_callback(name2,op))
+      rescue
+	trace = $!.backtrace
+	raise $!, "\n#{trace[0]}: #{$!.message} (#{$!.class})\n" + 
+	          "\tfrom #{trace[1..pos].join("\n\tfrom ")}"
+      end
+=end
+    else
+      ''
+    end
+  end
+
+  def initialize(val="")
+    @id = Tk_VARIABLE_ID.join('')
+    Tk_VARIABLE_ID[1].succ!
+    TkVar_ID_TBL[@id] = self
+
+    @trace_var  = nil
+    @trace_elem = nil
+    @trace_opts = nil
+
+    begin
+      INTERP._unset_global_var(@id)
+    rescue
+    end
+
+    # teach Tk-ip that @id is global var
+    INTERP._invoke_without_enc('global', @id)
+    #INTERP._invoke('global', @id)
+
+    self.value = val
+
+=begin
+    if val == []
+      # INTERP._eval(format('global %s; set %s(0) 0; unset %s(0)', 
+      #	                    @id, @id, @id))
+    elsif val.kind_of?(Array)
+      a = []
+      # val.each_with_index{|e,i| a.push(i); a.push(array2tk_list(e))}
+      # s = '"' + a.join(" ").gsub(/[\[\]$"]/, '\\\\\&') + '"'
+      val.each_with_index{|e,i| a.push(i); a.push(e)}
+      #s = '"' + array2tk_list(a).gsub(/[\[\]$"]/, '\\\\\&') + '"'
+      s = '"' + array2tk_list(a).gsub(/[\[\]$"\\]/, '\\\\\&') + '"'
+      INTERP._eval(format('global %s; array set %s %s', @id, @id, s))
+    elsif  val.kind_of?(Hash)
+      #s = '"' + val.to_a.collect{|e| array2tk_list(e)}.join(" ")\
+      #             .gsub(/[\[\]$"]/, '\\\\\&') + '"'
+      s = '"' + val.to_a.collect{|e| array2tk_list(e)}.join(" ")\
+                   .gsub(/[\[\]$"\\]/, '\\\\\&') + '"'
+      INTERP._eval(format('global %s; array set %s %s', @id, @id, s))
+    else
+      #s = '"' + _get_eval_string(val).gsub(/[\[\]$"]/, '\\\\\&') + '"'
+      s = '"' + _get_eval_string(val).gsub(/[\[\]$"\\]/, '\\\\\&') + '"'
+      INTERP._eval(format('global %s; set %s %s', @id, @id, s))
+    end
+=end
+=begin
+    if  val.kind_of?(Hash)
+      #s = '"' + val.to_a.collect{|e| array2tk_list(e)}.join(" ")\
+      #             .gsub(/[\[\]$"]/, '\\\\\&') + '"'
+      s = '"' + val.to_a.collect{|e| array2tk_list(e)}.join(" ")\
+                   .gsub(/[\[\]$"\\]/, '\\\\\&') + '"'
+      INTERP._eval(Kernel.format('global %s; array set %s %s', @id, @id, s))
+    else
+      #s = '"' + _get_eval_string(val).gsub(/[\[\]$"]/, '\\\\\&') + '"'
+      s = '"' + _get_eval_string(val).gsub(/[\[\]$"\\]/, '\\\\\&') + '"'
+      INTERP._eval(Kernel.format('global %s; set %s %s', @id, @id, s))
+    end
+=end
+  end
+
+  def wait(on_thread = false, check_root = false)
+    if $SAFE >= 4
+      fail SecurityError, "can't wait variable at $SAFE >= 4"
+    end
+    on_thread &= (Thread.list.size != 1)
+    if on_thread
+      if check_root
+	INTERP._thread_tkwait('variable', @id)
+      else
+	INTERP._thread_vwait(@id)
+      end
+    else 
+      if check_root
+	INTERP._invoke_without_enc('tkwait', 'variable', @id)
+      else
+	INTERP._invoke_without_enc('vwait', @id)
+      end
+    end
+  end
+  def eventloop_wait(check_root = false)
+    wait(false, check_root)
+  end
+  def thread_wait(check_root = false)
+    wait(true, check_root)
+  end
+  def tkwait(on_thread = true)
+    wait(on_thread, true)
+  end
+  def eventloop_tkwait
+    wait(false, true)
+  end
+  def thread_tkwait
+    wait(true, true)
+  end
+
+  def id
+    @id
+  end
+
+  def is_hash?
+    #ITNERP._eval("global #{@id}; array exist #{@id}") == '1'
+    ITNERP._invoke_without_enc('array', 'exist', @id) == '1'
+  end
+
+  def is_scalar?
+    ! is_hash?
+  end
+
+  def keys
+    if (is_scalar?)
+      fail RuntimeError, 'cannot get keys from a scalar variable'
+    end
+    #tk_split_simplelist(INTERP._eval("global #{@id}; array get #{@id}"))
+    tk_split_simplelist(INTERP._fromUTF8(INTERP._invoke_without_enc('array', 'get', @id)))
+  end
+
+
+unless const_defined?(:USE_TCLs_SET_VARIABLE_FUNCTIONS)
+  USE_TCLs_SET_VARIABLE_FUNCTIONS = true
+end
+
+if USE_TCLs_SET_VARIABLE_FUNCTIONS
+  ###########################################################################
+  # use Tcl function version of set tkvariable
+  ###########################################################################
+
+  def value
+    #if INTERP._eval("global #{@id}; array exist #{@id}") == '1'
+    if INTERP._invoke('array', 'exist', @id) == '1'
+      #Hash[*tk_split_simplelist(INTERP._eval("global #{@id}; array get #{@id}"))]
+      Hash[*tk_split_simplelist(INTERP._invoke('array', 'get', @id))]
+    else
+      _fromUTF8(INTERP._get_global_var(@id))
+    end
+  end
+
+  def value=(val)
+    if val.kind_of?(Hash)
+      val.each{|k, v|
+	#INTERP._set_global_var2(@id, _toUTF8(_get_eval_string(k)), 
+	#			_toUTF8(_get_eval_string(v)))
+	INTERP._set_global_var2(@id, __get_eval_string(k, true), 
+				_get_eval_string(v, true))
+      }
+      self.value
+    elsif val.kind_of?(Array)
+      INTERP._set_global_var(@id, '')
+      val.each{|v|
+	#INTERP._set_variable(@id, _toUTF8(_get_eval_string(v)), 
+	INTERP._set_variable(@id, _get_eval_string(v, true), 
+			     TclTkLib::VarAccessFlag::GLOBAL_ONLY   | 
+			     TclTkLib::VarAccessFlag::LEAVE_ERR_MSG |
+			     TclTkLib::VarAccessFlag::APPEND_VALUE  | 
+			     TclTkLib::VarAccessFlag::LIST_ELEMENT)
+      }
+      self.value
+    else
+      #_fromUTF8(INTERP._set_global_var(@id, _toUTF8(_get_eval_string(val))))
+      _fromUTF8(INTERP._set_global_var(@id, _get_eval_string(val, true)))
+    end
+  end
+
+  def [](index)
+    #_fromUTF8(INTERP._get_global_var2(@id, _toUTF8(_get_eval_string(index))))
+    _fromUTF8(INTERP._get_global_var2(@id, _get_eval_string(index, true)))
+  end
+
+  def []=(index,val)
+    #_fromUTF8(INTERP._set_global_var2(@id, _toUTF8(_get_eval_string(index)), 
+    #				      _toUTF8(_get_eval_string(val))))
+    _fromUTF8(INTERP._set_global_var2(@id, _get_eval_string(index, true), 
+				      _get_eval_string(val, true)))
+  end
+
+  def unset(elem=nil)
+    if elem
+      INTERP._unset_global_var2(@id, tk_tcl2ruby(elem))
+    else
+      INTERP._unset_global_var(@id)
+    end
+  end
+  alias remove unset
+
+else
+  ###########################################################################
+  # use Ruby script version of set tkvariable (traditional methods)
+  ###########################################################################
+
+  def value
+    begin
+      INTERP._eval(Kernel.format('global %s; set %s', @id, @id))
+      #INTERP._eval(Kernel.format('set %s', @id))
+      #INTERP._invoke_without_enc('set', @id)
+    rescue
+      if INTERP._eval(Kernel.format('global %s; array exists %s', 
+      			    @id, @id)) != "1"
+      #if INTERP._eval(Kernel.format('array exists %s', @id)) != "1"
+      #if INTERP._invoke_without_enc('array', 'exists', @id) != "1"
+	fail
+      else
+	Hash[*tk_split_simplelist(INTERP._eval(Kernel.format('global %s; array get %s', @id, @id)))]
+	#Hash[*tk_split_simplelist(_fromUTF8(INTERP._invoke_without_enc('array', 'get', @id)))]
+      end
+    end
+  end
+
+  def value=(val)
+    begin
+      #s = '"' + _get_eval_string(val).gsub(/[\[\]$"]/, '\\\\\&') + '"'
+      s = '"' + _get_eval_string(val).gsub(/[\[\]$"\\]/, '\\\\\&') + '"'
+      INTERP._eval(Kernel.format('global %s; set %s %s', @id, @id, s))
+      #INTERP._eval(Kernel.format('set %s %s', @id, s))
+      #_fromUTF8(INTERP._invoke_without_enc('set', @id, _toUTF8(s)))
+    rescue
+      if INTERP._eval(Kernel.format('global %s; array exists %s', 
+      			    @id, @id)) != "1"
+      #if INTERP._eval(Kernel.format('array exists %s', @id)) != "1"
+      #if INTERP._invoke_without_enc('array', 'exists', @id) != "1"
+	fail
+      else
+	if val == []
+	  INTERP._eval(Kernel.format('global %s; unset %s; set %s(0) 0; unset %s(0)', @id, @id, @id, @id))
+	  #INTERP._eval(Kernel.format('unset %s; set %s(0) 0; unset %s(0)', 
+	  #			     @id, @id, @id))
+	  #INTERP._invoke_without_enc('unset', @id)
+	  #INTERP._invoke_without_enc('set', @id+'(0)', 0)
+	  #INTERP._invoke_without_enc('unset', @id+'(0)')
+	elsif val.kind_of?(Array)
+	  a = []
+	  val.each_with_index{|e,i| a.push(i); a.push(array2tk_list(e))}
+	  #s = '"' + a.join(" ").gsub(/[\[\]$"]/, '\\\\\&') + '"'
+	  s = '"' + a.join(" ").gsub(/[\[\]$"\\]/, '\\\\\&') + '"'
+	  INTERP._eval(Kernel.format('global %s; unset %s; array set %s %s', 
+	  			     @id, @id, @id, s))
+	  #INTERP._eval(Kernel.format('unset %s; array set %s %s', 
+	  #			     @id, @id, s))
+	  #INTERP._invoke_without_enc('unset', @id)
+	  #_fromUTF8(INTERP._invoke_without_enc('array','set', @id, _toUTF8(s)))
+	elsif  val.kind_of?(Hash)
+	  #s = '"' + val.to_a.collect{|e| array2tk_list(e)}.join(" ")\
+	  #                      .gsub(/[\[\]$"]/, '\\\\\&') + '"'
+	  s = '"' + val.to_a.collect{|e| array2tk_list(e)}.join(" ")\
+	                        .gsub(/[\[\]$\\"]/, '\\\\\&') + '"'
+	  INTERP._eval(Kernel.format('global %s; unset %s; array set %s %s', 
+	  			     @id, @id, @id, s))
+	  #INTERP._eval(Kernel.format('unset %s; array set %s %s', 
+	  #			     @id, @id, s))
+	  #INTERP._invoke_without_enc('unset', @id)
+	  #_fromUTF8(INTERP._invoke_without_enc('array','set', @id, _toUTF8(s)))
+	else
+	  fail
+	end
+      end
+    end
+  end
+
+  def [](index)
+    INTERP._eval(Kernel.format('global %s; set %s(%s)', 
+                               @id, @id, _get_eval_string(index)))
+    #INTERP._eval(Kernel.format('set %s(%s)', @id, _get_eval_string(index)))
+    #INTERP._eval('set ' + @id + '(' + _get_eval_string(index) + ')')
+  end
+
+  def []=(index,val)
+    INTERP._eval(Kernel.format('global %s; set %s(%s) %s', @id, @id, 
+                              _get_eval_string(index), _get_eval_string(val)))
+    #INTERP._eval(Kernel.format('set %s(%s) %s', @id, 
+    #			       _get_eval_string(index), _get_eval_string(val)))
+    #INTERP._eval('set ' + @id + '(' + _get_eval_string(index) + ') ' + 
+    #		 _get_eval_string(val))
+  end
+
+  def unset(elem=nil)
+    if elem
+      INTERP._eval(Kernel.format('global %s; unset %s(%s)', 
+                                 @id, @id, tk_tcl2ruby(elem)))
+      #INTERP._eval(Kernel.format('unset %s(%s)', @id, tk_tcl2ruby(elem)))
+      #INTERP._eval('unset ' + @id + '(' + _get_eval_string(elem) + ')')
+    else
+      INTERP._eval(Kernel.format('global %s; unset %s', @id, @id))
+      #INTERP._eval(Kernel.format('unset %s', @id))
+      #INTERP._eval('unset ' + @id)
+    end
+  end
+  alias remove unset
+
+end
+
+  def numeric
+    number(value)
+  end
+  def numeric=(val)
+    case val
+    when Numeric
+      self.value=(val)
+    when TkVariable
+      self.value=(val.numeric)
+    else
+      raise ArgumentError, "Numeric is expected"
+    end
+    val
+  end
+
+  def to_i
+    number(value).to_i
+  end
+
+  def to_f
+    number(value).to_f
+  end
+
+  def to_s
+    #string(value).to_s
+    value
+  end
+
+  def to_sym
+    value.intern
+  end
+
+  def list
+    #tk_split_list(value)
+    tk_split_simplelist(value)
+  end
+  alias to_a list
+
+  def list=(val)
+    case val
+    when Array
+      self.value=(val)
+    when TkVariable
+      self.value=(val.list)
+    else
+      raise ArgumentError, "Array is expected"
+    end
+    val
+  end
+
+  def inspect
+    #Kernel.format "#<TkVariable: %s>", @id
+    '#<TkVariable: ' + @id + '>'
+  end
+
+  def coerce(other)
+    case other
+    when TkVariable
+      [other.value, self.value]
+    when String
+      [other, self.to_s]
+    when Symbol
+      [other, self.to_sym]
+    when Integer
+      [other, self.to_i]
+    when Float
+      [other, self.to_f]
+    when Array
+      [other, self.to_a]
+    else
+      [other, self.value]
+    end
+  end
+
+  def &(other)
+    if other.kind_of?(Array)
+      self.to_a & other.to_a
+    else
+      self.to_i & other.to_i
+    end
+  end
+  def |(other)
+    if other.kind_of?(Array)
+      self.to_a | other.to_a
+    else
+      self.to_i | other.to_i
+    end
+  end
+  def +(other)
+    case other
+    when Array
+      self.to_a + other
+    when String
+      self.value + other
+    else
+      begin
+	number(self.value) + other
+      rescue
+	self.value + other.to_s
+      end
+    end
+  end
+  def -(other)
+    if other.kind_of?(Array)
+      self.to_a - other
+    else
+      number(self.value) - other
+    end
+  end
+  def *(other)
+    begin
+      number(self.value) * other
+    rescue
+      self.value * other
+    end
+  end
+  def /(other)
+    number(self.value) / other
+  end
+  def %(other)
+    begin
+      number(self.value) % other
+    rescue
+      self.value % other
+    end
+  end
+  def **(other)
+    number(self.value) ** other
+  end
+  def =~(other)
+    self.value =~ other
+  end
+
+  def ==(other)
+    case other
+    when TkVariable
+      self.equal?(other)
+    when String
+      self.to_s == other
+    when Symbol
+      self.to_sym == other
+    when Integer
+      self.to_i == other
+    when Float
+      self.to_f == other
+    when Array
+      self.to_a == other
+    when Hash
+      self.value == other
+    else
+      false
+    end
+  end
+
+  def zero?
+    numeric.zero?
+  end
+  def nonzero?
+    !(numeric.zero?)
+  end
+
+  def <=>(other)
+    if other.kind_of?(TkVariable)
+      begin
+	val = other.numeric
+	other = val
+      rescue
+	other = other.value
+      end
+    end
+    if other.kind_of?(Numeric)
+      begin
+	return self.numeric <=> other
+      rescue
+	return self.value <=> other.to_s
+      end
+    else
+      return self.value <=> other
+    end
+  end
+
+  def to_eval
+    @id
+  end
+
+  def trace_callback(elem, op)
+    if @trace_var.kind_of? Array
+      @trace_var.each{|m,e| e.call(self,elem,op) if m.index(op)}
+    end
+    if elem.kind_of?(String) && elem != ''
+      if @trace_elem.kind_of?(Hash) && @trace_elem[elem].kind_of?(Array)
+	@trace_elem[elem].each{|m,e| e.call(self,elem,op) if m.index(op)}
+      end
+    end
+  end
+
+  def trace(opts, cmd = Proc.new)
+    @trace_var = [] if @trace_var == nil
+    opts = ['r','w','u'].find_all{|c| opts.index(c)}.join('')
+    @trace_var.unshift([opts,cmd])
+    if @trace_opts == nil
+      TkVar_CB_TBL[@id] = self
+      @trace_opts = opts.dup
+      Tk.tk_call_without_enc('trace', 'variable', @id, @trace_opts, 'rb_var')
+=begin
+      if /^(8\.([4-9]|[1-9][0-9])|9\.|[1-9][0-9])/ =~ Tk::TCL_VERSION
+	# TCL_VERSION >= 8.4
+	Tk.tk_call_without_enc('trace', 'add', 'variable', 
+			       @id, @trace_opts, 'rb_var')
+      else
+	# TCL_VERSION <= 8.3
+	Tk.tk_call_without_enc('trace', 'variable', @id, @trace_opts, 'rb_var')
+      end
+=end
+    else
+      newopts = @trace_opts.dup
+      opts.each_byte{|c| newopts += c.chr unless newopts.index(c)}
+      if newopts != @trace_opts
+	Tk.tk_call_without_enc('trace', 'vdelete', @id, @trace_opts, 'rb_var')
+	@trace_opts.replace(newopts)
+	Tk.tk_call_without_enc('trace', 'variable', @id, @trace_opts, 'rb_var')
+=begin
+	if /^(8\.([4-9]|[1-9][0-9])|9\.|[1-9][0-9])/ =~ Tk::TCL_VERSION
+	  # TCL_VERSION >= 8.4
+	  Tk.tk_call_without_enc('trace', 'remove', 'variable', 
+				 @id, @trace_opts, 'rb_var')
+	  @trace_opts.replace(newopts)
+	  Tk.tk_call_without_enc('trace', 'add', 'variable', 
+				 @id, @trace_opts, 'rb_var')
+	else
+	  # TCL_VERSION <= 8.3
+	  Tk.tk_call_without_enc('trace', 'vdelete', 
+				 @id, @trace_opts, 'rb_var')
+	  @trace_opts.replace(newopts)
+	  Tk.tk_call_without_enc('trace', 'variable', 
+				 @id, @trace_opts, 'rb_var')
+	end
+=end
+      end
+    end
+    self
+  end
+
+  def trace_element(elem, opts, cmd = Proc.new)
+    @trace_elem = {} if @trace_elem == nil
+    @trace_elem[elem] = [] if @trace_elem[elem] == nil
+    opts = ['r','w','u'].find_all{|c| opts.index(c)}.join('')
+    @trace_elem[elem].unshift([opts,cmd])
+    if @trace_opts == nil
+      TkVar_CB_TBL[@id] = self
+      @trace_opts = opts.dup
+      Tk.tk_call_without_enc('trace', 'variable', @id, @trace_opts, 'rb_var')
+=begin
+      if /^(8\.([4-9]|[1-9][0-9])|9\.|[1-9][0-9])/ =~ Tk::TCL_VERSION
+	# TCL_VERSION >= 8.4
+	Tk.tk_call_without_enc('trace', 'add', 'variable', 
+			       @id, @trace_opts, 'rb_var')
+      else
+	# TCL_VERSION <= 8.3
+	Tk.tk_call_without_enc('trace', 'variable', 
+			       @id, @trace_opts, 'rb_var')
+      end
+=end
+    else
+      newopts = @trace_opts.dup
+      opts.each_byte{|c| newopts += c.chr unless newopts.index(c)}
+      if newopts != @trace_opts
+	Tk.tk_call_without_enc('trace', 'vdelete', @id, @trace_opts, 'rb_var')
+	@trace_opts.replace(newopts)
+	Tk.tk_call_without_enc('trace', 'variable', @id, @trace_opts, 'rb_var')
+=begin
+	if /^(8\.([4-9]|[1-9][0-9])|9\.|[1-9][0-9])/ =~ Tk::TCL_VERSION
+	  # TCL_VERSION >= 8.4
+	  Tk.tk_call_without_enc('trace', 'remove', 'variable', 
+				 @id, @trace_opts, 'rb_var')
+	  @trace_opts.replace(newopts)
+	  Tk.tk_call_without_enc('trace', 'add', 'variable', 
+				 @id, @trace_opts, 'rb_var')
+	else
+	  # TCL_VERSION <= 8.3
+	  Tk.tk_call_without_enc('trace', 'vdelete', 
+				 @id, @trace_opts, 'rb_var')
+	  @trace_opts.replace(newopts)
+	  Tk.tk_call_without_enc('trace', 'variable', 
+				 @id, @trace_opts, 'rb_var')
+	end
+=end
+      end
+    end
+    self
+  end
+
+  def trace_vinfo
+    return [] unless @trace_var
+    @trace_var.dup
+  end
+  def trace_vinfo_for_element(elem)
+    return [] unless @trace_elem
+    return [] unless @trace_elem[elem]
+    @trace_elem[elem].dup
+  end
+
+  def trace_vdelete(opts,cmd)
+    return self unless @trace_var.kind_of? Array
+    opts = ['r','w','u'].find_all{|c| opts.index(c)}.join('')
+    idx = -1
+    newopts = ''
+    @trace_var.each_with_index{|e,i| 
+      if idx < 0 && e[0] == opts && e[1] == cmd
+	idx = i
+	next
+      end
+      e[0].each_byte{|c| newopts += c.chr unless newopts.index(c)}
+    }
+    if idx >= 0
+      @trace_var.delete_at(idx) 
+    else
+      return self
+    end
+
+    @trace_elem.each{|elem|
+      @trace_elem[elem].each{|e|
+	e[0].each_byte{|c| newopts += c.chr unless newopts.index(c)}
+      }
+    }
+
+    newopts = ['r','w','u'].find_all{|c| newopts.index(c)}.join('')
+    if newopts != @trace_opts
+      Tk.tk_call_without_enc('trace', 'vdelete', @id, @trace_opts, 'rb_var')
+=begin
+      if /^(8\.([4-9]|[1-9][0-9])|9\.|[1-9][0-9])/ =~ Tk::TCL_VERSION
+	# TCL_VERSION >= 8.4
+	Tk.tk_call_without_enc('trace', 'remove', 'variable', 
+			       @id, @trace_opts, 'rb_var')
+      else
+	# TCL_VERSION <= 8.3
+	Tk.tk_call_without_enc('trace', 'vdelete', 
+			       @id, @trace_opts, 'rb_var')
+      end
+=end
+      @trace_opts.replace(newopts)
+      if @trace_opts != ''
+	Tk.tk_call_without_enc('trace', 'variable', @id, @trace_opts, 'rb_var')
+=begin
+	if /^(8\.([4-9]|[1-9][0-9])|9\.|[1-9][0-9])/ =~ Tk::TCL_VERSION
+	  # TCL_VERSION >= 8.4
+	  Tk.tk_call_without_enc('trace', 'add', 'variable', 
+				 @id, @trace_opts, 'rb_var')
+	else
+	  # TCL_VERSION <= 8.3
+	  Tk.tk_call_without_enc('trace', 'variable', 
+				 @id, @trace_opts, 'rb_var')
+	end
+=end
+      end
+    end
+
+    self
+  end
+
+  def trace_vdelete_for_element(elem,opts,cmd)
+    return self unless @trace_elem.kind_of? Hash
+    return self unless @trace_elem[elem].kind_of? Array
+    opts = ['r','w','u'].find_all{|c| opts.index(c)}.join('')
+    idx = -1
+    @trace_elem[elem].each_with_index{|e,i| 
+      if idx < 0 && e[0] == opts && e[1] == cmd
+	idx = i
+	next
+      end
+    }
+    if idx >= 0
+      @trace_elem[elem].delete_at(idx)
+    else
+      return self
+    end
+
+    newopts = ''
+    @trace_var.each{|e| 
+      e[0].each_byte{|c| newopts += c.chr unless newopts.index(c)}
+    }
+    @trace_elem.each{|elem|
+      @trace_elem[elem].each{|e|
+	e[0].each_byte{|c| newopts += c.chr unless newopts.index(c)}
+      }
+    }
+
+    newopts = ['r','w','u'].find_all{|c| newopts.index(c)}.join('')
+    if newopts != @trace_opts
+      Tk.tk_call_without_enc('trace', 'vdelete', @id, @trace_opts, 'rb_var')
+=begin
+      if /^(8\.([4-9]|[1-9][0-9])|9\.|[1-9][0-9])/ =~ Tk::TCL_VERSION
+	# TCL_VERSION >= 8.4
+	Tk.tk_call_without_enc('trace', 'remove', 'variable', 
+			       @id, @trace_opts, 'rb_var')
+      else
+	# TCL_VERSION <= 8.3
+	Tk.tk_call_without_enc('trace', 'vdelete', 
+			       @id, @trace_opts, 'rb_var')
+      end
+=end
+      @trace_opts.replace(newopts)
+      if @trace_opts != ''
+	Tk.tk_call_without_enc('trace', 'variable', @id, @trace_opts, 'rb_var')
+=begin
+	if /^(8\.([4-9]|[1-9][0-9])|9\.|[1-9][0-9])/ =~ Tk::TCL_VERSION
+	  # TCL_VERSION >= 8.4
+	  Tk.tk_call_without_enc('trace', 'add', 'variable', 
+				 @id, @trace_opts, 'rb_var')
+	else
+	  # TCL_VERSION <= 8.3
+	  Tk.tk_call_without_enc('trace', 'variable', @id, 
+				 @trace_opts, 'rb_var')
+	end
+=end
+      end
+    end
+
+    self
+  end
+end
+
+
+class TkVarAccess<TkVariable
+  def self.new(name, *args)
+    return TkVar_ID_TBL[name] if TkVar_ID_TBL[name]
+    super(name, *args)
+  end
+
+  def initialize(varname, val=nil)
+    @id = varname
+    TkVar_ID_TBL[@id] = self
+
+    # teach Tk-ip that @id is global var
+    INTERP._invoke_without_enc('global', @id)
+
+    if val
+      #s = '"' + _get_eval_string(val).gsub(/[\[\]$"]/, '\\\\\&') + '"' #"
+      #s = '"' + _get_eval_string(val).gsub(/[\[\]$"\\]/, '\\\\\&') + '"' #"
+      #INTERP._eval(Kernel.format('global %s; set %s %s', @id, @id, s))
+      #INTERP._set_global_var(@id, _toUTF8(_get_eval_string(val)))
+      self.value = val
+    end
+  end
+end
+
+
+module Tk
+  begin
+    auto_path = INTERP._invoke('set', 'auto_path')
+  rescue
+    begin
+      auto_path = INTERP._invoke('set', 'env(TCLLIBPATH)')
+    rescue
+      auto_path = Tk::LIBRARY
+    end
+  end
+
+  AUTO_PATH = TkVarAccess.new('auto_path', auto_path)
+
+=begin
+  AUTO_OLDPATH = tk_split_simplelist(INTERP._invoke('set', 'auto_oldpath'))
+  AUTO_OLDPATH.each{|s| s.freeze}
+  AUTO_OLDPATH.freeze
+=end
+
+  TCL_PACKAGE_PATH = TkVarAccess.new('tcl_pkgPath')
+  PACKAGE_PATH = TCL_PACKAGE_PATH
+
+  TCL_LIBRARY_PATH = TkVarAccess.new('tcl_libPath')
+  LIBRARY_PATH = TCL_LIBRARY_PATH
+
+  TCL_PRECISION = TkVarAccess.new('tcl_precision')
+end

ext/tk/lib/tk/virtevent.rb

@@ -0,0 +1,89 @@
+#
+#   tk/virtevent.rb : treats virtual events
+#                     1998/07/16 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+require 'tk'
+
+class TkVirtualEvent<TkObject
+  extend Tk
+
+  TkCommandNames = ['event'.freeze].freeze
+
+  TkVirtualEventID = ["<VirtEvent".freeze, "00000".taint, ">".freeze].freeze
+  TkVirtualEventTBL = TkCore::INTERP.create_table
+
+  TkCore::INTERP.init_ip_env{ TkVirtualEventTBL.clear }
+
+  class PreDefVirtEvent<self
+    def initialize(event)
+      @path = @id = event
+      TkVirtualEvent::TkVirtualEventTBL[@id] = self
+    end
+  end
+
+  def TkVirtualEvent.getobj(event)
+    obj = TkVirtualEventTBL[event]
+    if obj
+      obj
+    else
+      if tk_call_without_enc('event', 'info').index("<#{event}>")
+	PreDefVirtEvent.new(event)
+      else
+	fail ArgumentError, "undefined virtual event '<#{event}>'"
+      end
+    end
+  end
+
+  def TkVirtualEvent.info
+    tk_call_without_enc('event', 'info').split(/\s+/).collect!{|seq|
+      TkVirtualEvent.getobj(seq[1..-2])
+    }
+  end
+
+  def initialize(*sequences)
+    @path = @id = TkVirtualEventID.join('')
+    TkVirtualEventID[1].succ!
+    add(*sequences)
+  end
+
+  def add(*sequences)
+    if sequences != []
+      tk_call_without_enc('event', 'add', "<#{@id}>", 
+			  *(sequences.collect{|seq| 
+			      "<#{tk_event_sequence(seq)}>"
+			    }) )
+      TkVirtualEventTBL[@id] = self
+    end
+    self
+  end
+
+  def delete(*sequences)
+    if sequences == []
+      tk_call_without_enc('event', 'delete', "<#{@id}>")
+      TkVirtualEventTBL.delete(@id)
+    else
+      tk_call_without_enc('event', 'delete', "<#{@id}>", 
+			  *(sequences.collect{|seq| 
+			      "<#{tk_event_sequence(seq)}>"
+			    }) )
+      TkVirtualEventTBL.delete(@id) if info == []
+    end
+    self
+  end
+
+  def info
+    tk_call_without_enc('event','info',"<#{@id}>").split(/\s+/).collect!{|seq|
+      l = seq.scan(/<*[^<>]+>*/).collect!{|subseq|
+	case (subseq)
+	when /^<<[^<>]+>>$/
+	  TkVirtualEvent.getobj(subseq[1..-2])
+	when /^<[^<>]+>$/
+	  subseq[1..-2]
+	else
+	  subseq.split('')
+	end
+      }.flatten
+      (l.size == 1) ? l[0] : l
+    }
+  end
+end

ext/tk/lib/tk/winfo.rb

@@ -0,0 +1,384 @@
+#
+# tk/winfo.rb : methods for winfo command
+#
+require 'tk'
+
+module TkWinfo
+  include Tk
+  extend Tk
+
+  TkCommandNames = ['winfo'.freeze].freeze
+
+  def TkWinfo.atom(name, win=nil)
+    if win
+      number(tk_call_without_enc('winfo', 'atom', '-displayof', win, 
+				 _get_eval_enc_str(name)))
+    else
+      number(tk_call_without_enc('winfo', 'atom', _get_eval_enc_str(name)))
+    end
+  end
+  def winfo_atom(name)
+    TkWinfo.atom(name, self)
+  end
+
+  def TkWinfo.atomname(id, win=nil)
+    if win
+      _fromUTF8(tk_call_without_enc('winfo', 'atomname', 
+				    '-displayof', win, id))
+    else
+      _fromUTF8(tk_call_without_enc('winfo', 'atomname', id))
+    end
+  end
+  def winfo_atomname(id)
+    TkWinfo.atomname(id, self)
+  end
+
+  def TkWinfo.cells(window)
+    number(tk_call_without_enc('winfo', 'cells', window))
+  end
+  def winfo_cells
+    TkWinfo.cells self
+  end
+
+  def TkWinfo.children(window)
+    list(tk_call_without_enc('winfo', 'children', window))
+  end
+  def winfo_children
+    TkWinfo.children self
+  end
+
+  def TkWinfo.classname(window)
+    tk_call_without_enc('winfo', 'class', window)
+  end
+  def winfo_classname
+    TkWinfo.classname self
+  end
+  alias winfo_class winfo_classname
+
+  def TkWinfo.colormapfull(window)
+     bool(tk_call_without_enc('winfo', 'colormapfull', window))
+  end
+  def winfo_colormapfull
+    TkWinfo.colormapfull self
+  end
+
+  def TkWinfo.containing(rootX, rootY, win=nil)
+    if win
+      window(tk_call_without_enc('winfo', 'containing', 
+				 '-displayof', win, rootX, rootY))
+    else
+      window(tk_call_without_enc('winfo', 'containing', rootX, rootY))
+    end
+  end
+  def winfo_containing(x, y)
+    TkWinfo.containing(x, y, self)
+  end
+
+  def TkWinfo.depth(window)
+    number(tk_call_without_enc('winfo', 'depth', window))
+  end
+  def winfo_depth
+    TkWinfo.depth self
+  end
+
+  def TkWinfo.exist?(window)
+    bool(tk_call_without_enc('winfo', 'exists', window))
+  end
+  def winfo_exist?
+    TkWinfo.exist? self
+  end
+
+  def TkWinfo.fpixels(window, dist)
+    number(tk_call_without_enc('winfo', 'fpixels', window, dist))
+  end
+  def winfo_fpixels(dist)
+    TkWinfo.fpixels self, dist
+  end
+
+  def TkWinfo.geometry(window)
+    tk_call_without_enc('winfo', 'geometry', window)
+  end
+  def winfo_geometry
+    TkWinfo.geometry self
+  end
+
+  def TkWinfo.height(window)
+    number(tk_call_without_enc('winfo', 'height', window))
+  end
+  def winfo_height
+    TkWinfo.height self
+  end
+
+  def TkWinfo.id(window)
+    tk_call_without_enc('winfo', 'id', window)
+  end
+  def winfo_id
+    TkWinfo.id self
+  end
+
+  def TkWinfo.interps(window=nil)
+    if window
+      tk_split_simplelist(tk_call_without_enc('winfo', 'interps',
+					      '-displayof', window))
+    else
+      tk_split_simplelist(tk_call_without_enc('winfo', 'interps'))
+    end
+  end
+  def winfo_interps
+    TkWinfo.interps self
+  end
+
+  def TkWinfo.mapped?(window)
+    bool(tk_call_without_enc('winfo', 'ismapped', window))
+  end
+  def winfo_mapped?
+    TkWinfo.mapped? self
+  end
+
+  def TkWinfo.manager(window)
+    tk_call_without_enc('winfo', 'manager', window)
+  end
+  def winfo_manager
+    TkWinfo.manager self
+  end
+
+  def TkWinfo.appname(window)
+    tk_call('winfo', 'name', window)
+  end
+  def winfo_appname
+    TkWinfo.appname self
+  end
+
+  def TkWinfo.parent(window)
+    window(tk_call_without_enc('winfo', 'parent', window))
+  end
+  def winfo_parent
+    TkWinfo.parent self
+  end
+
+  def TkWinfo.widget(id, win=nil)
+    if win
+      window(tk_call_without_enc('winfo', 'pathname', '-displayof', win, id))
+    else
+      window(tk_call_without_enc('winfo', 'pathname', id))
+    end
+  end
+  def winfo_widget(id)
+    TkWinfo.widget id, self
+  end
+
+  def TkWinfo.pixels(window, dist)
+    number(tk_call_without_enc('winfo', 'pixels', window, dist))
+  end
+  def winfo_pixels(dist)
+    TkWinfo.pixels self, dist
+  end
+
+  def TkWinfo.reqheight(window)
+    number(tk_call_without_enc('winfo', 'reqheight', window))
+  end
+  def winfo_reqheight
+    TkWinfo.reqheight self
+  end
+
+  def TkWinfo.reqwidth(window)
+    number(tk_call_without_enc('winfo', 'reqwidth', window))
+  end
+  def winfo_reqwidth
+    TkWinfo.reqwidth self
+  end
+
+  def TkWinfo.rgb(window, color)
+    list(tk_call_without_enc('winfo', 'rgb', window, color))
+  end
+  def winfo_rgb(color)
+    TkWinfo.rgb self, color
+  end
+
+  def TkWinfo.rootx(window)
+    number(tk_call_without_enc('winfo', 'rootx', window))
+  end
+  def winfo_rootx
+    TkWinfo.rootx self
+  end
+
+  def TkWinfo.rooty(window)
+    number(tk_call_without_enc('winfo', 'rooty', window))
+  end
+  def winfo_rooty
+    TkWinfo.rooty self
+  end
+
+  def TkWinfo.screen(window)
+    tk_call('winfo', 'screen', window)
+  end
+  def winfo_screen
+    TkWinfo.screen self
+  end
+
+  def TkWinfo.screencells(window)
+    number(tk_call_without_enc('winfo', 'screencells', window))
+  end
+  def winfo_screencells
+    TkWinfo.screencells self
+  end
+
+  def TkWinfo.screendepth(window)
+    number(tk_call_without_enc('winfo', 'screendepth', window))
+  end
+  def winfo_screendepth
+    TkWinfo.screendepth self
+  end
+
+  def TkWinfo.screenheight (window)
+    number(tk_call_without_enc('winfo', 'screenheight', window))
+  end
+  def winfo_screenheight
+    TkWinfo.screenheight self
+  end
+
+  def TkWinfo.screenmmheight(window)
+    number(tk_call_without_enc('winfo', 'screenmmheight', window))
+  end
+  def winfo_screenmmheight
+    TkWinfo.screenmmheight self
+  end
+
+  def TkWinfo.screenmmwidth(window)
+    number(tk_call_without_enc('winfo', 'screenmmwidth', window))
+  end
+  def winfo_screenmmwidth
+    TkWinfo.screenmmwidth self
+  end
+
+  def TkWinfo.screenvisual(window)
+    tk_call_without_enc('winfo', 'screenvisual', window)
+  end
+  def winfo_screenvisual
+    TkWinfo.screenvisual self
+  end
+
+  def TkWinfo.screenwidth(window)
+    number(tk_call_without_enc('winfo', 'screenwidth', window))
+  end
+  def winfo_screenwidth
+    TkWinfo.screenwidth self
+  end
+
+  def TkWinfo.server(window)
+    tk_call('winfo', 'server', window)
+  end
+  def winfo_server
+    TkWinfo.server self
+  end
+
+  def TkWinfo.toplevel(window)
+    window(tk_call_without_enc('winfo', 'toplevel', window))
+  end
+  def winfo_toplevel
+    TkWinfo.toplevel self
+  end
+
+  def TkWinfo.visual(window)
+    tk_call_without_enc('winfo', 'visual', window)
+  end
+  def winfo_visual
+    TkWinfo.visual self
+  end
+
+  def TkWinfo.visualid(window)
+    tk_call_without_enc('winfo', 'visualid', window)
+  end
+  def winfo_visualid
+    TkWinfo.visualid self
+  end
+
+  def TkWinfo.visualsavailable(window, includeids=false)
+    if includeids
+      list(tk_call_without_enc('winfo', 'visualsavailable', 
+			       window, "includeids"))
+    else
+      list(tk_call_without_enc('winfo', 'visualsavailable', window))
+    end
+  end
+  def winfo_visualsavailable(includeids=false)
+    TkWinfo.visualsavailable self, includeids
+  end
+
+  def TkWinfo.vrootheight(window)
+    number(tk_call_without_enc('winfo', 'vrootheight', window))
+  end
+  def winfo_vrootheight
+    TkWinfo.vrootheight self
+  end
+
+  def TkWinfo.vrootwidth(window)
+    number(tk_call_without_enc('winfo', 'vrootwidth', window))
+  end
+  def winfo_vrootwidth
+    TkWinfo.vrootwidth self
+  end
+
+  def TkWinfo.vrootx(window)
+    number(tk_call_without_enc('winfo', 'vrootx', window))
+  end
+  def winfo_vrootx
+    TkWinfo.vrootx self
+  end
+
+  def TkWinfo.vrooty(window)
+    number(tk_call_without_enc('winfo', 'vrooty', window))
+  end
+  def winfo_vrooty
+    TkWinfo.vrooty self
+  end
+
+  def TkWinfo.width(window)
+    number(tk_call_without_enc('winfo', 'width', window))
+  end
+  def winfo_width
+    TkWinfo.width self
+  end
+
+  def TkWinfo.x(window)
+    number(tk_call_without_enc('winfo', 'x', window))
+  end
+  def winfo_x
+    TkWinfo.x self
+  end
+
+  def TkWinfo.y(window)
+    number(tk_call_without_enc('winfo', 'y', window))
+  end
+  def winfo_y
+    TkWinfo.y self
+  end
+
+  def TkWinfo.viewable(window)
+    bool(tk_call_without_enc('winfo', 'viewable', window))
+  end
+  def winfo_viewable
+    TkWinfo.viewable self
+  end
+
+  def TkWinfo.pointerx(window)
+    number(tk_call_without_enc('winfo', 'pointerx', window))
+  end
+  def winfo_pointerx
+    TkWinfo.pointerx self
+  end
+
+  def TkWinfo.pointery(window)
+    number(tk_call_without_enc('winfo', 'pointery', window))
+  end
+  def winfo_pointery
+    TkWinfo.pointery self
+  end
+
+  def TkWinfo.pointerxy(window)
+    list(tk_call_without_enc('winfo', 'pointerxy', window))
+  end
+  def winfo_pointerxy
+    TkWinfo.pointerxy self
+  end
+end

ext/tk/lib/tk/winpkg.rb

@@ -0,0 +1,136 @@
+#
+#   tk/winpkg.rb : methods for Tcl/Tk packages for Microsoft Windows
+#                     2000/11/22 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+#     ATTENTION !!
+#         This is NOT TESTED. Because I have no test-environment.
+#
+require 'tk'
+
+module TkWinDDE
+  extend Tk
+  extend TkWinDDE
+
+  TkCommandNames = ['dde'.freeze].freeze
+
+  if self.const_defined? :FORCE_VERSION
+    tk_call_without_enc('package', 'require', 'dde', FORCE_VERSION)
+  else
+    tk_call_without_enc('package', 'require', 'dde')
+  end
+
+  def servername(topic=None)
+    tk_call('dde', 'servername', topic)
+  end
+  def servername(*args)
+    if args.size == 0
+      tk_call('dde', 'servername')
+    else
+      if args[-1].kind_of?(Hash)
+	keys = _symbolkey2str(args.pop)
+	force = (keys.delete('force'))? '-force': None
+	exact = (keys.delete('exact'))? '-exact': None
+	if keys.size == 0
+	  tk_call('dde', 'servername', force, exact)
+	elsif args.size == 0
+	  tk_call('dde', 'servername', force, exact, *hash_kv(keys))
+	else
+	  tk_call('dde', 'servername', force, exact, 
+		  *((hash_kv(keys) << '--') + args))
+	end
+      end
+    end
+  end
+
+  def execute(service, topic, data)
+    tk_call('dde', 'execute', service, topic, data)
+  end
+
+  def async_execute(service, topic, data)
+    tk_call('dde', '-async', 'execute', service, topic, data)
+  end
+
+  def poke(service, topic, item, data)
+    tk_call('dde', 'poke', service, topic, item, data)
+  end
+
+  def request(service, topic, item)
+    tk_call('dde', 'request', service, topic, item)
+  end
+
+  def binary_request(service, topic, item)
+    tk_call('dde', 'request', '-binary', service, topic, item)
+  end
+
+  def services(service, topic)
+    tk_call('dde', 'services', service, topic)
+  end
+
+  def eval(topic, cmd, *args)
+    tk_call('dde', 'eval', topic, cmd, *args)
+  end
+
+  def async_eval(topic, cmd, *args)
+    tk_call('dde', 'eval', -async, topic, cmd, *args)
+  end
+
+  module_function :servername, :execute, :async_execute, 
+                  :poke, :request, :services, :eval
+end
+
+module TkWinRegistry
+  extend Tk
+  extend TkWinRegistry
+
+  TkCommandNames = ['registry'.freeze].freeze
+
+  if self.const_defined? :FORCE_VERSION
+    tk_call('package', 'require', 'registry', FORCE_VERSION)
+  else
+    tk_call('package', 'require', 'registry')
+  end
+
+  def broadcast(keynam, timeout=nil)
+    if timeout
+      tk_call('registry', 'broadcast', keynam, '-timeout', timeout)
+    else
+      tk_call('registry', 'broadcast', keynam)
+    end
+  end
+
+  def delete(keynam, valnam=None)
+    tk_call('registry', 'delete', keynam, valnam)
+  end
+
+  def get(keynam, valnam)
+    tk_call('registry', 'get', keynam, valnam)
+  end
+
+  def keys(keynam, pattern=nil)
+    lst = tk_split_simplelist(tk_call('registry', 'keys', keynam))
+    if pattern
+      lst.find_all{|key| key =~ pattern}
+    else
+      lst
+    end
+  end
+
+  def set(keynam, valnam=None, data=None, dattype=None)
+    tk_call('registry', 'set', keynam, valnam, data, dattype)
+  end
+
+  def type(keynam, valnam)
+    tk_call('registry', 'type', keynam, valnam)
+  end
+
+  def values(keynam, pattern=nil)
+    lst = tk_split_simplelist(tk_call('registry', 'values', keynam))
+    if pattern
+      lst.find_all{|val| val =~ pattern}
+    else
+      lst
+    end
+  end
+
+  module_function :delete, :get, :keys, :set, :type, :values
+end

ext/tk/lib/tk/wm.rb

@@ -0,0 +1,247 @@
+#
+# tk/wm.rb : methods for wm command
+#
+require 'tk'
+
+module Tk
+  module Wm
+    include TkComm
+
+    TkCommandNames = ['wm'.freeze].freeze
+
+    def aspect(*args)
+      if args.length == 0
+	list(tk_call_without_enc('wm', 'aspect', path))
+      else
+	tk_call('wm', 'aspect', path, *args)
+	self
+      end
+    end
+    def attributes(slot=nil,value=None)
+      if slot == nil
+	lst = tk_split_list(tk_call('wm', 'attributes', path))
+	info = {}
+	while key = lst.shift
+	  info[key[1..-1]] = lst.shift
+	end
+	info
+      elsif slot.kind_of? Hash
+	tk_call('wm', 'attributes', path, *hash_kv(slot))
+	self
+      elsif value == None
+	tk_call('wm', 'attributes', path, "-#{slot}")
+      else
+	tk_call('wm', 'attributes', path, "-#{slot}", value)
+	self
+      end
+    end
+    def client(name=None)
+      if name == None
+	tk_call('wm', 'client', path)
+      else
+        name = '' if name == nil
+	tk_call('wm', 'client', path, name)
+	self
+      end
+    end
+    def colormapwindows(*args)
+      if args.size == 0
+	list(tk_call_without_enc('wm', 'colormapwindows', path))
+      else
+	tk_call_without_enc('wm', 'colormapwindows', path, *args)
+	self
+      end
+    end
+    def wm_command(value=nil)
+      if value
+	tk_call('wm', 'command', path, value)
+	self
+      else
+	#procedure(tk_call('wm', 'command', path))
+	tk_call('wm', 'command', path)
+      end
+    end
+    def deiconify(ex = true)
+      tk_call_without_enc('wm', 'deiconify', path) if ex
+      self
+    end
+    def focusmodel(mode = nil)
+      if mode
+	tk_call_without_enc('wm', 'focusmodel', path, mode)
+	self
+      else
+	tk_call_without_enc('wm', 'focusmodel', path)
+      end
+    end
+    def frame
+      tk_call_without_enc('wm', 'frame', path)
+    end
+    def geometry(geom=nil)
+      if geom
+	tk_call_without_enc('wm', 'geometry', path, geom)
+	self
+      else
+	tk_call_without_enc('wm', 'geometry', path)
+      end
+    end
+    def wm_grid(*args)
+      if args.size == 0
+	list(tk_call_without_enc('wm', 'grid', path))
+      else
+	tk_call_without_enc('wm', 'grid', path, *args)
+	self
+      end
+    end
+    def group(leader = nil)
+      if leader
+	tk_call('wm', 'group', path, leader)
+	self
+      else
+	window(tk_call('wm', 'group', path))
+      end
+    end
+    def iconbitmap(bmp=nil)
+      if bmp
+	tk_call_without_enc('wm', 'iconbitmap', path, bmp)
+	self
+      else
+	image_obj(tk_call_without_enc('wm', 'iconbitmap', path))
+      end
+    end
+    def iconify(ex = true)
+      tk_call_without_enc('wm', 'iconify', path) if ex
+      self
+    end
+    def iconmask(bmp=nil)
+      if bmp
+	tk_call_without_enc('wm', 'iconmask', path, bmp)
+	self
+      else
+	image_obj(tk_call_without_enc('wm', 'iconmask', path))
+      end
+    end
+    def iconname(name=nil)
+      if name
+	tk_call('wm', 'iconname', path, name)
+	self
+      else
+	tk_call('wm', 'iconname', path)
+      end
+    end
+    def iconposition(*args)
+      if args.size == 0
+	list(tk_call_without_enc('wm', 'iconposition', path))
+      else
+	tk_call_without_enc('wm', 'iconposition', path, *args)
+	self
+      end
+    end
+    def iconwindow(win = nil)
+      if win
+	tk_call_without_enc('wm', 'iconwindow', path, win)
+	self
+      else
+	w = tk_call_without_enc('wm', 'iconwindow', path)
+	(w == '')? nil: window(w)
+      end
+    end
+    def maxsize(*args)
+      if args.size == 0
+	list(tk_call_without_enc('wm', 'maxsize', path))
+      else
+	tk_call_without_enc('wm', 'maxsize', path, *args)
+	self
+      end
+    end
+    def minsize(*args)
+      if args.size == 0
+	list(tk_call_without_enc('wm', 'minsize', path))
+      else
+	tk_call_without_enc('wm', 'minsize', path, *args)
+	self
+      end
+    end
+    def overrideredirect(bool=None)
+      if bool == None
+	bool(tk_call_without_enc('wm', 'overrideredirect', path))
+      else
+	tk_call_without_enc('wm', 'overrideredirect', path, bool)
+	self
+      end
+    end
+    def positionfrom(who=None)
+      if who == None
+	r = tk_call_without_enc('wm', 'positionfrom', path)
+	(r == "")? nil: r
+      else
+	tk_call_without_enc('wm', 'positionfrom', path, who)
+	self
+      end
+    end
+    def protocol(name=nil, cmd=nil)
+      if cmd
+	tk_call_without_enc('wm', 'protocol', path, name, cmd)
+	self
+      elsif name
+	result = tk_call_without_enc('wm', 'protocol', path, name)
+	(result == "")? nil : tk_tcl2ruby(result)
+      else
+	tk_split_simplelist(tk_call_without_enc('wm', 'protocol', path))
+      end
+    end
+    def resizable(*args)
+      if args.length == 0
+	list(tk_call_without_enc('wm', 'resizable', path)).collect{|e| bool(e)}
+      else
+	tk_call_without_enc('wm', 'resizable', path, *args)
+	self
+      end
+    end
+    def sizefrom(who=None)
+      if who == None
+	r = tk_call_without_enc('wm', 'sizefrom', path)
+	(r == "")? nil: r
+      else
+	tk_call_without_enc('wm', 'sizefrom', path, who)
+	self
+      end
+    end
+    def stackorder
+      list(tk_call('wm', 'stackorder', path))
+    end
+    def stackorder_isabove(win)
+      bool(tk_call('wm', 'stackorder', path, 'isabove', win))
+    end
+    def stackorder_isbelow(win)
+      bool(tk_call('wm', 'stackorder', path, 'isbelow', win))
+    end
+    def state(state=nil)
+      if state
+	tk_call_without_enc('wm', 'state', path, state)
+	self
+      else
+	tk_call_without_enc('wm', 'state', path)
+      end
+    end
+    def title(str=nil)
+      if str
+	tk_call('wm', 'title', path, str)
+	self
+      else
+	tk_call('wm', 'title', path)
+      end
+    end
+    def transient(master=nil)
+      if master
+	tk_call_without_enc('wm', 'transient', path, master)
+	self
+      else
+	window(tk_call_without_enc('wm', 'transient', path))
+      end
+    end
+    def withdraw(ex = true)
+      tk_call_without_enc('wm', 'withdraw', path) if ex
+      self
+    end
+  end
+end

ext/tk/lib/tk/xim.rb

@@ -0,0 +1,122 @@
+#
+# tk/xim.rb : control imput_method
+#
+require 'tk'
+
+module TkXIM
+  include Tk
+  extend Tk
+
+  TkCommandNames = ['imconfigure'.freeze].freeze
+
+  def TkXIM.useinputmethods(value = None, window = nil)
+    if value == None
+      if window
+        bool(tk_call_without_enc('tk', 'useinputmethods', 
+				 '-displayof', window))
+      else
+        bool(tk_call_without_enc('tk', 'useinputmethods'))
+      end
+    else
+      if window
+	bool(tk_call_without_enc('tk', 'useinputmethods', 
+				 '-displayof', window, value))
+      else
+        bool(tk_call_without_enc('tk', 'useinputmethods', value))
+      end
+    end
+  end
+
+  def TkXIM.useinputmethods_displayof(window, value = None)
+    TkXIM.useinputmethods(value, window)
+  end
+
+  def TkXIM.caret(window, keys=nil)
+    if keys
+      tk_call_without_enc('tk', 'caret', window, *hash_kv(keys))
+      self
+    else
+      lst = tk_split_list(tk_call_without_enc('tk', 'caret', window))
+      info = {}
+      while key = lst.shift
+	info[key[1..-1]] = lst.shift
+      end
+      info
+    end
+  end
+
+  def TkXIM.configure(window, slot, value=None)
+    begin
+      if /^8\.*/ === Tk::TK_VERSION  && JAPANIZED_TK
+        if slot.kind_of? Hash
+          tk_call('imconfigure', window, *hash_kv(slot))
+        else
+          tk_call('imconfigure', window, "-#{slot}", value)
+        end
+      end
+    rescue
+    end
+  end
+
+  def TkXIM.configinfo(window, slot=nil)
+    if TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
+      begin
+	if /^8\.*/ === Tk::TK_VERSION  && JAPANIZED_TK
+	  if slot
+	    conf = tk_split_list(tk_call('imconfigure', window, "-#{slot}"))
+	    conf[0] = conf[0][1..-1]
+	    conf
+	  else
+	    tk_split_list(tk_call('imconfigure', window)).collect{|conf|
+	      conf[0] = conf[0][1..-1]
+	      conf
+	    }
+	  end
+	else
+	  []
+	end
+      rescue
+	[]
+      end
+    else # ! TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
+      TkXIM.current_configinfo(window, slot)
+    end
+  end
+
+  def TkXIM.current_configinfo(window, slot=nil)
+    begin
+      if /^8\.*/ === Tk::TK_VERSION  && JAPANIZED_TK
+	if slot
+	  conf = tk_split_list(tk_call('imconfigure', window, "-#{slot}"))
+	  { conf[0][1..-1] => conf[1] }
+	else
+	  ret = {}
+	  tk_split_list(tk_call('imconfigure', window)).each{|conf|
+	    ret[conf[0][1..-1]] = conf[1]
+	  }
+	  ret
+	end
+      else
+	{}
+      end
+    rescue
+      {}
+    end
+  end
+
+  def useinputmethods(value=None)
+    TkXIM.useinputmethods(value, self)
+  end
+
+  def caret(keys=nil)
+    TkXIM.caret(self, keys=nil)
+  end
+
+  def imconfigure(slot, value=None)
+    TkXIM.configure(self, slot, value)
+  end
+
+  def imconfiginfo(slot=nil)
+    TkXIM.configinfo(self, slot)
+  end
+end

ext/tk/sample/binding_sample.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require 'tk'
+
+class Button_clone < TkLabel
+  def initialize(*args)
+    @command = nil
+
+    if args[-1].kind_of?(Hash)
+      keys = _symbolkey2str(args.pop)
+      @command = keys.delete('command')
+
+      keys['highlightthickness'] = 1 unless keys.key?('highlightthickness')
+      keys['padx'] = '3m' unless keys.key?('padx')
+      keys['pady'] = '1m' unless keys.key?('pady')
+      keys['relief'] = 'raised' unless keys.key?('relief')
+
+      args.push(keys)
+    end
+
+    super(*args)
+
+    @press = false
+
+    self.bind('Enter', proc{self.background(self.activebackground)})
+    self.bind('Leave', proc{
+		@press = false
+		self.background(self.highlightbackground)
+		self.relief('raised')
+	      })
+
+    self.bind('ButtonPress-1', proc{@press = true; self.relief('sunken')})
+    self.bind('ButtonRelease-1', proc{
+		self.relief('raised')
+		@command.call if @press && @command
+		@press = false
+	      })
+  end
+
+  def command(cmd = Proc.new)
+    @command = cmd
+  end
+
+  def invoke
+    if @command
+      @command.call 
+    else
+      ''
+    end
+  end
+end
+
+TkLabel.new(:text=><<EOT).pack
+This is a sample of 'event binding'.
+The first button is a normal button widget.
+And the second one is a normal label widget 
+but with some bindings like a button widget.
+EOT
+
+lbl = TkLabel.new(:foreground=>'red').pack(:pady=>3)
+
+v = TkVariable.new(0)
+
+TkFrame.new{|f|
+  TkLabel.new(f, :text=>'click count : ').pack(:side=>:left)
+  TkLabel.new(f, :textvariable=>v).pack(:side=>:left)
+}.pack
+
+TkButton.new(:text=>'normal Button widget', 
+	     :command=>proc{
+	       puts 'button is clicked!!'
+	       lbl.text 'button is clicked!!'
+	       v.numeric += 1
+	     }){
+  pack(:fill=>:x, :expand=>true)
+}
+
+Button_clone.new(:text=>'Label with Button binding', 
+		 :command=>proc{
+		   puts 'label is clicked!!'
+		   lbl.text 'label is clicked!!'
+		   v.numeric += 1
+		 }){
+  pack(:fill=>:x, :expand=>true)
+}
+
+Tk.mainloop

ext/tk/sample/bindtag_sample.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+require 'tk'
+
+TkLabel.new(:text=><<EOT, :justify=>:left).pack
+This is a sample of bindtags and usage of 
+Tk.callback_break/Tk.callback_continue. 
+Please check the work of following buttons 
+(attend the difference between before/after 
+ pressing the bottom button), and see the 
+source code.
+EOT
+
+def set_class_bind
+  TkButton.bind('ButtonPress-1', 
+		proc{puts 'bind "ButtonPress-1" of TkButton class'})
+  TkButton.bind('ButtonRelease-1', 
+		proc{puts 'bind "ButtonRelease-1" of TkButton class'})
+end
+
+# set root binding
+r = TkRoot.new
+r.bind('ButtonPress-1',   proc{puts 'bind "ButtonPress-1" of root widget'})
+r.bind('ButtonRelease-1', proc{puts 'bind "ButtonRelease-1" of root widget'})
+
+# set 'all' binding
+TkBindTag::ALL.bind('ButtonPress-1', 
+		    proc{puts 'bind "ButtonPress-1" of the tag "all"'})
+TkBindTag::ALL.bind('ButtonRelease-1', 
+		    proc{puts 'bind "ButtonRelease-1" of the tag "all"'})
+
+# create buttons
+b1 = TkButton.new(:text=>'button-1', 
+		  :command=>proc{puts "command of button-1"}).pack
+b2 = TkButton.new(:text=>'button-2', 
+		  :command=>proc{puts "command of button-2"}).pack
+b3 = TkButton.new(:text=>'button-3', 
+		  :command=>proc{puts "command of button-3"}).pack
+b4 = TkButton.new(:text=>'button-4', 
+		  :command=>proc{puts "command of button-4"}).pack
+b5 = TkButton.new(:text=>'button-5', 
+		  :command=>proc{puts "command of button-5"}).pack
+
+# set button binding
+b1.bind('ButtonPress-1',   proc{puts 'bind "ButtonPress-1" of button-1'})
+b1.bind('ButtonRelease-1', proc{puts 'bind "ButtonRelease-1" of button-1'})
+
+b2.bind('ButtonPress-1',   proc{puts 'bind "ButtonPress-1" of button-2'})
+b2.bind('ButtonRelease-1', proc{puts 'bind "ButtonRelease-1" of button-2'})
+
+b3.bind('ButtonPress-1',   proc{puts 'bind "ButtonPress-1" of button-3'})
+b3.bind('ButtonRelease-1', proc{puts 'bind "ButtonRelease-1" of button-3'})
+
+b4.bind('ButtonPress-1',   proc{puts 'bind "ButtonPress-1" of button-4'})
+b4.bind('ButtonRelease-1', proc{puts 'bind "ButtonRelease-1" of button-4'})
+
+b5.bind('ButtonPress-1',   proc{puts 'bind "ButtonPress-1" of button-5'})
+b5.bind('ButtonRelease-1', proc{puts 'bind "ButtonRelease-1" of button-5'})
+
+# create bindtag and set binding
+tag1 = TkBindTag.new
+tag1.bind('ButtonPress-1',   proc{puts 'bind "ButtonPress-1" of tag1'})
+tag1.bind('ButtonRelease-1', proc{puts 'bind "ButtonRelease-1" of tag1'})
+
+tag2 = TkBindTag.new
+tag2.bind('ButtonPress-1',   
+	  proc{
+	    puts 'bind "ButtonPress-1" of tag2'
+	    puts 'call Tk.callback_continue'
+	    Tk.callback_continue
+	    puts 'never see this message'
+	  })
+tag2.bind('ButtonRelease-1', 
+	  proc{
+	    puts 'bind "ButtonRelease-1" of tag2'
+	    puts 'call Tk.callback_continue'
+	    Tk.callback_continue
+	    puts 'never see this message'
+	  })
+
+tag3 = TkBindTag.new
+tag3.bind('ButtonPress-1',   
+	  proc{
+	    puts 'bind "ButtonPress-1" of tag3'
+	    puts 'call Tk.callback_break'
+	    Tk.callback_break
+	    puts 'never see this message'
+	  })
+tag3.bind('ButtonRelease-1', 
+	  proc{
+	    puts 'bind "ButtonRelease-1" of tag3'
+	    puts 'call Tk.callback_break'
+	    Tk.callback_break
+	    puts 'never see this message'
+	  })
+
+# set bindtags
+p b1.bindtags
+
+tags = b2.bindtags
+tags[2,0] = tag1
+tags[0,0] = tag1
+b2.bindtags(tags)
+p b2.bindtags
+
+tags = b3.bindtags
+tags[2,0] = tag2
+tags[0,0] = tag2
+b3.bindtags(tags)
+p b3.bindtags
+
+tags = b4.bindtags
+tags[2,0] = tag3
+tags[0,0] = tag3
+b4.bindtags(tags)
+p b4.bindtags
+
+b5.bindtags([tag1, TkButton, tag2, b5])
+
+# create button to set button class binding
+TkButton.new(:text=>'set binding to TkButton class', 
+	     :command=>proc{
+	       puts 'call "set_class_bind"'
+	       set_class_bind
+	     }).pack(:pady=>7)
+
+# start event-loop
+Tk.mainloop

ext/tk/sample/binstr_usage.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require "tk"
+
+TkMessage.new(:width=>360, :text=><<EOM).pack
+This sample shows how to use a binary sequence between Ruby and Tk. \
+This reads the image data from the file as the binary sequence.
+
+To treat the difference of encodings between on Ruby and on Tk seamlessly, \
+Ruby/Tk converts the encoding of string arguments automatically. \
+I think it is comfortable for users on almost all situations. \
+However, when treats a binary sequence, the convert process makes troubles.
+
+Tk::BinaryString class (subclass of Tk::EncodedString class) is the class \
+to avoid such troubles. Please see the source code of this sample. \
+A Tk::BinaryString instance is used to create the image for the center button. 
+EOM
+
+ImgFile=['images','tcllogo.gif'].join(File::Separator)
+
+ph1 = TkPhotoImage.new(:file=>ImgFile)
+p ph1.configinfo
+
+b_str = Tk::BinaryString(IO.read(ImgFile))
+p [b_str, b_str.encoding]
+
+ph2 = TkPhotoImage.new(:data=>b_str)
+p ph2.configinfo
+p ph2.data(:grayscale=>true)
+
+ph3 = TkPhotoImage.new()
+ph3.put(ph2.data(:grayscale=>true))
+
+f = TkFrame.new.pack
+TkButton.new(:parent=>f, :image=>ph1, :command=>proc{exit}).pack(:side=>:left)
+TkButton.new(:parent=>f, :image=>ph2, :command=>proc{exit}).pack(:side=>:left)
+TkButton.new(:parent=>f, :image=>ph3, :command=>proc{exit}).pack(:side=>:left)
+
+Tk.mainloop

ext/tk/sample/btn_with_frame.rb

@@ -0,0 +1,20 @@
+require 'tk'
+
+class Button_with_Frame < TkButton
+  def create_self(keys)
+    @frame = TkFrame.new('widgetname'=>@path, 'background'=>'yellow')
+    install_win(@path) # create new @path which is a daughter of old @path
+    super(keys)
+    TkPack(@path, :padx=>7, :pady=>7)
+    @epath = @frame.path
+  end
+  def epath
+    @epath
+  end
+end
+
+Button_with_Frame.new(:text=>'QUIT', :command=>proc{exit}) {
+  pack(:padx=>15, :pady=>5)
+}
+
+Tk.mainloop

ext/tk/sample/demos-en/README.1st

@@ -0,0 +1,18 @@
+There are Ruby/Tk demo scripts.
+
+Files with '.rb' extension are sub-scripts which are launched 'widget'
+script. Those files don't work independently. Please call them from 
+'widget' script.
+
+If you want start some sub-scripts at same time when the launcher
+script tarts, please give the sub-script names as arguments. 
+(e.g. /usr/local/bin/ruby widget button.rb entry1.rb text.rb )
+You can ommit '.rb' of the sub-scripts
+(e.g. /usr/local/bin/ruby widget button entry1 text )
+
+If you don't need launcher's main window, give -n option. 
+(e.g. /usr/local/bin/ruby widget -n button.rb entry1.rb text.rb )
+
+Others (browse1, hello, and so on) are standalone scripts. 
+
+          2004/04/14  Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)

ext/tk/sample/demos-en/check2.rb

@@ -0,0 +1,107 @@
+#
+# checkbutton widget demo2 (called by 'widget')
+#
+
+# delete old toplevel widget
+if defined?($check2_demo) && $check2_demo
+  $check2_demo.destroy 
+  $check2_demo = nil
+end
+
+# create demo toplevel widget
+$check2_demo = TkToplevel.new {|w|
+  title("Checkbutton Demonstration 2")
+  iconname("check2")
+  positionWindow(w)
+}
+
+# label
+msg = TkLabel.new($check2_demo) {
+  font $font
+  wraplength '4i'
+  justify 'left'
+  text "Four checkbuttons are displayed below.  If you click on a button, it will toggle the button's selection state and set a Tcl variable to a value indicating the state of the checkbutton.  The first button also follows the state of the other three.  If only some of the three are checked, the first button will display the tri-state mode. Click the \"See Variables\" button to see the current values of the variables."
+}
+msg.pack('side'=>'top')
+
+# variable
+safety = TkVariable.new(0)
+wipers = TkVariable.new(0)
+brakes = TkVariable.new(0)
+sober  = TkVariable.new(0)
+
+# frame
+TkFrame.new($check2_demo) {|frame|
+  TkGrid(TkFrame.new(frame, :height=>2, :relief=>:sunken, :bd=>2), 
+	 :columnspan=>4, :row=>0, :sticky=>'ew', :pady=>2)
+  TkGrid('x', 
+	 TkButton.new(frame, :text=>'See Variables', 
+		      :image=>$image['view'], :compound=>:left, 
+		      :command=>proc{
+			showVars($check2_demo, 
+				 ['safety', safety], ['wipers', wipers], 
+				 ['brakes', brakes], ['sober', sober])
+		      }), 
+	 TkButton.new(frame, :text=>'See Code', 
+		      :image=>$image['view'], :compound=>:left, 
+		      :command=>proc{showCode 'check2'}), 
+	 TkButton.new(frame, :text=>'Dismiss', 
+		      :image=>$image['delete'], :compound=>:left, 
+		      :command=>proc{
+			tmppath = $check2_demo
+			$check2_demo = nil
+			$showVarsWin[tmppath.path] = nil
+			tmppath.destroy
+		      }), 
+	 :padx=>4, :pady=>4)
+  frame.grid_columnconfigure(0, :weight=>1)
+}.pack('side'=>'bottom', 'fill'=>'x')
+
+
+# checkbutton
+TkCheckButton.new($check2_demo, :text=>'Safety Check', :variable=>safety, 
+		  :relief=>:flat, :onvalue=>'all', :offvalue=>'none', 
+		  :tristatevalue=>'partial'){
+  pack('side'=>'top', 'pady'=>2, 'anchor'=>'w')
+}
+
+[ TkCheckButton.new($check2_demo, 'text'=>'Wipers OK', 'variable'=>wipers),
+  TkCheckButton.new($check2_demo, 'text'=>'Brakes OK', 'variable'=>brakes),
+  TkCheckButton.new($check2_demo, 'text'=>'Driver Sober', 'variable'=>sober)
+].each{|w| 
+  w.relief('flat')
+  w.pack('side'=>'top', 'padx'=>15, 'pady'=>2, 'anchor'=>'w')
+}
+
+# tristate check
+in_check = false
+tristate_check = proc{|n1,n2,op|
+  return if in_check
+
+  in_check = true
+  begin
+    if n1 == safety
+      if safety == 'none'
+	wipers.value = 0
+	brakes.value = 0
+	sober.value  = 0
+      elsif safety == 'all'
+	wipers.value = 1
+	brakes.value = 1
+	sober.value  = 1
+      end
+    else
+      if wipers == 1 && brakes == 1 && sober == 1
+	safety.value = 'all'
+      elsif wipers == 1 || brakes == 1 || sober == 1
+	safety.value = 'partial'
+      else
+	safety.value = 'none'
+      end
+    end
+  ensure
+    in_check = false
+  end
+}
+
+[wipers, brakes, sober, safety].each{|v| v.trace('w', tristate_check)}

ext/tk/sample/demos-en/radio3.rb

@@ -0,0 +1,114 @@
+# radio3.rb
+#
+# This demonstration script creates a toplevel window containing
+# several radiobutton widgets.
+#
+# radiobutton widget demo (called by 'widget')
+#
+
+# toplevel widget
+if defined?($radio3_demo) && $radio3_demo
+  $radio3_demo.destroy 
+  $radio3_demo = nil
+end
+
+# demo toplevel widget
+$radio3_demo = TkToplevel.new {|w|
+  title("Radiobutton Demonstration 3")
+  iconname("radio3")
+  positionWindow(w)
+}
+
+# label 
+msg = TkLabel.new($radio3_demo) {
+  font $font
+  wraplength '5i'
+  justify 'left'
+  text "Three groups of radiobuttons are displayed below.  If you click on a button then the button will become selected exclusively among all the buttons in its group.  A Tcl variable is associated with each group to indicate which of the group's buttons is selected.  When the 'Tristate' button is pressed, the radio buttons will display the tri-state mode. Selecting any radio button will return the buttons to their respective on/off state. Click the \"See Variables\" button to see the current values of the variables."
+}
+msg.grid(:row=>0, :column=>0, :columnspan=>3, :sticky=>'nsew')
+
+# variable
+size = TkVariable.new
+color = TkVariable.new
+align = TkVariable.new
+
+# frame 
+TkFrame.new($radio3_demo) {|frame|
+  TkGrid(TkFrame.new(frame, :height=>2, :relief=>:sunken, :bd=>2), 
+	 :columnspan=>4, :row=>0, :sticky=>'ew', :pady=>2)
+  TkGrid('x', 
+	 TkButton.new(frame, :text=>'See Variables', 
+		      :image=>$image['view'], :compound=>:left, 
+		      :command=>proc{
+			showVars($radio3_demo, ['size', size], 
+				 ['color', color], ['compound', align])
+		      }), 
+	 TkButton.new(frame, :text=>'See Code', 
+		      :image=>$image['view'], :compound=>:left, 
+		      :command=>proc{showCode 'radio3'}), 
+	 TkButton.new(frame, :text=>'Dismiss', 
+		      :image=>$image['delete'], :compound=>:left, 
+		      :command=>proc{
+			tmppath = $radio3_demo
+			$radio3_demo = nil
+			$showVarsWin[tmppath.path] = nil
+			tmppath.destroy
+		      }), 
+	 :padx=>4, :pady=>4)
+  frame.grid_columnconfigure(0, :weight=>1)
+  TkGrid(frame, :row=>3, :column=>0, :columnspan=>3, :sticky=>'nsew')
+}
+
+# frame 
+f_left  = TkLabelFrame.new($radio3_demo, 'text'=>'Point Size', 
+			   'pady'=>2, 'padx'=>2)
+f_mid   = TkLabelFrame.new($radio3_demo, 'text'=>'Color', 
+			   'pady'=>2, 'padx'=>2)
+f_right = TkLabelFrame.new($radio3_demo, 'text'=>'Alignment', 
+			   'pady'=>2, 'padx'=>2)
+f_left .grid('column'=>0, 'row'=>1, 'pady'=>'.5c', 'padx'=>'.5c', 'rowspan'=>2)
+f_mid  .grid('column'=>1, 'row'=>1, 'pady'=>'.5c', 'padx'=>'.5c', 'rowspan'=>2)
+f_right.grid('column'=>2, 'row'=>1, 'pady'=>'.5c', 'padx'=>'.5c')
+
+TkButton.new($radio3_demo, 'text'=>'Tristate', 
+	     'command'=>proc{size.value = 'multi'; color.value = 'multi'}){
+  grid('column'=>2, 'row'=>2, 'pady'=>'.5c', 'padx'=>'.5c')
+}
+
+# radiobutton 
+[10, 12, 14, 18, 24].each {|sz|
+  TkRadioButton.new(f_left) {
+    text "Point Size #{sz}"
+    variable size
+    relief 'flat'
+    value sz
+    tristatevalue 'multi'
+  }.pack('side'=>'top', 'pady'=>2, 'anchor'=>'w', 'fill'=>'x')
+}
+
+['Red', 'Green', 'Blue', 'Yellow', 'Orange', 'Purple'].each {|col|
+  TkRadioButton.new(f_mid) {
+    text col
+    variable color
+    relief 'flat'
+    value col.downcase
+    anchor 'w'
+    tristatevalue 'multi'
+    command proc{f_mid.fg(color.value)}
+  }.pack('side'=>'top', 'pady'=>2, 'fill'=>'x')
+}
+
+label = TkLabel.new(f_right, 'text'=>'Label', 'bitmap'=>'questhead', 
+		    'compound'=>'left')
+label.configure('width'=>TkWinfo.reqwidth(label), 'compound'=>'top')
+label.height(TkWinfo.reqheight(label))
+a_btn = ['Top', 'Left', 'Right', 'Bottom'].collect{|a|
+  TkRadioButton.new(f_right, 'text'=>a, 'variable'=>align, 'relief'=>'flat', 
+		    'value'=>a.downcase, 'indicatoron'=>0, 'width'=>7, 
+		    'command'=>proc{label.compound(align.value)})
+}
+
+Tk.grid('x', a_btn[0])
+Tk.grid(a_btn[1], label, a_btn[2])
+Tk.grid('x', a_btn[3])

ext/tk/sample/demos-en/twind2.rb

@@ -0,0 +1,382 @@
+#
+# text (embedded windows) widget demo 2 (called by 'widget')
+#
+
+# delete toplevel widget
+if defined?($twind2_demo) && $twind2_demo
+  $twind2_demo.destroy 
+  $twind2_demo = nil
+end
+
+# demo toplevel widget
+$twind2_demo = TkToplevel.new {|w|
+  title("Text Demonstration - Embedded Windows 2")
+  iconname("Embedded Windows")
+  positionWindow(w)
+}
+
+# frame
+$twind2_buttons = TkFrame.new($twind2_demo) {|frame|
+  TkGrid(TkFrame.new(frame, :height=>2, :relief=>:sunken, :bd=>2), 
+	 :columnspan=>4, :row=>0, :sticky=>'ew', :pady=>2)
+  TkGrid('x', 
+	 TkButton.new(frame, :text=>'See Code', 
+		      :image=>$image['view'], :compound=>:left, 
+		      :command=>proc{showCode 'twind2'}), 
+	 TkButton.new(frame, :text=>'Dismiss', 
+		      :image=>$image['delete'], :compound=>:left, 
+		      :command=>proc{
+			tmppath = $twind2_demo
+			$twind2_demo = nil
+			$showVarsWin[tmppath.path] = nil
+			tmppath.destroy
+		      }), 
+	 :padx=>4, :pady=>4)
+  frame.grid_columnconfigure(0, :weight=>1)
+}
+$twind2_buttons.pack('side'=>'bottom', 'fill'=>'x', 'pady'=>'2m')
+
+# frame
+$twind2_text = nil
+TkFrame.new($twind2_demo, 'highlightthickness'=>2, 'borderwidth'=>2, 
+	    'relief'=>'sunken') {|f|
+  $twind2_text = TkText.new(f, 'setgrid'=>true, 'font'=>$font,
+			    # 'width'=>'70', 'height'=>35, 'wrap'=>'word', 
+			    'width'=>'70', 'height'=>35, 'wrap'=>'char', 
+			    'highlightthickness'=>0, 'borderwidth'=>0 ){|t|
+    TkScrollbar.new(f) {|s|
+      command proc{|*args| t.yview(*args)}
+      t.yscrollcommand proc{|first,last| s.set first,last}
+    }.pack('side'=>'right', 'fill'=>'y')
+  }.pack('expand'=>'yes', 'fill'=>'both')
+}.pack('expand'=>'yes', 'fill'=>'both')
+
+# text tags
+$tag2_center = TkTextTag.new($twind2_text, 
+			    'justify' =>'center',
+			    'spacing1'=>'5m',
+			    'spacing3'=>'5m'  )
+$tag2_buttons = TkTextTag.new($twind2_text, 
+			     'lmargin1'=>'1c',
+			     'lmargin2'=>'1c',
+			     'rmargin' =>'1c',
+			     'spacing1'=>'3m',
+			     'spacing2'=>0,
+			     'spacing3'=>0 )
+
+# insert text
+$twind2_text.insert('end', 
+		  'A text widget can contain many different kinds of items, ')
+$twind2_text.insert('end',
+		  "both active and passive.  It can lay these out in various ")
+$twind2_text.insert('end',
+		   "ways, with wrapping, tabs, centering, etc.  In addition, ")
+$twind2_text.insert('end',
+		    "when the contents are too big for the window, smooth ")
+$twind2_text.insert('end', "scrolling in all directions is provided.\n\n")
+
+$twind2_text.insert('end', "A text widget can contain other widgets embedded ")
+$twind2_text.insert('end', "it.  These are called \"embedded windows\", ")
+$twind2_text.insert('end', "and they can consist of arbitrary widgets.  ")
+$twind2_text.insert('end', "For example, here are two embedded button ")
+$twind2_text.insert('end', "widgets.  You can click on the first button to ")
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text) {
+		   text 'ON'
+		   command proc{textWindOn2 $twind2_text,$twind2_buttons}
+		   cursor 'top_left_arrow'
+		 })
+$twind2_text.insert('end', " horizontal scrolling, which also turns off ")
+$twind2_text.insert('end', "word wrapping.  Or, you can click on the second ")
+$twind2_text.insert('end', "button to\n")
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text) {
+		   text 'OFF'
+		   command proc{textWindOff2 $twind2_text}
+		   cursor 'top_left_arrow'
+		 })
+$twind2_text.insert('end', 
+		   " horizontal scrolling and turn back on word wrapping.\n\n")
+
+$twind2_text.insert('end', "Or, here is another example.  If you ")
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text) {
+		   text 'Click Here'
+		   command proc{textWindPlot2 $twind2_text}
+		   cursor 'top_left_arrow'
+		 })
+$twind2_text.insert('end', 
+		    " a canvas displaying an x-y plot will appear right here.")
+$mark2_plot = TkTextMark.new($twind2_text, 'insert')
+$mark2_plot.gravity='left'
+$twind2_text.insert('end', 
+		    "  You can drag the data points around with the mouse, ")
+$twind2_text.insert('end', "or you can click here to ")
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text) {
+		   text 'Delete'
+		   command proc{textWindDel2 $twind2_text}
+		   cursor 'top_left_arrow'
+		 })
+$twind2_text.insert('end', " the plot again.\n\n")
+
+$twind2_text.insert('end', 
+		    "You may also find it useful to put embedded windows in ")
+$twind2_text.insert('end', 
+		    "a text without any actual text.  In this case the ")
+$twind2_text.insert('end', "text widget acts like a geometry manager.  For ")
+$twind2_text.insert('end', 
+		    "example, here is a collection of buttons laid out ")
+$twind2_text.insert('end', 
+		    "neatly into rows by the text widget.  These buttons ")
+$twind2_text.insert('end', 
+		    "can be used to change the background color of the ")
+$twind2_text.insert('end', "text widget (\"Default\" restores the color to ")
+$twind2_text.insert('end', 
+		    "its default).  If you click on the button labeled ")
+$twind2_text.insert('end', "\"Short\", it changes to a longer string so that ")
+$twind2_text.insert('end', "you can see how the text widget automatically ")
+$twind2_text.insert('end', "changes the layout.  Click on the button again ")
+$twind2_text.insert('end', "to restore the short string.\n")
+
+btn_default = TkButton.new($twind2_text) {|b|
+  text 'Default'
+  command proc{embDefBg2 $twind2_text}
+  cursor 'top_left_arrow'
+}
+TkTextWindow.new($twind2_text, 'end', 'window'=>btn_default, 'padx'=>3)
+embToggle = TkVariable.new('Short')
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkCheckButton.new($twind2_text) {
+		   textvariable embToggle
+		   indicatoron 0
+		   variable embToggle
+		   onvalue 'A much longer string'
+		   offvalue 'Short'
+		   cursor 'top_left_arrow'
+		   pady 5
+		   padx 2
+		 },
+		 'padx'=>3, 
+		 'pady'=>2 )
+
+[ 'AntiqueWhite3', 'Bisque1', 'Bisque2', 'Bisque3', 'Bisque4', 
+  'SlateBlue3', 'RoyalBlue1', 'SteelBlue2', 'DeepSkyBlue3', 'LightBlue1', 
+  'DarkSlateGray1', 'Aquamarine2', 'DarkSeaGreen2', 'SeaGreen1', 
+  'Yellow1', 'IndianRed1', 'IndianRed2', 'Tan1', 'Tan4' 
+].each{|twind_color|
+  TkTextWindow.new($twind2_text, 'end', 
+		   'window'=>TkButton.new($twind2_text) {
+		     text twind_color
+		     cursor 'top_left_arrow'
+		     command proc{$twind2_text.bg twind_color}
+		   },
+		   'padx'=>3, 
+		   'pady'=>2 )
+}
+
+$tag2_buttons.add(btn_default, 'end')
+
+$text_normal2 = {}
+$text_normal2['border'] = $twind2_text.cget('borderwidth')
+$text_normal2['highlight'] = $twind2_text.cget('highlightthickness')
+$text_normal2['pad'] = $twind2_text.cget('padx')
+
+$twind2_text.insert('end', "\nYou can also change the usual border width and ")
+$twind2_text.insert('end', "highlightthickness and padding.\n")
+
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text, :text=>"Big borders", 
+					:cursor=>'top_left_arrow', 
+					'command'=>proc{
+					  textWinBigB2 $twind2_text
+					}))
+
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text, :text=>"Small borders", 
+					:cursor=>'top_left_arrow', 
+					'command'=>proc{
+					  textWinSmallB2 $twind2_text
+					}))
+
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text, :text=>"Big highlight", 
+					:cursor=>'top_left_arrow', 
+					'command'=>proc{
+					  textWinBigH2 $twind2_text
+					}))
+
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text, :text=>"Small highlight",
+					:cursor=>'top_left_arrow', 
+					'command'=>proc{
+					  textWinSmallH2 $twind2_text
+					}))
+
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text, :text=>"Big pad", 
+					:cursor=>'top_left_arrow', 
+					'command'=>proc{
+					  textWinBigP2 $twind2_text
+					}))
+
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text, :text=>"Small pad", 
+					:cursor=>'top_left_arrow', 
+					'command'=>proc{
+					  textWinSmallP2 $twind2_text
+					}))
+
+$twind2_text.insert('end', 
+		    "\n\nFinally, images fit comfortably in text widgets too:")
+
+TkTextImage.new($twind2_text, 'end', 
+		'image'=>TkBitmapImage.new(:file=>[
+					     $demo_dir, '..', 
+					     'images', 'face.xbm'
+					   ].join(File::Separator)))
+
+# methods
+def textWinBigB2(w)
+  w.borderwidth 15
+end
+def textWinSmallB2(w)
+  w.borderwidth $text_normal2['border']
+end
+def textWinBigH2(w)
+  w.highlightthickness 15
+end
+def textWinSmallH2(w)
+  w.highlightthickness $text_normal2['highlight']
+end
+def textWinBigP2(w)
+  w.configure(:padx=>15, :pady=>15)
+end
+def textWinSmallP2(w)
+  w.configure(:padx=>$text_normal2['pad'], :pady=>$text_normal2['pad'])
+end
+
+def textWindOn2 (w,f)
+  if defined? $twind2_scroll
+    begin
+      $twind2_scroll.destroy
+    rescue
+    end
+    $twind2_scroll = nil
+  end
+
+  base = TkWinfo.parent( TkWinfo.parent(w) )
+  $twind2_scroll = TkScrollbar.new(base) {|s|
+    orient 'horizontal'
+    command proc{|*args| w.xview(*args)}
+    w.xscrollcommand proc{|first,last| s.set first,last}
+    w.wrap 'none'
+    pack('after'=>f, 'side'=>'bottom', 'fill'=>'x')
+  }
+
+  return nil
+end
+
+def textWindOff2 (w)
+  if defined? $twind2_scroll
+    begin
+      $twind2_scroll.destroy
+    rescue
+    end
+    $twind2_scroll = nil
+  end
+  w.xscrollcommand ''
+  #w.wrap 'word'
+  w.wrap 'char'
+end
+
+def textWindPlot2 (t)
+  if (defined? $twind2_plot) && (TkWinfo.exist?($twind2_plot))
+    return
+  end
+
+  $twind2_plot = TkCanvas.new(t) {
+    relief 'sunken'
+    width  450
+    height 300
+    cursor 'top_left_arrow'
+  }
+
+  #font = '-Adobe-Helvetica-Medium-R-Normal--*-180-*-*-*-*-*-*'
+  font = 'Helvetica 18'
+
+  TkcLine.new($twind2_plot, 100, 250, 400, 250, 'width'=>2)
+  TkcLine.new($twind2_plot, 100, 250, 100,  50, 'width'=>2)
+  TkcText.new($twind2_plot, 225, 20, 
+	      'text'=>"A Simple Plot", 'font'=>font, 'fill'=>'brown')
+
+  (0..10).each {|i|
+    x = 100 + (i * 30)
+    TkcLine.new($twind2_plot, x, 250, x, 245, 'width'=>2)
+    TkcText.new($twind2_plot, x, 254, 
+		'text'=>10*i, 'font'=>font, 'anchor'=>'n')
+  }
+  (0..5).each {|i|
+    y = 250 - (i * 40)
+    TkcLine.new($twind2_plot, 100, y, 105, y, 'width'=>2)
+    TkcText.new($twind2_plot, 96, y, 
+		'text'=>"#{i*50}.0", 'font'=>font, 'anchor'=>'e')
+  }
+
+  for xx, yy in [[12,56],[20,94],[33,98],[32,120],[61,180],[75,160],[98,223]]
+    x = 100 + (3*xx)
+    y = 250 - (4*yy)/5
+    item = TkcOval.new($twind2_plot, x-6, y-6, x+6, y+6, 
+		       'width'=>1, 'outline'=>'black', 'fill'=>'SkyBlue2')
+    item.addtag 'point'
+  end
+
+  $twind2_plot.itembind('point', 'Any-Enter', 
+			proc{$twind2_plot.itemconfigure 'current', 'fill', 'red'})
+  $twind2_plot.itembind('point', 'Any-Leave', 
+			proc{$twind2_plot.itemconfigure 'current', 'fill', 'SkyBlue2'})
+  $twind2_plot.itembind('point', '1', 
+			proc{|x,y| embPlotDown2 $twind2_plot,x,y}, "%x %y")
+  $twind2_plot.itembind('point', 'ButtonRelease-1', 
+			proc{$twind2_plot.dtag 'selected'})
+  $twind2_plot.bind('B1-Motion', 
+		    proc{|x,y| embPlotMove2 $twind2_plot,x,y}, "%x %y")
+  while ($twind2_text.get($mark2_plot) =~ /[ \t\n]/)
+    $twind2_text.delete $mark2_plot
+  end
+  $twind2_text.insert $mark2_plot,"\n"
+  TkTextWindow.new($twind2_text, $mark2_plot, 'window'=>$twind2_plot)
+  $tag2_center.add $mark2_plot
+  $twind2_text.insert $mark2_plot,"\n"
+end
+
+$embPlot2 = {'lastX'=>0, 'lastY'=>0}
+
+def embPlotDown2 (w, x, y)
+  w.dtag 'selected'
+  w.addtag_withtag 'selected', 'current'
+  w.raise 'current'
+  $embPlot2['lastX'] = x
+  $embPlot2['lastY'] = y
+end
+
+def embPlotMove2 (w, x, y)
+  w.move 'selected', x - $embPlot2['lastX'], y - $embPlot2['lastY']
+  $embPlot2['lastX'] = x
+  $embPlot2['lastY'] = y
+end
+
+def textWindDel2 (w)
+  if (defined? $twind2_text) && TkWinfo.exist?($twind2_plot)
+    $twind2_text.delete $twind2_plot
+    $twind2_plot = nil
+    while ($twind2_text.get($mark2_plot) =~ /[ \t\n]/)
+      $twind2_text.delete $mark2_plot
+    end
+    $twind2_text.insert $mark2_plot,"  "
+  end
+end
+
+def embDefBg2 (w)
+  w['background'] = w.configinfo('background')[3]
+end

ext/tk/sample/demos-jp/README.1st

@@ -0,0 +1,20 @@
+このディレクトリには Ruby/Tk のデモスクリプトが収められています．
+
+'.rb' という拡張子を持っているファイルは，ランチャ─スクリプトで
+ある 'widget' から呼び出されるサブスクリプトです．それぞれ独立に
+は動きません．'widget' スクリプトから呼び出してください．
+
+もしランチャ─スクリプト 'widget' の起動と同時にいくつかのサブス
+クリプトを起動したければ，そのサブスクリプトの名前を引数として与
+えてください．
+( 例: /usr/local/bin/ruby widget button.rb entry1.rb text.rb )
+サブスクリプトの拡張子 '.rb' は省略することもできます．
+( 例: /usr/local/bin/ruby widget button entry1 text )
+
+もしランチャ─スクリプトのウィンドウが必要ない場合には，'-n' オ
+プションを与えてください．
+( 例: /usr/local/bin/ruby widget -n button.rb entry1.rb text.rb )
+
+他のファイル (browse1 や hello など) は単独で動かすことが可能です．
+
+          2004/04/14  Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)

ext/tk/sample/demos-jp/check2.rb

@@ -0,0 +1,107 @@
+#
+# checkbutton widget demo2 (called by 'widget')
+#
+
+# toplevel widget が存在すれば削除する
+if defined?($check2_demo) && $check2_demo
+  $check2_demo.destroy 
+  $check2_demo = nil
+end
+
+# demo 用の toplevel widget を生成
+$check2_demo = TkToplevel.new {|w|
+  title("Checkbutton Demonstration 2")
+  iconname("check2")
+  positionWindow(w)
+}
+
+# label 生成
+msg = TkLabel.new($check2_demo) {
+  font $font
+  wraplength '4i'
+  justify 'left'
+  text "下には４つのチェックボタンが表示されています。クリックするとボタンの選択状態が変わり、Tcl変数（TkVariableオブジェクトでアクセスできます）にそのボタンの状態を示す値を設定します。最初のボタンの状態は他の３つのボタンの状態にも依存して変化します。もし３つのボタンの一部だけにチェックが付けられている場合、最初のボタンはトライステート（３状態）モードでの表示を行います。現在の変数の値を見るには「変数参照」ボタンをクリックしてください。"
+}
+msg.pack('side'=>'top')
+
+# 変数生成
+safety = TkVariable.new(0)
+wipers = TkVariable.new(0)
+brakes = TkVariable.new(0)
+sober  = TkVariable.new(0)
+
+# frame 生成
+TkFrame.new($check2_demo) {|frame|
+  TkGrid(TkFrame.new(frame, :height=>2, :relief=>:sunken, :bd=>2), 
+	 :columnspan=>4, :row=>0, :sticky=>'ew', :pady=>2)
+  TkGrid('x', 
+	 TkButton.new(frame, :text=>'変数参照', 
+		      :image=>$image['view'], :compound=>:left, 
+		      :command=>proc{
+			showVars($check2_demo, 
+				 ['safety', safety], ['wipers', wipers], 
+				 ['brakes', brakes], ['sober', sober])
+		      }), 
+	 TkButton.new(frame, :text=>'コード参照', 
+		      :image=>$image['view'], :compound=>:left, 
+		      :command=>proc{showCode 'check2'}), 
+	 TkButton.new(frame, :text=>'閉じる', 
+		      :image=>$image['delete'], :compound=>:left, 
+		      :command=>proc{
+			tmppath = $check2_demo
+			$check2_demo = nil
+			$showVarsWin[tmppath.path] = nil
+			tmppath.destroy
+		      }), 
+	 :padx=>4, :pady=>4)
+  frame.grid_columnconfigure(0, :weight=>1)
+}.pack('side'=>'bottom', 'fill'=>'x')
+
+
+# checkbutton 生成
+TkCheckButton.new($check2_demo, :text=>'安全性検査', :variable=>safety, 
+		  :relief=>:flat, :onvalue=>'all', :offvalue=>'none', 
+		  :tristatevalue=>'partial'){
+  pack('side'=>'top', 'pady'=>2, 'anchor'=>'w')
+}
+
+[ TkCheckButton.new($check2_demo, 'text'=>'ワイパー OK', 'variable'=>wipers),
+  TkCheckButton.new($check2_demo, 'text'=>'ブレーキ OK', 'variable'=>brakes),
+  TkCheckButton.new($check2_demo, 'text'=>'運転手 素面', 'variable'=>sober)
+].each{|w| 
+  w.relief('flat')
+  w.pack('side'=>'top', 'padx'=>15, 'pady'=>2, 'anchor'=>'w')
+}
+
+# tristate check
+in_check = false
+tristate_check = proc{|n1,n2,op|
+  return if in_check
+
+  in_check = true
+  begin
+    if n1 == safety
+      if safety == 'none'
+	wipers.value = 0
+	brakes.value = 0
+	sober.value  = 0
+      elsif safety == 'all'
+	wipers.value = 1
+	brakes.value = 1
+	sober.value  = 1
+      end
+    else
+      if wipers == 1 && brakes == 1 && sober == 1
+	safety.value = 'all'
+      elsif wipers == 1 || brakes == 1 || sober == 1
+	safety.value = 'partial'
+      else
+	safety.value = 'none'
+      end
+    end
+  ensure
+    in_check = false
+  end
+}
+
+[wipers, brakes, sober, safety].each{|v| v.trace('w', tristate_check)}

ext/tk/sample/demos-jp/radio3.rb

@@ -0,0 +1,114 @@
+# radio3.rb
+#
+# This demonstration script creates a toplevel window containing
+# several radiobutton widgets.
+#
+# radiobutton widget demo (called by 'widget')
+#
+
+# toplevel widget
+if defined?($radio3_demo) && $radio3_demo
+  $radio3_demo.destroy 
+  $radio3_demo = nil
+end
+
+# demo toplevel widget
+$radio3_demo = TkToplevel.new {|w|
+  title("Radiobutton Demonstration 3")
+  iconname("radio3")
+  positionWindow(w)
+}
+
+# label 
+msg = TkLabel.new($radio3_demo) {
+  font $font
+  wraplength '5i'
+  justify 'left'
+  text '下には3つのラジオボタングループが表示されています。ボタンをクリックすると、そのグループに属するすべてのボタンの中でクリックしたボタンだけが選択された状態になります。各グループには、そのグループの中のどのボタンが選択されているかを示す変数が割り当てられています。「トライステート」ボタンが押されたときには、ラジオボタンの表示がトライステートモードになります。いずれかのボタンを選択すれば、ボタンの状態は元のように個々のボタンのon/off状態を示すようになります。現在の変数の値を見るには「変数参照」ボタンをクリックしてください。'
+}
+msg.grid(:row=>0, :column=>0, :columnspan=>3, :sticky=>'nsew')
+
+# variable
+size = TkVariable.new
+color = TkVariable.new
+align = TkVariable.new
+
+# frame 
+TkFrame.new($radio3_demo) {|frame|
+  TkGrid(TkFrame.new(frame, :height=>2, :relief=>:sunken, :bd=>2), 
+	 :columnspan=>4, :row=>0, :sticky=>'ew', :pady=>2)
+  TkGrid('x', 
+	 TkButton.new(frame, :text=>'変数参照', 
+		      :image=>$image['view'], :compound=>:left, 
+		      :command=>proc{
+			showVars($radio3_demo, ['size', size], 
+				 ['color', color], ['compound', align])
+		      }), 
+	 TkButton.new(frame, :text=>'コード参照', 
+		      :image=>$image['view'], :compound=>:left, 
+		      :command=>proc{showCode 'radio3'}), 
+	 TkButton.new(frame, :text=>'閉じる', 
+		      :image=>$image['delete'], :compound=>:left, 
+		      :command=>proc{
+			tmppath = $radio3_demo
+			$radio3_demo = nil
+			$showVarsWin[tmppath.path] = nil
+			tmppath.destroy
+		      }), 
+	 :padx=>4, :pady=>4)
+  frame.grid_columnconfigure(0, :weight=>1)
+  TkGrid(frame, :row=>3, :column=>0, :columnspan=>3, :sticky=>'nsew')
+}
+
+# frame 
+f_left  = TkLabelFrame.new($radio3_demo, 'text'=>'文字サイズ', 
+			   'pady'=>2, 'padx'=>2)
+f_mid   = TkLabelFrame.new($radio3_demo, 'text'=>'色', 
+			   'pady'=>2, 'padx'=>2)
+f_right = TkLabelFrame.new($radio3_demo, 'text'=>'ビットマップ配置', 
+			   'pady'=>2, 'padx'=>2)
+f_left .grid('column'=>0, 'row'=>1, 'pady'=>'.5c', 'padx'=>'.5c', 'rowspan'=>2)
+f_mid  .grid('column'=>1, 'row'=>1, 'pady'=>'.5c', 'padx'=>'.5c', 'rowspan'=>2)
+f_right.grid('column'=>2, 'row'=>1, 'pady'=>'.5c', 'padx'=>'.5c')
+
+TkButton.new($radio3_demo, 'text'=>'トライステート', 
+	     'command'=>proc{size.value = 'multi'; color.value = 'multi'}){
+  grid('column'=>2, 'row'=>2, 'pady'=>'.5c', 'padx'=>'.5c')
+}
+
+# radiobutton 
+[10, 12, 14, 18, 24].each {|sz|
+  TkRadioButton.new(f_left) {
+    text "ポイントサイズ #{sz}"
+    variable size
+    relief 'flat'
+    value sz
+    tristatevalue 'multi'
+  }.pack('side'=>'top', 'pady'=>2, 'anchor'=>'w', 'fill'=>'x')
+}
+
+['Red', 'Green', 'Blue', 'Yellow', 'Orange', 'Purple'].each {|col|
+  TkRadioButton.new(f_mid) {
+    text col
+    variable color
+    relief 'flat'
+    value col.downcase
+    anchor 'w'
+    tristatevalue 'multi'
+    command proc{f_mid.fg(color.value)}
+  }.pack('side'=>'top', 'pady'=>2, 'fill'=>'x')
+}
+
+label = TkLabel.new(f_right, 'text'=>'ラベル', 'bitmap'=>'questhead', 
+		    'compound'=>'left')
+label.configure('width'=>TkWinfo.reqwidth(label), 'compound'=>'top')
+label.height(TkWinfo.reqheight(label))
+a_btn = ['Top', 'Left', 'Right', 'Bottom'].collect{|a|
+  TkRadioButton.new(f_right, 'text'=>a, 'variable'=>align, 'relief'=>'flat', 
+		    'value'=>a.downcase, 'indicatoron'=>0, 'width'=>7, 
+		    'command'=>proc{label.compound(align.value)})
+}
+
+Tk.grid('x', a_btn[0])
+Tk.grid(a_btn[1], label, a_btn[2])
+Tk.grid('x', a_btn[3])

ext/tk/sample/demos-jp/twind2.rb

@@ -0,0 +1,381 @@
+#
+# text (embedded windows) widget demo 2 (called by 'widget')
+#
+
+# toplevel widget が存在すれば削除する
+if defined?($twind2_demo) && $twind2_demo
+  $twind2_demo.destroy 
+  $twind2_demo = nil
+end
+
+# demo 用の toplevel widget を生成
+$twind2_demo = TkToplevel.new {|w|
+  title("Text Demonstration - Embedded Windows 2")
+  iconname("Embedded Windows")
+  positionWindow(w)
+}
+
+# frame 生成
+$twind2_buttons = TkFrame.new($twind2_demo) {|frame|
+  TkGrid(TkFrame.new(frame, :height=>2, :relief=>:sunken, :bd=>2), 
+	 :columnspan=>4, :row=>0, :sticky=>'ew', :pady=>2)
+  TkGrid('x', 
+	 TkButton.new(frame, :text=>'コード参照', 
+		      :image=>$image['view'], :compound=>:left, 
+		      :command=>proc{showCode 'twind2'}), 
+	 TkButton.new(frame, :text=>'閉じる', 
+		      :image=>$image['delete'], :compound=>:left, 
+		      :command=>proc{
+			tmppath = $twind2_demo
+			$twind2_demo = nil
+			$showVarsWin[tmppath.path] = nil
+			tmppath.destroy
+		      }), 
+	 :padx=>4, :pady=>4)
+  frame.grid_columnconfigure(0, :weight=>1)
+}
+$twind2_buttons.pack('side'=>'bottom', 'fill'=>'x', 'pady'=>'2m')
+
+# frame 生成
+$twind2_text = nil
+TkFrame.new($twind2_demo, 'highlightthickness'=>2, 'borderwidth'=>2, 
+	    'relief'=>'sunken') {|f|
+  $twind2_text = TkText.new(f, 'setgrid'=>true, 'font'=>$font,
+			    # 'width'=>'70', 'height'=>35, 'wrap'=>'word', 
+			    'width'=>'70', 'height'=>35, 'wrap'=>'char', 
+			    'highlightthickness'=>0, 'borderwidth'=>0 ){|t|
+    TkScrollbar.new(f) {|s|
+      command proc{|*args| t.yview(*args)}
+      t.yscrollcommand proc{|first,last| s.set first,last}
+    }.pack('side'=>'right', 'fill'=>'y')
+  }.pack('expand'=>'yes', 'fill'=>'both')
+}.pack('expand'=>'yes', 'fill'=>'both')
+
+# タグ生成
+$tag2_center = TkTextTag.new($twind2_text, 
+			    'justify' =>'center',
+			    'spacing1'=>'5m',
+			    'spacing3'=>'5m'  )
+$tag2_buttons = TkTextTag.new($twind2_text, 
+			     'lmargin1'=>'1c',
+			     'lmargin2'=>'1c',
+			     'rmargin' =>'1c',
+			     'spacing1'=>'3m',
+			     'spacing2'=>0,
+			     'spacing3'=>0 )
+
+# テキストの生成
+$twind2_text.insert('end', 'テキストウィジェットには色々な種類のアイテム')
+$twind2_text.insert('end', '（動的なものや静的なものの両方があります）を')
+$twind2_text.insert('end', '数多く含めることができます。そうしたアイテムは')
+$twind2_text.insert('end', '行替え、タブ、中央揃えなどの様々な方法で')
+$twind2_text.insert('end', '配置することができます。')
+$twind2_text.insert('end', '加えて、テキストウィジェットの内容物が')
+$twind2_text.insert('end', 'ウィンドウサイズに比べて大きすぎる場合でも')
+$twind2_text.insert('end', 'すべての方向にスムーズにスクロールさせて')
+$twind2_text.insert('end', '確認することが可能です。')
+$twind2_text.insert('end', "\n\n")
+$twind2_text.insert('end', 'テキストウィジェット上には他のウィジェットを')
+$twind2_text.insert('end', '含めることもできます。こうしたものは')
+$twind2_text.insert('end', '「埋め込みウィンドウ」と呼ばれ、その中に')
+$twind2_text.insert('end', 'いかなるウィジェットでも詰め込むことができます。')
+$twind2_text.insert('end', '例えば，ここには２つの')
+$twind2_text.insert('end', 'ボタンウィジェットが埋め込まれています。')
+$twind2_text.insert('end', '最初のボタンをクリックすると、')
+$twind2_text.insert('end', '水平方向のスクロールを ')
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text) {
+		   #text 'ON'
+		   text 'オン'
+		   command proc{textWindOn2 $twind2_text,$twind2_buttons}
+		   cursor 'top_left_arrow'
+		 })
+$twind2_text.insert('end', "にします。また、２つめのボタンをクリックすると\n")
+$twind2_text.insert('end', '水平方向のスクロールを')
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text) {
+		   #text 'OFF'
+		   text 'オフ'
+		   command proc{textWindOff2 $twind2_text}
+		   cursor 'top_left_arrow'
+		 })
+$twind2_text.insert('end', "にします。\n\n")
+
+$twind2_text.insert('end', '次はもうひとつの例です。')
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text) {
+		   text 'ここをクリック'
+		   command proc{textWindPlot2 $twind2_text}
+		   cursor 'top_left_arrow'
+		 })
+$twind2_text.insert('end', 'すると、x-yプロットがここに現れます。')
+$mark2_plot = TkTextMark.new($twind2_text, 'insert')
+$mark2_plot.gravity='left'
+$twind2_text.insert('end', 'マウスでドラッグすることで、')
+$twind2_text.insert('end', 'プロット上のデータ点を移動することができます。')
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text) {
+		   text '消去'
+		   command proc{textWindDel2 $twind2_text}
+		   cursor 'top_left_arrow'
+		 })
+$twind2_text.insert('end', 'をクリックすると元に戻ります。')
+$twind2_text.insert('end', "\n\n")
+
+$twind2_text.insert('end', '表示するテキストなしに埋め込みウィンドウだけを')
+$twind2_text.insert('end', 'テキストウィジェットに含めることも有用でしょう。')
+$twind2_text.insert('end', 'この場合、テキストウィジェットは')
+$twind2_text.insert('end', 'ジオメトリマネージャのように働きます。')
+$twind2_text.insert('end', '例えば、ここにはテキストウィジェットに')
+$twind2_text.insert('end', 'よってボタンがきれいに整列して配置されています。')
+$twind2_text.insert('end', 'これらのボタンをクリックすることで、')
+$twind2_text.insert('end', 'このテキストウィジェットの背景色を')
+$twind2_text.insert('end', '変えることができます("デフォルト"ボタンで')
+$twind2_text.insert('end', '元の色に戻すことができます)。')
+$twind2_text.insert('end', '"Short"というボタンをクリックすると文字列の長さが')
+$twind2_text.insert('end', '変わり、テキストウィジェットが自動的に')
+$twind2_text.insert('end', 'レイアウトを整える様子を見ることができます。')
+$twind2_text.insert('end', 'もう一度同じボタンを押すと元に戻ります。')
+$twind2_text.insert('end', "\n")
+
+btn_default = TkButton.new($twind2_text) {|b|
+  text 'デフォルト'
+  command proc{embDefBg2 $twind2_text}
+  cursor 'top_left_arrow'
+}
+TkTextWindow.new($twind2_text, 'end', 'window'=>btn_default, 'padx'=>3)
+embToggle = TkVariable.new('Short')
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkCheckButton.new($twind2_text) {
+		   textvariable embToggle
+		   indicatoron 0
+		   variable embToggle
+		   onvalue 'A much longer string'
+		   offvalue 'Short'
+		   cursor 'top_left_arrow'
+		   pady 5
+		   padx 2
+		 },
+		 'padx'=>3, 
+		 'pady'=>2 )
+
+[ 'AntiqueWhite3', 'Bisque1', 'Bisque2', 'Bisque3', 'Bisque4', 
+  'SlateBlue3', 'RoyalBlue1', 'SteelBlue2', 'DeepSkyBlue3', 'LightBlue1', 
+  'DarkSlateGray1', 'Aquamarine2', 'DarkSeaGreen2', 'SeaGreen1', 
+  'Yellow1', 'IndianRed1', 'IndianRed2', 'Tan1', 'Tan4' 
+].each{|twind_color|
+  TkTextWindow.new($twind2_text, 'end', 
+		   'window'=>TkButton.new($twind2_text) {
+		     text twind_color
+		     cursor 'top_left_arrow'
+		     command proc{$twind2_text.bg twind_color}
+		   },
+		   'padx'=>3, 
+		   'pady'=>2 )
+}
+
+$tag2_buttons.add(btn_default, 'end')
+
+$text_normal2 = {}
+$text_normal2['border'] = $twind2_text.cget('borderwidth')
+$text_normal2['highlight'] = $twind2_text.cget('highlightthickness')
+$text_normal2['pad'] = $twind2_text.cget('padx')
+
+$twind2_text.insert('end', "\nborder width や highlightthickness, ")
+$twind2_text.insert('end', "padding を通常の値から変更することも可能です。\n")
+
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text, :text=>"Big borders", 
+					:cursor=>'top_left_arrow', 
+					'command'=>proc{
+					  textWinBigB2 $twind2_text
+					}))
+
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text, :text=>"Small borders", 
+					:cursor=>'top_left_arrow', 
+					'command'=>proc{
+					  textWinSmallB2 $twind2_text
+					}))
+
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text, :text=>"Big highlight", 
+					:cursor=>'top_left_arrow', 
+					'command'=>proc{
+					  textWinBigH2 $twind2_text
+					}))
+
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text, :text=>"Small highlight",
+					:cursor=>'top_left_arrow', 
+					'command'=>proc{
+					  textWinSmallH2 $twind2_text
+					}))
+
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text, :text=>"Big pad", 
+					:cursor=>'top_left_arrow', 
+					'command'=>proc{
+					  textWinBigP2 $twind2_text
+					}))
+
+TkTextWindow.new($twind2_text, 'end', 
+		 'window'=>TkButton.new($twind2_text, :text=>"Small pad", 
+					:cursor=>'top_left_arrow', 
+					'command'=>proc{
+					  textWinSmallP2 $twind2_text
+					}))
+
+$twind2_text.insert('end', "\n\n更にイメージもテキストウィジェットに")
+$twind2_text.insert('end', "うまく配置できます：")
+
+TkTextImage.new($twind2_text, 'end', 
+		'image'=>TkBitmapImage.new(:file=>[
+					     $demo_dir, '..', 
+					     'images', 'face.xbm'
+					   ].join(File::Separator)))
+
+# メソッド定義
+def textWinBigB2(w)
+  w.borderwidth 15
+end
+def textWinSmallB2(w)
+  w.borderwidth $text_normal2['border']
+end
+def textWinBigH2(w)
+  w.highlightthickness 15
+end
+def textWinSmallH2(w)
+  w.highlightthickness $text_normal2['highlight']
+end
+def textWinBigP2(w)
+  w.configure(:padx=>15, :pady=>15)
+end
+def textWinSmallP2(w)
+  w.configure(:padx=>$text_normal2['pad'], :pady=>$text_normal2['pad'])
+end
+
+def textWindOn2 (w,f)
+  if defined? $twind2_scroll
+    begin
+      $twind2_scroll.destroy
+    rescue
+    end
+    $twind2_scroll = nil
+  end
+
+  base = TkWinfo.parent( TkWinfo.parent(w) )
+  $twind2_scroll = TkScrollbar.new(base) {|s|
+    orient 'horizontal'
+    command proc{|*args| w.xview(*args)}
+    w.xscrollcommand proc{|first,last| s.set first,last}
+    w.wrap 'none'
+    pack('after'=>f, 'side'=>'bottom', 'fill'=>'x')
+  }
+
+  return nil
+end
+
+def textWindOff2 (w)
+  if defined? $twind2_scroll
+    begin
+      $twind2_scroll.destroy
+    rescue
+    end
+    $twind2_scroll = nil
+  end
+  w.xscrollcommand ''
+  #w.wrap 'word'
+  w.wrap 'char'
+end
+
+def textWindPlot2 (t)
+  if (defined? $twind2_plot) && (TkWinfo.exist?($twind2_plot))
+    return
+  end
+
+  $twind2_plot = TkCanvas.new(t) {
+    relief 'sunken'
+    width  450
+    height 300
+    cursor 'top_left_arrow'
+  }
+
+  #font = '-Adobe-Helvetica-Medium-R-Normal--*-180-*-*-*-*-*-*'
+  font = 'Helvetica 18'
+
+  TkcLine.new($twind2_plot, 100, 250, 400, 250, 'width'=>2)
+  TkcLine.new($twind2_plot, 100, 250, 100,  50, 'width'=>2)
+  TkcText.new($twind2_plot, 225, 20, 
+	      'text'=>"A Simple Plot", 'font'=>font, 'fill'=>'brown')
+
+  (0..10).each {|i|
+    x = 100 + (i * 30)
+    TkcLine.new($twind2_plot, x, 250, x, 245, 'width'=>2)
+    TkcText.new($twind2_plot, x, 254, 
+		'text'=>10*i, 'font'=>font, 'anchor'=>'n')
+  }
+  (0..5).each {|i|
+    y = 250 - (i * 40)
+    TkcLine.new($twind2_plot, 100, y, 105, y, 'width'=>2)
+    TkcText.new($twind2_plot, 96, y, 
+		'text'=>"#{i*50}.0", 'font'=>font, 'anchor'=>'e')
+  }
+
+  for xx, yy in [[12,56],[20,94],[33,98],[32,120],[61,180],[75,160],[98,223]]
+    x = 100 + (3*xx)
+    y = 250 - (4*yy)/5
+    item = TkcOval.new($twind2_plot, x-6, y-6, x+6, y+6, 
+		       'width'=>1, 'outline'=>'black', 'fill'=>'SkyBlue2')
+    item.addtag 'point'
+  end
+
+  $twind2_plot.itembind('point', 'Any-Enter', 
+			proc{$twind2_plot.itemconfigure 'current', 'fill', 'red'})
+  $twind2_plot.itembind('point', 'Any-Leave', 
+			proc{$twind2_plot.itemconfigure 'current', 'fill', 'SkyBlue2'})
+  $twind2_plot.itembind('point', '1', 
+			proc{|x,y| embPlotDown2 $twind2_plot,x,y}, "%x %y")
+  $twind2_plot.itembind('point', 'ButtonRelease-1', 
+			proc{$twind2_plot.dtag 'selected'})
+  $twind2_plot.bind('B1-Motion', 
+		    proc{|x,y| embPlotMove2 $twind2_plot,x,y}, "%x %y")
+  while ($twind2_text.get($mark2_plot) =~ /[ \t\n]/)
+    $twind2_text.delete $mark2_plot
+  end
+  $twind2_text.insert $mark2_plot,"\n"
+  TkTextWindow.new($twind2_text, $mark2_plot, 'window'=>$twind2_plot)
+  $tag2_center.add $mark2_plot
+  $twind2_text.insert $mark2_plot,"\n"
+end
+
+$embPlot2 = {'lastX'=>0, 'lastY'=>0}
+
+def embPlotDown2 (w, x, y)
+  w.dtag 'selected'
+  w.addtag_withtag 'selected', 'current'
+  w.raise 'current'
+  $embPlot2['lastX'] = x
+  $embPlot2['lastY'] = y
+end
+
+def embPlotMove2 (w, x, y)
+  w.move 'selected', x - $embPlot2['lastX'], y - $embPlot2['lastY']
+  $embPlot2['lastX'] = x
+  $embPlot2['lastY'] = y
+end
+
+def textWindDel2 (w)
+  if (defined? $twind2_text) && TkWinfo.exist?($twind2_plot)
+    $twind2_text.delete $twind2_plot
+    $twind2_plot = nil
+    while ($twind2_text.get($mark2_plot) =~ /[ \t\n]/)
+      $twind2_text.delete $mark2_plot
+    end
+    $twind2_text.insert $mark2_plot,"  "
+  end
+end
+
+def embDefBg2 (w)
+  w['background'] = w.configinfo('background')[3]
+end

ext/tk/sample/encstr_usage.rb

@@ -0,0 +1,29 @@
+require 'tk'
+
+TkMessage.new(:width=>400, :text=><<EOM).pack
+This sample shows how to use Tk::EncodedString class. \
+This reads 'iso2022-kr' text (from discription of \
+Korean language environment of GNU Emacs 20.7.2) \
+and inserts the text into the text widget.
+EOM
+
+t1 = TkText.new(:height=>5).pack
+t2 = TkText.new(:height=>5).pack
+t3 = TkText.new(:height=>5).pack
+
+src_str = IO.readlines('iso2022-kr.txt').join
+
+t1.insert('end', 
+	  "use neither Tk::EncodedString class nor Tk.encoding= method\n\n")
+t1.insert('end', src_str)
+
+enc_str = Tk::EncodedString(src_str, 'iso2022-kr')
+t2.insert('end', 
+	  "use Tk::EncodedString class (Tk.encoding => '#{Tk.encoding}')\n\n")
+t2.insert('end', enc_str)
+
+Tk.encoding = 'iso2022-kr'
+t3.insert('end', "use Tk.encoding = 'iso2022-kr'\n\n")
+t3.insert('end', src_str)
+
+Tk.mainloop

ext/tk/sample/images/face.xbm

@@ -0,0 +1,173 @@
+#define face_width 108
+#define face_height 144
+#define face_x_hot 48
+#define face_y_hot 80
+static char face_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x09,
+   0x20, 0x80, 0x24, 0x05, 0x00, 0x80, 0x08, 0x00, 0x00, 0x00, 0x00, 0x88,
+   0x24, 0x20, 0x80, 0x24, 0x00, 0x00, 0x00, 0x10, 0x80, 0x04, 0x00, 0x01,
+   0x00, 0x01, 0x40, 0x0a, 0x09, 0x00, 0x92, 0x04, 0x80, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x10, 0x40, 0x12, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00, 0x84,
+   0x24, 0x40, 0x22, 0xa8, 0x02, 0x14, 0x84, 0x92, 0x40, 0x42, 0x12, 0x04,
+   0x10, 0x00, 0x00, 0x00, 0x00, 0x52, 0x00, 0x52, 0x11, 0x00, 0x12, 0x00,
+   0x40, 0x02, 0x00, 0x20, 0x00, 0x08, 0x00, 0xaa, 0x02, 0x54, 0x85, 0x24,
+   0x00, 0x10, 0x12, 0x00, 0x00, 0x81, 0x44, 0x00, 0x90, 0x5a, 0x00, 0xea,
+   0x1b, 0x00, 0x80, 0x40, 0x40, 0x02, 0x00, 0x08, 0x00, 0x20, 0xa2, 0x05,
+   0x8a, 0xb4, 0x6e, 0x45, 0x12, 0x04, 0x08, 0x00, 0x00, 0x00, 0x10, 0x02,
+   0xa8, 0x92, 0x00, 0xda, 0x5f, 0x10, 0x00, 0x10, 0xa1, 0x04, 0x20, 0x41,
+   0x02, 0x00, 0x5a, 0x25, 0xa0, 0xff, 0xfb, 0x05, 0x41, 0x02, 0x04, 0x00,
+   0x00, 0x08, 0x40, 0x80, 0xec, 0x9b, 0xec, 0xfe, 0x7f, 0x01, 0x04, 0x20,
+   0x90, 0x02, 0x04, 0x00, 0x08, 0x20, 0xfb, 0x2e, 0xf5, 0xff, 0xff, 0x57,
+   0x00, 0x04, 0x02, 0x00, 0x00, 0x20, 0x01, 0xc1, 0x6e, 0xab, 0xfa, 0xff,
+   0xff, 0x05, 0x90, 0x20, 0x48, 0x02, 0x00, 0x04, 0x20, 0xa8, 0xdf, 0xb5,
+   0xfe, 0xff, 0xff, 0x0b, 0x01, 0x00, 0x01, 0x00, 0x80, 0x80, 0x04, 0xe0,
+   0xbb, 0xef, 0xff, 0xff, 0x7f, 0x01, 0x00, 0x04, 0x48, 0x02, 0x00, 0x20,
+   0x80, 0xf4, 0x6f, 0xfb, 0xff, 0xff, 0xff, 0x20, 0x90, 0x40, 0x02, 0x00,
+   0x00, 0x04, 0x08, 0xb8, 0xf6, 0xff, 0xff, 0xdf, 0xbe, 0x12, 0x45, 0x10,
+   0x90, 0x04, 0x90, 0x00, 0x22, 0xfa, 0xff, 0xff, 0xff, 0xbb, 0xd7, 0xe9,
+   0x3a, 0x02, 0x02, 0x00, 0x04, 0x90, 0x80, 0xfe, 0xdf, 0xf6, 0xb7, 0xef,
+   0xbe, 0x56, 0x57, 0x40, 0x48, 0x09, 0x00, 0x04, 0x00, 0xfa, 0xf5, 0xdf,
+   0xed, 0x5a, 0xd5, 0xea, 0xbd, 0x09, 0x00, 0x00, 0x40, 0x00, 0x92, 0xfe,
+   0xbf, 0x7d, 0xb7, 0x6a, 0x55, 0xbf, 0xf7, 0x02, 0x11, 0x01, 0x00, 0x91,
+   0x00, 0xff, 0xff, 0xaf, 0x55, 0x55, 0x5b, 0xeb, 0xef, 0x22, 0x04, 0x04,
+   0x04, 0x00, 0xa4, 0xff, 0xf7, 0xad, 0xaa, 0xaa, 0xaa, 0xbe, 0xfe, 0x03,
+   0x20, 0x00, 0x10, 0x44, 0x80, 0xff, 0x7f, 0x55, 0x12, 0x91, 0x2a, 0xeb,
+   0xbf, 0x0b, 0x82, 0x02, 0x00, 0x00, 0xd1, 0x7f, 0xdf, 0xa2, 0xa4, 0x54,
+   0x55, 0xfd, 0xfd, 0x47, 0x08, 0x08, 0x00, 0x21, 0xe4, 0xff, 0x37, 0x11,
+   0x09, 0xa5, 0xaa, 0xb6, 0xff, 0x0d, 0x80, 0x00, 0x00, 0x04, 0xd0, 0xff,
+   0x4f, 0x44, 0x20, 0x48, 0x55, 0xfb, 0xff, 0x27, 0x11, 0x02, 0x40, 0x40,
+   0xe2, 0xfb, 0x15, 0x11, 0x4a, 0x55, 0x4a, 0x7d, 0xf7, 0x0f, 0x00, 0x00,
+   0x04, 0x08, 0xf8, 0xdf, 0x52, 0x44, 0x01, 0x52, 0xb5, 0xfa, 0xff, 0x0f,
+   0x49, 0x02, 0x00, 0x02, 0xe9, 0xf6, 0x0a, 0x11, 0xa4, 0x88, 0x4a, 0x6d,
+   0xff, 0x5f, 0x00, 0x00, 0x10, 0x20, 0xf0, 0x2f, 0x21, 0x44, 0x10, 0x52,
+   0xb5, 0xfa, 0xff, 0x0f, 0x44, 0x04, 0x80, 0x08, 0xf8, 0xab, 0x8a, 0x00,
+   0x81, 0xa4, 0xd4, 0xd6, 0xfe, 0x2f, 0x00, 0x00, 0x04, 0x40, 0xb5, 0x2d,
+   0x21, 0x08, 0x04, 0x90, 0xaa, 0xfa, 0xff, 0x1f, 0x11, 0x01, 0x00, 0x04,
+   0xf0, 0x57, 0x0a, 0x22, 0x40, 0x4a, 0xda, 0x5e, 0xfb, 0x1f, 0x40, 0x00,
+   0x40, 0x20, 0xba, 0x95, 0x90, 0x00, 0x01, 0xa0, 0xaa, 0xea, 0xff, 0x5f,
+   0x02, 0x02, 0x00, 0x01, 0xe8, 0x57, 0x05, 0x00, 0x00, 0x12, 0xd5, 0xfe,
+   0xfd, 0x1f, 0x48, 0x00, 0x04, 0x48, 0x7a, 0x95, 0x08, 0x02, 0x10, 0x40,
+   0xaa, 0x55, 0xf7, 0x1f, 0x00, 0x09, 0x20, 0x00, 0xf8, 0x57, 0x22, 0x10,
+   0x00, 0x28, 0xa9, 0xfa, 0xff, 0x5f, 0x02, 0x00, 0x00, 0x49, 0xdd, 0x29,
+   0x01, 0x00, 0x80, 0x80, 0xaa, 0xd7, 0xff, 0x0f, 0x10, 0x00, 0x08, 0x00,
+   0xf8, 0x96, 0x08, 0x00, 0x00, 0x20, 0x54, 0xfa, 0xee, 0x3f, 0x81, 0x04,
+   0x40, 0x24, 0xfe, 0x55, 0x82, 0x00, 0x00, 0x82, 0xd2, 0xad, 0xff, 0x0f,
+   0x08, 0x00, 0x04, 0x80, 0x6c, 0x97, 0x00, 0x00, 0x02, 0x20, 0xa9, 0xf6,
+   0xdf, 0x5f, 0x00, 0x02, 0x20, 0x09, 0xfa, 0x49, 0x12, 0x00, 0x20, 0x84,
+   0x54, 0xdb, 0xfe, 0x1f, 0x91, 0x00, 0x00, 0x00, 0xf8, 0x2b, 0x00, 0x20,
+   0x00, 0x40, 0xa4, 0xf6, 0xbb, 0x1f, 0x04, 0x00, 0x44, 0x92, 0x7e, 0x95,
+   0x02, 0x00, 0x00, 0x89, 0xaa, 0xdd, 0xff, 0x1f, 0x20, 0x09, 0x10, 0x00,
+   0xf4, 0x57, 0x20, 0x01, 0x08, 0x20, 0xa9, 0x76, 0xff, 0x5f, 0x02, 0x00,
+   0x00, 0x21, 0xfc, 0x4a, 0x05, 0x00, 0x01, 0x80, 0x54, 0xdb, 0xff, 0x1e,
+   0x08, 0x02, 0x04, 0x08, 0xf9, 0x2b, 0x00, 0x00, 0x40, 0x28, 0xd2, 0xf6,
+   0xff, 0xbf, 0x80, 0x00, 0x90, 0x00, 0xbc, 0x92, 0x08, 0x10, 0x00, 0x82,
+   0x54, 0xdb, 0xff, 0x1f, 0x20, 0x00, 0x00, 0x44, 0xf9, 0x55, 0x02, 0x01,
+   0x00, 0x20, 0xaa, 0xbd, 0xfd, 0x3f, 0x08, 0x04, 0x04, 0x10, 0xf4, 0x2a,
+   0x01, 0x00, 0x22, 0x80, 0xd4, 0xf6, 0xff, 0x5f, 0x82, 0x00, 0x40, 0x02,
+   0xf8, 0x55, 0x20, 0x00, 0x00, 0x50, 0x6a, 0xdf, 0xfe, 0x3f, 0x00, 0x00,
+   0x00, 0x48, 0xe9, 0x4a, 0x05, 0x08, 0x00, 0xa5, 0xd5, 0xf5, 0xff, 0x3f,
+   0x10, 0x01, 0x10, 0x01, 0xb0, 0xab, 0x92, 0x02, 0x40, 0xf8, 0xbf, 0xde,
+   0xfe, 0x5f, 0x02, 0x04, 0x04, 0x48, 0xfa, 0xd4, 0x6f, 0x20, 0x84, 0xef,
+   0xff, 0xfb, 0xff, 0x1f, 0x20, 0x00, 0x00, 0x00, 0xe0, 0xed, 0xbf, 0x0b,
+   0xa1, 0x7e, 0xff, 0xbf, 0xfd, 0x5f, 0x04, 0x01, 0x20, 0x49, 0xd2, 0xfb,
+   0xfe, 0x55, 0xd4, 0xff, 0xff, 0xf6, 0xff, 0x07, 0x00, 0x04, 0x00, 0x00,
+   0xc0, 0xaa, 0xfb, 0x2b, 0xa2, 0xfe, 0xff, 0xdf, 0xee, 0x1f, 0x91, 0x00,
+   0x82, 0xa4, 0xa4, 0xf5, 0xff, 0x57, 0xd5, 0xff, 0xbf, 0xfd, 0xff, 0x4d,
+   0x00, 0x00, 0x20, 0x00, 0x88, 0x5b, 0xff, 0x2f, 0x69, 0xff, 0xff, 0xdb,
+   0xfe, 0x1f, 0x24, 0x02, 0x00, 0x49, 0xa2, 0xd6, 0xff, 0x5f, 0xea, 0xff,
+   0x7f, 0x7f, 0x7f, 0x0d, 0x00, 0x00, 0x10, 0x00, 0x40, 0xab, 0xf7, 0xbb,
+   0xf0, 0xdf, 0xff, 0xd5, 0xff, 0xbf, 0x82, 0x04, 0x42, 0x24, 0x91, 0xd5,
+   0xaa, 0xae, 0xd4, 0xaa, 0x52, 0x7b, 0xff, 0x15, 0x08, 0x00, 0x00, 0x01,
+   0x04, 0x55, 0xd5, 0x55, 0x70, 0x5b, 0x75, 0xdd, 0xdf, 0x1f, 0x40, 0x00,
+   0x08, 0x48, 0xa0, 0x4a, 0xa9, 0x56, 0xea, 0x56, 0xad, 0x6a, 0x7d, 0x9b,
+   0x04, 0x01, 0x00, 0x02, 0x42, 0x2a, 0xd5, 0xaa, 0xa8, 0xaa, 0xaa, 0xfa,
+   0xdf, 0x2f, 0x10, 0x04, 0x22, 0x48, 0x08, 0x45, 0x2a, 0x15, 0x68, 0x55,
+   0x55, 0xd7, 0x76, 0x1b, 0x00, 0x00, 0x00, 0x01, 0x40, 0x2a, 0x80, 0xa0,
+   0xb2, 0x09, 0x48, 0xb9, 0xdf, 0x17, 0x22, 0x01, 0x00, 0x24, 0x45, 0x8a,
+   0x24, 0x4a, 0x54, 0x51, 0x91, 0xf6, 0x6e, 0x4b, 0x00, 0x04, 0x90, 0x00,
+   0x80, 0x52, 0x00, 0x20, 0x69, 0x05, 0xa4, 0xaa, 0xff, 0x1e, 0x48, 0x00,
+   0x02, 0x92, 0x08, 0x05, 0x81, 0x94, 0xd4, 0x92, 0x40, 0xfd, 0xb6, 0x8b,
+   0x00, 0x01, 0x40, 0x00, 0x82, 0x54, 0x00, 0x48, 0x68, 0x05, 0x90, 0xa4,
+   0xef, 0x06, 0x24, 0x00, 0x08, 0x12, 0x10, 0x05, 0x00, 0x10, 0xb5, 0x01,
+   0x42, 0xfb, 0xbf, 0x43, 0x00, 0x09, 0x00, 0x40, 0x81, 0xa8, 0x08, 0x4a,
+   0xaa, 0x96, 0x90, 0xac, 0x6d, 0x15, 0x22, 0x00, 0x20, 0x09, 0x04, 0x15,
+   0x80, 0x28, 0xdc, 0x01, 0x24, 0xfb, 0xbf, 0x01, 0x80, 0x04, 0x09, 0x00,
+   0x40, 0x48, 0x02, 0x45, 0xb2, 0x2e, 0x41, 0x6d, 0xef, 0x05, 0x11, 0x00,
+   0x40, 0x52, 0x02, 0x15, 0x29, 0x2a, 0xac, 0x42, 0x54, 0xfb, 0x3b, 0x51,
+   0x84, 0x00, 0x08, 0x00, 0x20, 0x54, 0x80, 0x05, 0xb5, 0x3d, 0xa2, 0xb6,
+   0xdf, 0x00, 0x20, 0x04, 0x20, 0x49, 0x89, 0xa8, 0x6a, 0x29, 0xac, 0xd6,
+   0x54, 0xff, 0x3f, 0x84, 0x00, 0x01, 0x04, 0x10, 0x00, 0x94, 0xa8, 0x56,
+   0xda, 0x5f, 0xab, 0xd5, 0x1e, 0x10, 0x48, 0x00, 0x90, 0x82, 0x48, 0xa8,
+   0xb2, 0xac, 0xfd, 0x55, 0xd5, 0xfe, 0x9f, 0x80, 0x00, 0x0a, 0x02, 0x08,
+   0x02, 0x55, 0x5a, 0x75, 0xff, 0xaf, 0xb6, 0xf7, 0x2d, 0x12, 0x92, 0x00,
+   0x10, 0x20, 0x10, 0xa8, 0x54, 0xd5, 0xbf, 0x5d, 0xad, 0xdd, 0x0f, 0x00,
+   0x00, 0x04, 0x40, 0x09, 0x84, 0xa8, 0xaa, 0x5a, 0xed, 0xeb, 0x6a, 0xff,
+   0x9f, 0xa4, 0x24, 0x01, 0x02, 0xa0, 0x20, 0x50, 0x55, 0xd5, 0xbe, 0xae,
+   0xad, 0xfd, 0x16, 0x00, 0x10, 0x04, 0x20, 0x0a, 0x08, 0xb4, 0xaa, 0x95,
+   0xaa, 0x7b, 0xb7, 0xdb, 0x5f, 0x92, 0x04, 0x01, 0x84, 0x20, 0x21, 0x51,
+   0xd5, 0x2a, 0xa9, 0xee, 0xd5, 0xfe, 0x0d, 0x00, 0x20, 0x04, 0x10, 0x00,
+   0x08, 0x50, 0xe9, 0xd7, 0xd4, 0xfb, 0xb5, 0xff, 0x9f, 0x24, 0x09, 0x01,
+   0x42, 0x4a, 0xa2, 0x64, 0xd5, 0x55, 0x7b, 0x7f, 0xda, 0x7d, 0x4f, 0x00,
+   0x20, 0x04, 0x00, 0x80, 0x00, 0xa0, 0x2a, 0x13, 0x84, 0x6a, 0x55, 0xff,
+   0x1d, 0x48, 0x8a, 0x00, 0x94, 0x24, 0x8a, 0xc8, 0xaa, 0x42, 0x20, 0x5d,
+   0xf5, 0xff, 0x5f, 0x01, 0x00, 0x02, 0x01, 0x00, 0x20, 0xa2, 0x4a, 0x1a,
+   0x82, 0x56, 0xda, 0xbd, 0x3f, 0x92, 0x92, 0x00, 0x90, 0x92, 0x00, 0x40,
+   0x95, 0x6a, 0xf4, 0x55, 0x6d, 0xff, 0xd6, 0x00, 0x00, 0x0a, 0x04, 0x20,
+   0x14, 0x49, 0x4b, 0xaa, 0xaa, 0x56, 0xf5, 0xff, 0xbf, 0xab, 0xa4, 0x00,
+   0x20, 0x89, 0x40, 0x80, 0xaa, 0xaa, 0xaa, 0xaa, 0xde, 0xbf, 0xeb, 0x03,
+   0x00, 0x02, 0x04, 0x02, 0x0a, 0x10, 0x2b, 0x2a, 0x55, 0x5b, 0xf5, 0xff,
+   0xd7, 0x2f, 0x92, 0x00, 0x10, 0x28, 0x21, 0x01, 0x56, 0x95, 0xa0, 0x56,
+   0xdf, 0xef, 0xea, 0x87, 0x40, 0x0a, 0x42, 0x41, 0x00, 0x90, 0xaa, 0x52,
+   0xb6, 0xad, 0xfa, 0xff, 0xd5, 0x2f, 0x14, 0x00, 0x00, 0x04, 0x95, 0x04,
+   0xaa, 0xac, 0x55, 0x6b, 0xff, 0xb7, 0xea, 0x9f, 0x40, 0x02, 0x28, 0x51,
+   0x00, 0x40, 0x58, 0xd5, 0xda, 0xd6, 0x6e, 0x7f, 0xf9, 0x3f, 0x12, 0x04,
+   0x02, 0x04, 0x49, 0x25, 0x55, 0xaa, 0x77, 0xab, 0xff, 0x2b, 0xfd, 0x3f,
+   0x48, 0x01, 0x20, 0x41, 0x00, 0x00, 0x58, 0xa9, 0xda, 0xea, 0xfd, 0xaf,
+   0xfa, 0xff, 0x02, 0x04, 0x08, 0x14, 0x29, 0x49, 0x52, 0x55, 0x55, 0x55,
+   0xff, 0x8d, 0xfe, 0x3f, 0xa8, 0x00, 0x02, 0x41, 0x00, 0x02, 0xa0, 0xa2,
+   0xaa, 0xea, 0xff, 0x53, 0xfd, 0xff, 0x02, 0x04, 0x50, 0x04, 0x25, 0xa8,
+   0x54, 0x49, 0x52, 0xb5, 0xbf, 0x8a, 0xfe, 0xff, 0xa9, 0x08, 0x04, 0x50,
+   0x80, 0x02, 0xa1, 0x2a, 0x95, 0xea, 0xff, 0xa1, 0xff, 0xff, 0x03, 0x02,
+   0x90, 0x02, 0x09, 0x08, 0x44, 0x49, 0x52, 0xbd, 0x7f, 0xca, 0xff, 0xff,
+   0x2b, 0x09, 0x04, 0x48, 0x40, 0x82, 0x90, 0x56, 0xa9, 0xf6, 0xbf, 0xd0,
+   0xff, 0xff, 0x47, 0x00, 0x50, 0x02, 0x15, 0x11, 0x40, 0x95, 0xaa, 0xfd,
+   0x2f, 0xe9, 0xff, 0xff, 0x8f, 0x0a, 0x84, 0x50, 0x40, 0x84, 0x14, 0xaa,
+   0x6a, 0xff, 0x5f, 0xf2, 0xff, 0xff, 0x7f, 0x00, 0x10, 0x02, 0x09, 0x10,
+   0x40, 0x7d, 0xf7, 0xff, 0x0b, 0xfc, 0xff, 0xff, 0xaf, 0x02, 0x84, 0x50,
+   0x42, 0x85, 0x12, 0xd0, 0xdd, 0xff, 0xa7, 0xf2, 0xff, 0xff, 0xff, 0x04,
+   0x00, 0x0a, 0x08, 0x10, 0x48, 0xf8, 0xff, 0xff, 0x0a, 0xfe, 0xff, 0xff,
+   0x7f, 0x03, 0xa4, 0x80, 0xa2, 0x8a, 0x02, 0x68, 0xff, 0xff, 0x52, 0xfd,
+   0xff, 0xff, 0xff, 0x07, 0x00, 0x2a, 0x08, 0x20, 0x28, 0xdc, 0xff, 0x5f,
+   0x05, 0xff, 0xff, 0xff, 0xff, 0x0d, 0x92, 0x40, 0x22, 0x09, 0x02, 0xea,
+   0xfb, 0xaf, 0x48, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x12, 0x81, 0xa0,
+   0x48, 0x9c, 0x6e, 0x93, 0xa2, 0xff, 0xff, 0xff, 0xff, 0x07, 0xa8, 0x40,
+   0x28, 0x0a, 0x02, 0x74, 0xb5, 0x45, 0x81, 0xff, 0xff, 0xff, 0xff, 0x0f,
+   0x02, 0x0a, 0x81, 0x20, 0x08, 0xae, 0xaa, 0x90, 0xe8, 0xff, 0xff, 0xff,
+   0xff, 0x0f, 0x90, 0x40, 0x28, 0x88, 0x12, 0x58, 0x15, 0x50, 0xd0, 0xff,
+   0xff, 0xff, 0xff, 0x0f, 0x44, 0x0a, 0x41, 0x21, 0x08, 0xae, 0x04, 0x14,
+   0xf0, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x10, 0x40, 0x14, 0x88, 0x04, 0xba,
+   0x02, 0x28, 0xe8, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x42, 0x15, 0x41, 0x21,
+   0x05, 0xad, 0x00, 0x05, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x10, 0x40,
+   0x24, 0x8a, 0x0e, 0x36, 0x00, 0x0a, 0xf4, 0xff, 0xff, 0xff, 0xff, 0x0f,
+   0x42, 0x25, 0x90, 0xd0, 0x8b, 0xc2, 0x41, 0x05, 0xfc, 0xff, 0xff, 0xff,
+   0xff, 0x0f, 0x10, 0x08, 0x05, 0xe8, 0x8e, 0x58, 0x80, 0x02, 0xfa, 0xff,
+   0xff, 0xff, 0xff, 0x0f, 0x4a, 0x20, 0xa8, 0xba, 0x0b, 0x2b, 0x51, 0x01,
+   0xfe, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x8a, 0x02, 0xe8, 0xaf, 0x84,
+   0x90, 0x04, 0xfd, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x52, 0x21, 0x54, 0xbf,
+   0x1f, 0x15, 0xa5, 0x02, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x08,
+   0x01, 0xfa, 0xb6, 0xa4, 0x52, 0x40, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f,
+   0x4a, 0xa2, 0x54, 0xef, 0x5f, 0x4b, 0xa4, 0x80, 0xff, 0xff, 0xff, 0xff,
+   0xff, 0x0f, 0x80, 0x10, 0x82, 0xfe, 0xbf, 0x92, 0x52, 0x42, 0xff, 0xff,
+   0xff, 0xff, 0xff, 0x0f, 0x12, 0x42, 0xa8, 0xbf, 0x1f, 0x24, 0x80, 0xa0,
+   0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x84, 0x28, 0x8a, 0xf7, 0x37, 0x80,
+   0x52, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x10, 0x82, 0xe0, 0xff,
+   0x1f, 0x00, 0x20, 0xe1, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x84, 0x28,
+   0xca, 0xff, 0x1f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f,
+   0x10, 0x42, 0xf0, 0xfd, 0x1b, 0x00, 0x50, 0xf0, 0xff, 0xff, 0xff, 0xff,
+   0xff, 0x0f, 0xa4, 0x10, 0xc5, 0xff, 0x1f, 0x00, 0x00, 0xe0, 0xff, 0xff,
+   0xff, 0xff, 0xff, 0x0f, 0x00, 0x22, 0xf8, 0xff, 0x0e, 0x00, 0x00, 0xf0,
+   0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xaa, 0x88, 0xe2, 0xff, 0x0f, 0x10,
+   0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x25, 0xfa, 0xff,
+   0x0f, 0x01, 0x11, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xfb,
+   0xfb, 0xff, 0x7f, 0x5d, 0xd5, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f};

ext/tk/sample/images/flagdown.xbm

@@ -0,0 +1,27 @@
+#define flagdown_width 48
+#define flagdown_height 48
+static char flagdown_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00,
+   0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xe1, 0x00, 0x00,
+   0x00, 0x00, 0x70, 0x80, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x03, 0x00,
+   0x00, 0x00, 0x0c, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x04,
+   0x00, 0x00, 0x03, 0x00, 0x06, 0x06, 0x00, 0x80, 0x01, 0x00, 0x06, 0x07,
+   0x00, 0xc0, 0x1f, 0x00, 0x87, 0x07, 0x00, 0xe0, 0x7f, 0x80, 0xc7, 0x07,
+   0x00, 0x70, 0xe0, 0xc0, 0xe5, 0x07, 0x00, 0x38, 0x80, 0xe1, 0x74, 0x07,
+   0x00, 0x18, 0x80, 0x71, 0x3c, 0x07, 0x00, 0x0c, 0x00, 0x3b, 0x1e, 0x03,
+   0x00, 0x0c, 0x00, 0x1f, 0x0f, 0x00, 0x00, 0x86, 0x1f, 0x8e, 0x07, 0x00,
+   0x00, 0x06, 0x06, 0xc6, 0x05, 0x00, 0x00, 0x06, 0x00, 0xc6, 0x05, 0x00,
+   0x00, 0x06, 0x00, 0xc6, 0x04, 0x00, 0x00, 0x06, 0x00, 0x06, 0x04, 0x00,
+   0x7f, 0x06, 0x00, 0x06, 0xe4, 0xff, 0x00, 0x06, 0x00, 0x06, 0x04, 0x00,
+   0x00, 0x06, 0x00, 0x06, 0x04, 0x00, 0x00, 0x06, 0x00, 0x06, 0x06, 0x00,
+   0x00, 0x06, 0x00, 0x06, 0x03, 0x00, 0x00, 0x06, 0x00, 0x86, 0x01, 0x00,
+   0x00, 0x06, 0x00, 0xc6, 0x00, 0x00, 0x00, 0x06, 0x00, 0x66, 0x00, 0x00,
+   0x00, 0x06, 0x00, 0x36, 0x00, 0x00, 0x00, 0x06, 0x00, 0x3e, 0x00, 0x00,
+   0x00, 0xfe, 0xff, 0x2f, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x27, 0x00, 0x00,
+   0x00, 0x00, 0x88, 0x20, 0x00, 0x00, 0x00, 0x00, 0x88, 0x20, 0x00, 0x00,
+   0x00, 0x00, 0x88, 0x20, 0x00, 0x00, 0x00, 0x00, 0x88, 0x20, 0x00, 0x00,
+   0x00, 0x00, 0x88, 0x20, 0x00, 0x00, 0x00, 0x00, 0x88, 0x20, 0x00, 0x00,
+   0x00, 0x00, 0x88, 0x20, 0x00, 0x00, 0x00, 0x00, 0x88, 0x20, 0x00, 0x00,
+   0xf7, 0xbf, 0x8e, 0xfc, 0xdf, 0xf8, 0x9d, 0xeb, 0x9b, 0x76, 0xd2, 0x7a,
+   0x46, 0x30, 0xe2, 0x0f, 0xe1, 0x47, 0x55, 0x84, 0x48, 0x11, 0x84, 0x19};

ext/tk/sample/images/flagup.xbm

@@ -0,0 +1,27 @@
+#define flagup_width 48
+#define flagup_height 48
+static char flagup_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00,
+   0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xef, 0x6a, 0x00,
+   0x00, 0x00, 0xc0, 0x7b, 0x75, 0x00, 0x00, 0x00, 0xe0, 0xe0, 0x6a, 0x00,
+   0x00, 0x00, 0x30, 0x60, 0x75, 0x00, 0x00, 0x00, 0x18, 0xe0, 0x7f, 0x00,
+   0x00, 0x00, 0x0c, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x06, 0xe0, 0x04, 0x00,
+   0x00, 0x00, 0x03, 0xe0, 0x04, 0x00, 0x00, 0x80, 0x01, 0xe0, 0x06, 0x00,
+   0x00, 0xc0, 0x1f, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x7f, 0xe0, 0x07, 0x00,
+   0x00, 0x70, 0xe0, 0xe0, 0x05, 0x00, 0x00, 0x38, 0x80, 0xe1, 0x04, 0x00,
+   0x00, 0x18, 0x80, 0xf1, 0x04, 0x00, 0x00, 0x0c, 0x00, 0xfb, 0x04, 0x00,
+   0x00, 0x0c, 0x00, 0xff, 0x04, 0x00, 0x00, 0x86, 0x1f, 0xee, 0x04, 0x00,
+   0x00, 0x06, 0x06, 0xe6, 0x04, 0x00, 0x00, 0x06, 0x00, 0xe6, 0x04, 0x00,
+   0x00, 0x06, 0x00, 0xe6, 0x04, 0x00, 0x00, 0x06, 0x00, 0x66, 0x04, 0x00,
+   0x7f, 0x56, 0x52, 0x06, 0xe4, 0xff, 0x00, 0x76, 0x55, 0x06, 0x04, 0x00,
+   0x00, 0x56, 0x57, 0x06, 0x04, 0x00, 0x00, 0x56, 0x55, 0x06, 0x06, 0x00,
+   0x00, 0x56, 0xd5, 0x06, 0x03, 0x00, 0x00, 0x06, 0x00, 0x86, 0x01, 0x00,
+   0x54, 0x06, 0x00, 0xc6, 0x54, 0x55, 0xaa, 0x06, 0x00, 0x66, 0xaa, 0x2a,
+   0x54, 0x06, 0x00, 0x36, 0x55, 0x55, 0xaa, 0x06, 0x00, 0xbe, 0xaa, 0x2a,
+   0x54, 0xfe, 0xff, 0x6f, 0x55, 0x55, 0xaa, 0xfc, 0xff, 0xa7, 0xaa, 0x2a,
+   0x54, 0x01, 0x88, 0x60, 0x55, 0x55, 0xaa, 0xaa, 0x8a, 0xa0, 0xaa, 0x2a,
+   0x54, 0x55, 0x8d, 0x60, 0x55, 0x55, 0xaa, 0xaa, 0x8a, 0xa0, 0xaa, 0x2a,
+   0x54, 0x55, 0x8d, 0x60, 0x55, 0x55, 0xaa, 0xaa, 0x8a, 0xa0, 0xaa, 0x2a,
+   0x54, 0x55, 0x8d, 0x50, 0x55, 0x55, 0xaa, 0xaa, 0x8a, 0xa8, 0xaa, 0x2a,
+   0x54, 0x55, 0x95, 0x54, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x2a,
+   0x54, 0x55, 0x55, 0x55, 0x55, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

ext/tk/sample/images/gray25.xbm

@@ -0,0 +1,6 @@
+#define grey_width 16
+#define grey_height 16
+static char grey_bits[] = {
+   0x11, 0x11, 0x44, 0x44, 0x11, 0x11, 0x44, 0x44, 0x11, 0x11, 0x44, 0x44,
+   0x11, 0x11, 0x44, 0x44, 0x11, 0x11, 0x44, 0x44, 0x11, 0x11, 0x44, 0x44,
+   0x11, 0x11, 0x44, 0x44, 0x11, 0x11, 0x44, 0x44};

ext/tk/sample/images/grey.25

@@ -0,0 +1,6 @@
+#define grey_width 16
+#define grey_height 16
+static char grey_bits[] = {
+   0x11, 0x11, 0x44, 0x44, 0x11, 0x11, 0x44, 0x44, 0x11, 0x11, 0x44, 0x44,
+   0x11, 0x11, 0x44, 0x44, 0x11, 0x11, 0x44, 0x44, 0x11, 0x11, 0x44, 0x44,
+   0x11, 0x11, 0x44, 0x44, 0x11, 0x11, 0x44, 0x44};

ext/tk/sample/images/grey.5

@@ -0,0 +1,6 @@
+#define grey_width 16
+#define grey_height 16
+static char grey_bits[] = {
+   0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa,
+   0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa,
+   0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa};

ext/tk/sample/images/letters.xbm

@@ -0,0 +1,27 @@
+#define letters_width 48
+#define letters_height 48
+static char letters_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x02, 0x00, 0x00, 0x00, 0x20,
+   0x00, 0xfa, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x02, 0x00, 0x00, 0x00, 0x2a,
+   0x00, 0x3a, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x02, 0x00, 0x00, 0x00, 0x2e,
+   0xe0, 0xff, 0xff, 0xff, 0xff, 0x21, 0x20, 0x00, 0x00, 0x00, 0x00, 0x21,
+   0xa0, 0x03, 0x00, 0x00, 0x70, 0x21, 0x20, 0x00, 0x00, 0x00, 0x50, 0x21,
+   0xa0, 0x1f, 0x00, 0x00, 0x50, 0x21, 0x20, 0x00, 0x00, 0x00, 0x70, 0x21,
+   0xfe, 0xff, 0xff, 0xff, 0x0f, 0x21, 0x02, 0x00, 0x00, 0x00, 0x08, 0x21,
+   0xfa, 0x01, 0x00, 0x80, 0x0b, 0x21, 0x02, 0x00, 0x00, 0x80, 0x0a, 0x21,
+   0xba, 0x01, 0x00, 0x80, 0x0a, 0x21, 0x02, 0x00, 0x00, 0x80, 0x0b, 0x21,
+   0x3a, 0x00, 0x00, 0x00, 0x08, 0x21, 0x02, 0x00, 0x00, 0x00, 0x08, 0x21,
+   0x02, 0xc0, 0xfb, 0x03, 0x08, 0x21, 0x02, 0x00, 0x00, 0x00, 0x08, 0x3f,
+   0x02, 0xc0, 0xbd, 0x0f, 0x08, 0x01, 0x02, 0x00, 0x00, 0x00, 0x08, 0x01,
+   0x02, 0xc0, 0x7f, 0x7b, 0x08, 0x01, 0x02, 0x00, 0x00, 0x00, 0x08, 0x01,
+   0x02, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00,
+   0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00,
+   0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00,
+   0xfe, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

ext/tk/sample/images/noletter.xbm

@@ -0,0 +1,27 @@
+#define noletters_width 48
+#define noletters_height 48
+static char noletters_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x1f, 0x00, 0x00,
+   0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x07, 0x00,
+   0x00, 0xf0, 0x0f, 0xe0, 0x1f, 0x00, 0x00, 0xfc, 0x01, 0x00, 0x7f, 0x00,
+   0x00, 0x3e, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x1f, 0x00, 0x00, 0xf0, 0x01,
+   0x80, 0x07, 0x00, 0x00, 0xc0, 0x03, 0xc0, 0x03, 0x00, 0x00, 0xe0, 0x07,
+   0xe0, 0x01, 0x00, 0x00, 0xf0, 0x0f, 0xe0, 0x00, 0x00, 0x00, 0x78, 0x0e,
+   0xf0, 0x00, 0x00, 0x00, 0x3c, 0x1e, 0x70, 0x00, 0x00, 0x00, 0x1e, 0x1c,
+   0x38, 0x00, 0x00, 0x00, 0x0f, 0x38, 0x38, 0x00, 0x00, 0x80, 0x07, 0x38,
+   0x3c, 0xfc, 0xff, 0xff, 0x7f, 0x78, 0x1c, 0x04, 0x00, 0xe0, 0x41, 0x70,
+   0x1c, 0x04, 0x00, 0xf0, 0x40, 0x70, 0x1c, 0x74, 0x00, 0x78, 0x4e, 0x70,
+   0x0e, 0x04, 0x00, 0x3c, 0x4a, 0xe0, 0x0e, 0x74, 0x03, 0x1e, 0x4a, 0xe0,
+   0x0e, 0x04, 0x00, 0x0f, 0x4e, 0xe0, 0x0e, 0x04, 0x80, 0x07, 0x40, 0xe0,
+   0x0e, 0x04, 0xf8, 0x0f, 0x40, 0xe0, 0x0e, 0x04, 0xe0, 0x01, 0x40, 0xe0,
+   0x0e, 0x04, 0xf8, 0x00, 0x40, 0xe0, 0x0e, 0x04, 0x78, 0x00, 0x40, 0xe0,
+   0x0e, 0x04, 0xfc, 0xf3, 0x40, 0xe0, 0x1c, 0x04, 0x1e, 0x00, 0x40, 0x70,
+   0x1c, 0x04, 0x0f, 0x00, 0x40, 0x70, 0x1c, 0x84, 0x07, 0x00, 0x40, 0x70,
+   0x3c, 0xfc, 0xff, 0xff, 0x7f, 0x78, 0x38, 0xe0, 0x01, 0x00, 0x00, 0x38,
+   0x38, 0xf0, 0x00, 0x00, 0x00, 0x38, 0x70, 0x78, 0x00, 0x00, 0x00, 0x1c,
+   0xf0, 0x3c, 0x00, 0x00, 0x00, 0x1e, 0xe0, 0x1e, 0x00, 0x00, 0x00, 0x0e,
+   0xe0, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0xc0, 0x07, 0x00, 0x00, 0x80, 0x07,
+   0x80, 0x07, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x1f, 0x00, 0x00, 0xf0, 0x01,
+   0x00, 0x3e, 0x00, 0x00, 0xf8, 0x00, 0x00, 0xfc, 0x01, 0x00, 0x7f, 0x00,
+   0x00, 0xf0, 0x0f, 0xe0, 0x1f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x07, 0x00,
+   0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0xf0, 0x1f, 0x00, 0x00};

ext/tk/sample/images/pattern.xbm

@@ -0,0 +1,6 @@
+#define foo_width 16
+#define foo_height 16
+static char foo_bits[] = {
+   0x60, 0x06, 0x90, 0x09, 0x90, 0x09, 0xb0, 0x0d, 0x4e, 0x72, 0x49, 0x92,
+   0x71, 0x8e, 0x8e, 0x71, 0x8e, 0x71, 0x71, 0x8e, 0x49, 0x92, 0x4e, 0x72,
+   0xb0, 0x0d, 0x90, 0x09, 0x90, 0x09, 0x60, 0x06};

ext/tk/sample/iso2022-kr.txt

@@ -0,0 +1,2 @@
+Sample text:
+$)C  Hangul (GQ1[)	>H3gGO<<?d, >H3gGO=J4O1n

ext/tk/sample/msgs_rb/README

@@ -0,0 +1,3 @@
+Message catalogs in this directory depend on Tcl/Tk's message catalogs. 
+Texts of each locale are copied from Tcl/Tk8.5a1 widget demos.
+Please refer '../msgs_tk/README'. 

ext/tk/sample/msgs_rb/cs.msg

@@ -0,0 +1,84 @@
+TkMsgCatalog.new('::tkmsgcat_demo') {
+    cs "Application Error", "Chyba programu"
+    cs "Blue", "Modr\341"
+    cs "Color", "Barva"
+    cs "Delete", "Smazat"
+    cs "Error", "Chyba"
+    cs "Exit", "Konec"
+    cs "Green", "Zelen\341"
+    cs "Red", "\\u010cerven\341"
+    cs "blue", "modr\341"
+    cs "green", "zelen\341"
+    cs "red", "\\u010derven\341"
+}
+
+TkMsgCatalog.new('::tk') {
+    cs "&Abort", "&P\\u0159eru\\u0161it"
+    cs "About...", "O programu..."
+    cs "All Files", "V\\u0161echny soubory"
+    cs "Application Error", "Chyba programu"
+    cs "&Blue", "&Modr\341"
+    cs "&Cancel", "&Zru\\u0161it"
+    cs "Cannot change to the directory \"%1\$s\".\nPermission denied.", "Nemohu zm\\u011bnit atku\341ln\355 adres\341\\u0159 na \"%1\$s\".\nP\\u0159\355stup odm\355tnut."
+    cs "Choose Directory", "V\375b\\u011br adres\341\\u0159e"
+    cs "Clear", "Smazat"
+    cs "Color", "Barva"
+    cs "Console", "Konzole"
+    cs "Copy", "Kop\355rovat"
+    cs "Cut", "Vy\\u0159\355znout"
+    cs "Delete", "Smazat"
+    cs "Details >>", "Detaily >>"
+    cs "Directory \"%1\$s\" does not exist.", "Adres\341\\u0159 \"%1\$s\" neexistuje."
+    cs "&Directory:", "&Adres\341\\u0159:"
+    cs "Error: %1\$s", "Chyba: %1\$s"
+    cs "Exit", "Konec"
+    cs "File \"%1\$s\" already exists.\n\n", "Soubor \"%1\$s\" ji\\u017e existuje.\n\n"
+    cs "File \"%1\$s\" already exists.\nDo you want to overwrite it?", "Soubor \"%1\$s\" ji\\u017e existuje.\nChcete jej p\\u0159epsat?"
+    cs "File \"%1\$s\" does not exist.", "Soubor \"%1\$s\" neexistuje."
+    cs "File &name:", "&Jm\351no souboru:"
+    cs "File &names:", "&Jm\351na soubor\\u016f:"
+    cs "Files of &type:", "&Typy soubor\\u016f:"
+    cs "Fi&les:", "Sou&bory:"
+    cs "&Filter", "&Filtr"
+    cs "Fil&ter:", "Fil&tr:"
+    cs "&Green", "Ze&len\341"
+    cs "Hi"
+    cs "Hide Console", "Skr\375t konsolu"
+    cs "&Ignore", "&Ignorovat"
+    cs "Invalid file name \"%1\$s\".", "\\u0160patn\351 jm\351no souboru \"%1\$s\"."
+    cs "Log Files", "Log soubory"
+    cs "&No", "&Ne"
+    cs "&OK"
+    cs "Ok"
+    cs "Open", "Otev\\u0159\355t"
+    cs "&Open", "&Otev\\u0159\355t"
+    cs "Open Multiple Files", "Otev\\u0159\355t v\355ce soubor\\u016f"
+    cs "Paste", "Vlo\\u017eit"
+    cs "Quit", "Skon\\u010dit"
+    cs "&Red", " \\u010ce&rven\341"
+    cs "Replace existing file?", "Nahradit st\341vaj\355c\355 soubor?"
+    cs "&Retry", "Z&novu"
+    cs "&Save", "&Ulo\\u017eit"
+    cs "Save As", "Ulo\\u017eit jako"
+    cs "Save To Log", "Ulo\\u017eit do logu"
+    cs "Select Log File", "Vybrat log soubor"
+    cs "Select a file to source", "Vybrat soubor k nahr\341n\355"
+    cs "&Selection:", "&V\375b\\u011br:"
+    cs "Skip Messages", "P\\u0159esko\\u010dit zpr\341vy"
+    cs "Source...", "Nahr\341t..."
+    cs "Tcl Scripts", "Tcl skripty"
+    cs "Tcl for Windows", "Tcl pro Windows"
+    cs "Text Files", "Textov\351 soubory"
+    cs "&Yes", "&Ano"
+    cs "abort", "p\\u0159eru\\u0161it"
+    cs "blue", "modr\341"
+    cs "cancel", "zru\\u0161it"
+    cs "extension", "p\\u0159\355pona"
+    cs "extensions", "p\\u0159\355pony"
+    cs "green", "zelen\341"
+    cs "ignore", "ignorovat"
+    cs "ok"
+    cs "red", "\\u010derven\341"
+    cs "retry", "znovu"
+    cs "yes", "ano"
+}

ext/tk/sample/msgs_rb/de.msg

@@ -0,0 +1,88 @@
+TkMsgCatalog.new('::tkmsgcat_demo') {
+    de "Application Error", "Applikationsfehler"
+    de "Blue", "Blau"
+    de "Color", "Farbe"
+    de "Delete", "L\\u00f6schen"
+    de "Error", "Fehler"
+    de "Exit", "Ende"
+    de "Green", "Gr\\u00fcn"
+    de "Red", "Rot"
+    de "blue", "blau"
+    de "green", "gr\\u00fcn"
+    de "red", "rot"
+}
+
+TkMsgCatalog.new('::tk') {
+    de "&Abort", "&Abbruch"
+    de "&About...", "&\\u00dcber..."
+    de "All Files", "Alle Dateien"
+    de "Application Error", "Applikationsfehler"
+    de "&Blue", "&Blau"
+    de "&Cancel", "&Abbruch"
+    de "Cannot change to the directory \"%1\$s\".\nPermission denied.", "Kann nicht in das Verzeichnis \"%1\$s\" wechseln.\nKeine Rechte vorhanden."
+    de "Choose Directory", "W\\u00e4hle Verzeichnis"
+    de "&Clear", "&R\\u00fccksetzen"
+    de "&Clear Console", "&Konsole l\\u00f6schen"
+    de "Color", "Farbe"
+    de "Console", "Konsole"
+    de "&Copy", "&Kopieren"
+    de "Cu&t", "Aus&schneiden"
+    de "&Delete", "&L\\u00f6schen"
+    de "Details >>"
+    de "Directory \"%1\$s\" does not exist.", "Das Verzeichnis \"%1\$s\" existiert nicht."
+    de "&Directory:", "&Verzeichnis:"
+    de "&Edit", "&Bearbieten"
+    de "Error: %1\$s", "Fehler: %1\$s"
+    de "E&xit", "&Ende"
+    de "&File", "&Datei"
+    de "File \"%1\$s\" already exists.\nDo you want to overwrite it?", "Die Datei \"%1\$s\" ist bereits vorhanden.\nWollen sie diese Datei \\u00fcberschreiben ?"
+    de "File \"%1\$s\" already exists.\n\n", "Die Datei \"%1\$s\" ist bereits vorhanden.\n\n"
+    de "File \"%1\$s\" does not exist.", "Die Datei \"%1\$s\" existiert nicht."
+    de "File &name:", "Datei&name:"
+    de "File &names:", "Datei&namen:"
+    de "Files of &type:", "Dateien des &Typs:"
+    de "Fi&les:", "Dat&eien:"
+    de "&Filter"
+    de "Fil&ter:"
+    de "&Green", "&Gr\\u00fcn"
+    de "&Help", "&Hilfe"
+    de "Hi", "Hallo"
+    de "&Hide Console", "&Konsole unsichtbar machen"
+    de "&Ignore", "&Ignorieren"
+    de "Invalid file name \"%1\$s\".", "Ung\\u00fcltiger Dateiname \"%1\$s\"."
+    de "Log Files", "Protokolldatei"
+    de "&No", "&Nein"
+    de "OK"
+    de "Ok"
+    de "Open", "\\u00d6ffnen"
+    de "&Open", "\\u00d6&ffnen"
+    de "Open Multiple Files"
+    de "P&aste", "E&inf\\u00fcgen"
+    de "&Quit", "&Beenden"
+    de "&Red", "&Rot"
+    de "Replace existing file?", "Existierende Datei ersetzen?"
+    de "&Retry", "&Wiederholen"
+    de "&Save", "&Speichern"
+    de "Save As", "Speichern unter"
+    de "Save To Log", "In Protokoll speichern"
+    de "Select Log File", "Protokolldatei ausw\\u00e4hlen"
+    de "Select a file to source", "Auszuf\\u00fchrende Datei ausw\\u00e4hlen"
+    de "&Selection:", "Auswah&l:"
+    de "Skip Messages", "Weitere Nachrichten \\u00fcberspringen"
+    de "&Source...", "&Ausf\\u00fchren..."
+    de "Tcl Scripts", "Tcl-Skripte"
+    de "Tcl for Windows", "Tcl f\\u00fcr Windows"
+    de "Text Files", "Textdateien"
+    de "&Yes", "&Ja"
+    de "abort", "abbrechen"
+    de "blue", "blau"
+    de "cancel", "abbrechen"
+    de "extension", "Erweiterung"
+    de "extensions", "Erweiterungen"
+    de "green", "gr\\u00fcn"
+    de "ignore", "ignorieren"
+    de "ok"
+    de "red", "rot"
+    de "retry", "wiederholen"
+    de "yes", "ja"
+}

ext/tk/sample/msgs_rb/el.msg

@@ -0,0 +1,98 @@
+TkMsgCatalog.new('::tkmsgcat_demo') {
+    el 'Application Error',  '\u039b\u03ac\u03b8\u03bf\u03c2 \u0395\u03c6\u03b1\u03c1\u03bc\u03bf\u03b3\u03ae\u03c2'
+    el 'Blue',     '\u039c\u03c0\u03bb\u03b5'
+    el 'Color',    '\u03a7\u03c1\u03ce\u03bc\u03b1'
+    el 'Delete',   '\u0394\u03b9\u03b1\u03b3\u03c1\u03b1\u03c6\u03ae'
+    el 'Error',    '\u039b\u03ac\u03b8\u03bf\u03c2'
+    el 'Exit',     '\u0388\u03be\u03bf\u03b4\u03bf\u03c2'
+    el 'Green',    '\u03a0\u03c1\u03ac\u03c3\u03b9\u03bd\u03bf'
+    el 'Red',      '\u039a\u03cc\u03ba\u03ba\u03b9\u03bd\u03bf'
+    el 'blue',     '\u03bc\u03c0\u03bb\u03b5'
+    el 'green',    '\u03c0\u03c1\u03ac\u03c3\u03b9\u03bd\u03bf'
+    el 'red',      '\u03ba\u03cc\u03ba\u03ba\u03b9\u03bd\u03bf'
+}
+
+TkMsgCatalog.new('::tk') {
+    el '&Abort',             '\u03a4\u03b5\u03c1\u03bc\u03b1\u03c4\u03b9\u03c3\u03bc\u03cc\u03c2'
+    el 'About...',           '\u03a3\u03c7\u03b5\u03c4\u03b9\u03ba\u03ac...'
+    el 'All Files',          '\u038c\u03bb\u03b1 \u03c4\u03b1 \u0391\u03c1\u03c7\u03b5\u03af\u03b1'
+    el 'Application Error',  '\u039b\u03ac\u03b8\u03bf\u03c2 \u0395\u03c6\u03b1\u03c1\u03bc\u03bf\u03b3\u03ae\u03c2'
+    el '&Blue',              '\u039c\u03c0\u03bb\u03b5'
+    el '&Cancel',            '\u0391\u03ba\u03cd\u03c1\u03c9\u03c3\u03b7'
+    el 'Cannot change to the directory "%1\$s".' "\n" 'Permission denied.', \
+          '\u0394\u03b5\u03bd \u03b5\u03af\u03bd\u03b1\u03b9 \u03b4\u03c5\u03bd\u03b1\u03c4\u03ae \u03b7 \u03b1\u03bb\u03bb\u03b1\u03b3\u03ae \u03ba\u03b1\u03c4\u03b1\u03bb\u03cc\u03b3\u03bf\u03c5 \u03c3\u03b5 "%1\$s".' \
+          "\n" \
+          '\u0397 \u03c0\u03c1\u03cc\u03c3\u03b2\u03b1\u03c3\u03b7 \u03b4\u03b5\u03bd \u03b5\u03c0\u03b9\u03c4\u03c1\u03ad\u03c0\u03b5\u03c4\u03b1\u03b9.'
+    el 'Choose Directory',   '\u0395\u03c0\u03b9\u03bb\u03bf\u03b3\u03ae \u039a\u03b1\u03c4\u03b1\u03bb\u03cc\u03b3\u03bf\u03c5'
+    el 'Clear',              '\u039a\u03b1\u03b8\u03b1\u03c1\u03b9\u03c3\u03bc\u03cc\u03c2'
+    el 'Color',              '\u03a7\u03c1\u03ce\u03bc\u03b1'
+    el 'Console',            '\u039a\u03bf\u03bd\u03c3\u03cc\u03bb\u03b1'
+    el 'Copy',               '\u0391\u03bd\u03c4\u03b9\u03b3\u03c1\u03b1\u03c6\u03ae'
+    el 'Cut',                '\u0391\u03c0\u03bf\u03ba\u03bf\u03c0\u03ae'
+    el 'Delete',             '\u0394\u03b9\u03b1\u03b3\u03c1\u03b1\u03c6\u03ae'
+    el 'Details >>',         '\u039b\u03b5\u03c0\u03c4\u03bf\u03bc\u03ad\u03c1\u03b5\u03b9\u03b5\u03c2 >>'
+    el 'Directory "%1\$s", does not exist.', \
+          '\u039f \u03ba\u03b1\u03c4\u03ac\u03bb\u03bf\u03b3\u03bf\u03c2 \'%1\$s\' \u03b4\u03b5\u03bd \u03c5\u03c0\u03ac\u03c1\u03c7\u03b5\u03b9.'
+    el '&Directory:',        '&\u039a\u03b1\u03c4\u03ac\u03bb\u03bf\u03b3\u03bf\u03c2:'
+    el 'Error: %1\$s',       '\u039b\u03ac\u03b8\u03bf\u03c2: %1\$s'
+    el 'Exit',               '\u0388\u03be\u03bf\u03b4\u03bf\u03c2'
+    el 'File "%1\$s" already exists.' "\n" 'Do you want to overwrite it?', \
+          '\u03a4\u03bf \u03b1\u03c1\u03c7\u03b5\u03af\u03bf "%1\$s" \u03ae\u03b4\u03b7 \u03c5\u03c0\u03ac\u03c1\u03c7\u03b5\u03b9.' \
+          "\n" \
+          '\u0398\u03ad\u03bb\u03b5\u03c4\u03b5 \u03bd\u03b1 \u03b5\u03c0\u03b9\u03ba\u03b1\u03bb\u03c5\u03c6\u03b8\u03b5\u03af;'
+    el 'File "%1\$s" already exists.' "\n\n",  \
+          '\u03a4\u03bf \u03b1\u03c1\u03c7\u03b5\u03af\u03bf "%1\$s" \u03ae\u03b4\u03b7 \u03c5\u03c0\u03ac\u03c1\u03c7\u03b5\u03b9.' "\n\n"
+    el 'File "%1\$s" does not exist.', \
+          '\u03a4\u03bf \u03b1\u03c1\u03c7\u03b5\u03af\u03bf "%1\$s" \u03b4\u03b5\u03bd \u03c5\u03c0\u03ac\u03c1\u03c7\u03b5\u03b9.'
+    el 'File &name:',        '\u038c&\u03bd\u03bf\u03bc\u03b1 \u03b1\u03c1\u03c7\u03b5\u03af\u03bf\u03c5:'
+    el 'File &names:',       '\u038c&\u03bd\u03bf\u03bc\u03b1 \u03b1\u03c1\u03c7\u03b5\u03af\u03c9\u03bd:'
+    el 'Files of &type:',    '\u0391\u03c1\u03c7\u03b5\u03af\u03b1 \u03c4\u03bf\u03c5 &\u03c4\u03cd\u03c0\u03bf\u03c5:'
+    el 'Fi&les:',            '\u0391\u03c1\u03c7\u03b5\u03af\u03b1:'
+    el '&Filter',            '\u03a6\u03af\u03bb\u03c4\u03c1\u03bf'
+    el 'Fil&ter:',           '\u03a6\u03af\u03bb\u03c4\u03c1\u03bf:'
+    el '&Green',             '\u03a0\u03c1\u03ac\u03c3\u03b9\u03bd\u03bf'
+    el 'Hi',                 '\u0393\u03b5\u03b9\u03b1'
+    el 'Hide Console',       '\u0391\u03c0\u03cc\u03ba\u03c1\u03c5\u03c8\u03b7 \u03ba\u03bf\u03bd\u03c3\u03cc\u03bb\u03b1\u03c2'
+    el '&Ignore',            '\u0391\u03b3\u03bd\u03cc\u03b7\u03c3\u03b7'
+    el 'Invalid file name "%1\$s".', \
+          '\u0386\u03ba\u03c5\u03c1\u03bf \u03cc\u03bd\u03bf\u03bc\u03b1 \u03b1\u03c1\u03c7\u03b5\u03af\u03bf\u03c5 "%1\$s".'
+    el 'Log Files',          '\u0391\u03c1\u03c7\u03b5\u03af\u03b1 \u039a\u03b1\u03c4\u03b1\u03b3\u03c1\u03b1\u03c6\u03ae\u03c2'
+    el '&No',                '\u038c\u03c7\u03b9'
+    el '&OK',                '\u0395\u03bd\u03c4\u03ac\u03be\u03b5\u03b9'
+    el '&Ok',                '\u0395\u03bd\u03c4\u03ac\u03be\u03b5\u03b9'
+    el 'Open',               '\u0386\u03bd\u03bf\u03b9\u03b3\u03bc\u03b1'
+    el '&Open',              '\u0386\u03bd\u03bf\u03b9\u03b3\u03bc\u03b1'
+    el 'Open Multiple Files', \
+          '\u0386\u03bd\u03bf\u03b9\u03b3\u03bc\u03b1 \u03c0\u03bf\u03bb\u03bb\u03b1\u03c0\u03bb\u03ce\u03bd \u03b1\u03c1\u03c7\u03b5\u03af\u03c9\u03bd'
+    el 'Paste',              '\u0395\u03c0\u03b9\u03ba\u03cc\u03bb\u03bb\u03b7\u03c3\u03b7'
+    el 'Quit',               '\u0388\u03be\u03bf\u03b4\u03bf\u03c2'
+    el '&Red',               '\u039a\u03cc\u03ba\u03ba\u03b9\u03bd\u03bf'
+    el 'Replace existing file?', \
+          '\u0395\u03c0\u03b9\u03ba\u03ac\u03bb\u03c5\u03c8\u03b7 \u03c5\u03c0\u03ac\u03c1\u03c7\u03bf\u03bd\u03c4\u03bf\u03c2 \u03b1\u03c1\u03c7\u03b5\u03af\u03bf\u03c5;'
+    el '&Retry',             '\u03a0\u03c1\u03bf\u03c3\u03c0\u03ac\u03b8\u03b7\u03c3\u03b5 \u03be\u03b1\u03bd\u03ac'
+    el '&Save',              '\u0391\u03c0\u03bf\u03b8\u03ae\u03ba\u03b5\u03c5\u03c3\u03b7'
+    el 'Save As',            '\u0391\u03c0\u03bf\u03b8\u03ae\u03ba\u03b5\u03c5\u03c3\u03b7 \u03c3\u03b1\u03bd'
+    el 'Save To Log',        '\u0391\u03c0\u03bf\u03b8\u03ae\u03ba\u03b5\u03c5\u03c3\u03b7 \u03c3\u03c4\u03bf \u03b1\u03c1\u03c7\u03b5\u03af\u03bf \u03ba\u03b1\u03c4\u03b1\u03b3\u03c1\u03b1\u03c6\u03ae\u03c2'
+    el 'Select Log File',    '\u0395\u03c0\u03b9\u03bb\u03bf\u03b3\u03ae \u03b1\u03c1\u03c7\u03b5\u03af\u03bf\u03c5 \u03ba\u03b1\u03c4\u03b1\u03b3\u03c1\u03b1\u03c6\u03ae\u03c2'
+    el 'Select a file to source', \
+          '\u0395\u03c0\u03b9\u03bb\u03ad\u03be\u03c4\u03b5 \u03b1\u03c1\u03c7\u03b5\u03af\u03bf \u03b3\u03b9\u03b1 \u03b5\u03ba\u03c4\u03ad\u03bb\u03b5\u03c3\u03b7'
+    el '&Selection:',        '\u0395\u03c0\u03b9\u03bb\u03bf\u03b3\u03ae:'
+    el 'Skip Messages',      '\u0391\u03c0\u03bf\u03c6\u03c5\u03b3\u03ae \u03bc\u03c5\u03bd\u03b7\u03bc\u03ac\u03c4\u03c9\u03bd'
+    el 'Source...',          '\u0395\u03ba\u03c4\u03ad\u03bb\u03b5\u03c3\u03b7...'
+    el 'Tcl Scripts',        'Tcl Scripts'
+    el 'Tcl for Windows',    'Tcl \u03b3\u03b9\u03b1 Windows'
+    el 'Text Files',         '\u0391\u03c1\u03c7\u03b5\u03af\u03b1 \u039a\u03b5\u03b9\u03bc\u03ad\u03bd\u03bf\u03c5'
+    el '&Yes',               '\u039d\u03b1\u03b9'
+    el 'abort',              '\u03c4\u03b5\u03c1\u03bc\u03b1\u03c4\u03b9\u03c3\u03bc\u03cc\u03c2'
+    el 'blue',               '\u03bc\u03c0\u03bb\u03b5'
+    el 'cancel',             '\u03b1\u03ba\u03cd\u03c1\u03c9\u03c3\u03b7'
+    el 'extension',          '\u03b5\u03c0\u03ad\u03ba\u03c4\u03b1\u03c3\u03b7'
+    el 'extensions',         '\u03b5\u03c0\u03b5\u03ba\u03c4\u03ac\u03c3\u03b5\u03b9\u03c2'
+    el 'green',              '\u03c0\u03c1\u03ac\u03c3\u03b9\u03bd\u03bf'
+    el 'ignore',             '\u03b1\u03b3\u03bd\u03cc\u03b7\u03c3\u03b7'
+    el 'ok',                 '\u03b5\u03bd\u03c4\u03ac\u03be\u03b5\u03b9'
+    el 'red',                '\u03ba\u03cc\u03ba\u03ba\u03b9\u03bd\u03bf'
+    el 'retry',              '\u03c0\u03c1\u03bf\u03c3\u03c0\u03ac\u03b8\u03b7\u03c3\u03b5 \u03be\u03b1\u03bd\u03ac'
+    el 'yes',                '\u03bd\u03b1\u03b9'
+}
+

ext/tk/sample/msgs_rb/en.msg

@@ -0,0 +1,83 @@
+TkMsgCatalog.new('::tkmsgcat_demo') {
+    en "Application Error"
+    en "Blue"
+    en "Color"
+    en "Delete"
+    en "Error"
+    en "Green"
+    en "Red"
+    en "blue"
+    en "green"
+    en "red"
+}
+
+TkMsgCatalog.new('::tk') {
+    en "&Abort"
+    en "About..."
+    en "All Files"
+    en "Application Error"
+    en "&Blue"
+    en "&Cancel"
+    en "Cannot change to the directory \"%1\$s\".\nPermission denied."
+    en "Choose Directory"
+    en "Clear"
+    en "Color"
+    en "Console"
+    en "Copy"
+    en "Cut"
+    en "Delete"
+    en "Details >>"
+    en "Directory \"%1\$s\" does not exist."
+    en "&Directory:"
+    en "Error: %1\$s"
+    en "Exit"
+    en "File \"%1\$s\" already exists.\nDo you want to overwrite it?"
+    en "File \"%1\$s\" already exists.\n\n"
+    en "File \"%1\$s\" does not exist."
+    en "File &name:"
+    en "File &names:"
+    en "Files of &type:"
+    en "Fi&les:"
+    en "&Filter"
+    en "Fil&ter:"
+    en "&Green"
+    en "Hi"
+    en "Hide Console"
+    en "&Ignore"
+    en "Invalid file name \"%1\$s\"."
+    en "Log Files"
+    en "&No"
+    en "&OK"
+    en "Ok"
+    en "Open"
+    en "&Open"
+    en "Open Multiple Files"
+    en "Paste"
+    en "Quit"
+    en "&Red"
+    en "Replace existing file?"
+    en "&Retry"
+    en "&Save"
+    en "Save As"
+    en "Save To Log"
+    en "Select Log File"
+    en "Select a file to source"
+    en "&Selection:"
+    en "Skip Messages"
+    en "Source..."
+    en "Tcl Scripts"
+    en "Tcl for Windows"
+    en "Text Files"
+    en "&Yes"
+    en "abort"
+    en "blue"
+    en "cancel"
+    en "extension"
+    en "extensions"
+    en "green"
+    en "ignore"
+    en "ok"
+    en "red"
+    en "retry"
+    en "yes"
+}

ext/tk/sample/msgs_rb/en_gb.msg

@@ -0,0 +1,7 @@
+TkMsgCatalog.new('::tkmsgcat_demo') {
+    en_gb 'Color', 'Colour'
+}
+
+TkMsgCatalog.new('::tk') {
+    en_gb 'Color', 'Colour'
+}