From 0a64817fb80016030c03518fb9459f63c11605ea Mon Sep 17 00:00:00 2001
From: matz <matz@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>
Date: Fri, 13 Aug 1999 05:37:52 +0000
Subject: remove marshal/gtk/kconv

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@518 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
---
 ext/tk/lib/tk.rb          | 2495 +++++++++++++++++++++++++++++++++++++++++++++
 ext/tk/lib/tkafter.rb     |  296 ++++++
 ext/tk/lib/tkbgerror.rb   |   17 +
 ext/tk/lib/tkcanvas.rb    |  829 +++++++++++++++
 ext/tk/lib/tkclass.rb     |   38 +
 ext/tk/lib/tkdialog.rb    |  141 +++
 ext/tk/lib/tkentry.rb     |   73 ++
 ext/tk/lib/tkfont.rb      |  953 +++++++++++++++++
 ext/tk/lib/tkmenubar.rb   |  137 +++
 ext/tk/lib/tkmngfocus.rb  |   27 +
 ext/tk/lib/tkpalette.rb   |   48 +
 ext/tk/lib/tkscrollbox.rb |   29 +
 ext/tk/lib/tktext.rb      |  946 +++++++++++++++++
 ext/tk/lib/tkvirtevent.rb |   66 ++
 14 files changed, 6095 insertions(+)
 create mode 100644 ext/tk/lib/tk.rb
 create mode 100644 ext/tk/lib/tkafter.rb
 create mode 100644 ext/tk/lib/tkbgerror.rb
 create mode 100644 ext/tk/lib/tkcanvas.rb
 create mode 100644 ext/tk/lib/tkclass.rb
 create mode 100644 ext/tk/lib/tkdialog.rb
 create mode 100644 ext/tk/lib/tkentry.rb
 create mode 100644 ext/tk/lib/tkfont.rb
 create mode 100644 ext/tk/lib/tkmenubar.rb
 create mode 100644 ext/tk/lib/tkmngfocus.rb
 create mode 100644 ext/tk/lib/tkpalette.rb
 create mode 100644 ext/tk/lib/tkscrollbox.rb
 create mode 100644 ext/tk/lib/tktext.rb
 create mode 100644 ext/tk/lib/tkvirtevent.rb

(limited to 'ext/tk/lib')

diff --git a/ext/tk/lib/tk.rb b/ext/tk/lib/tk.rb
new file mode 100644
index 0000000000..2b4b504b0a
--- /dev/null
+++ b/ext/tk/lib/tk.rb
@@ -0,0 +1,2495 @@
+#
+#		tk.rb - Tk interface modue using tcltklib
+#			$Date$
+#			by Yukihiro Matsumoto <matz@netlab.co.jp>
+
+# use Shigehiro's tcltklib
+require "tcltklib"
+require "tkutil"
+
+module TkComm
+  None = Object.new
+  def None.to_s
+    'None'
+  end
+
+  Tk_CMDTBL = {}
+  Tk_WINDOWS = {}
+
+  def error_at
+    frames = caller()
+    frames.delete_if do |c|
+      c =~ %r!/tk(|core|thcore|canvas|text|entry|scrollbox)\.rb:\d+!
+    end
+    frames
+  end
+  private :error_at
+
+  def _genobj_for_tkwidget(path)
+    return TkRoot.new if path == '.'
+
+    begin
+      tk_class = TkCore::INTERP._invoke('winfo', 'class', path)
+    rescue
+      return path
+    end
+
+    ruby_class = TkClassBind::WidgetClassNameTBL[tk_class]
+    gen_class_name = ruby_class.name + 'GeneratedOnTk'
+    unless Object.const_defined? gen_class_name
+      eval "class #{gen_class_name}<#{ruby_class.name}
+              def initialize(path)
+                @path=path
+                Tk_WINDOWS[@path] = self
+              end
+            end"
+    end
+    eval "#{gen_class_name}.new('#{path}')"
+  end
+
+  def tk_tcl2ruby(val)
+    if val =~ /^rb_out (c\d+)/
+      return Tk_CMDTBL[$1]
+    end
+    if val.include? ?\s
+      return val.split.collect{|v| tk_tcl2ruby(v)}
+    end
+    case val
+    when /^@font/
+      TkFont.get_obj(val)
+    when /^-?\d+$/
+      val.to_i
+    when /^\./
+      Tk_WINDOWS[val] ? Tk_WINDOWS[val] : _genobj_for_tkwidget(val)
+    when / /
+      val.split.collect{|elt|
+	tk_tcl2ruby(elt)
+      }
+    when /^-?\d+\.\d*$/
+      val.to_f
+    else
+      val
+    end
+  end
+
+  def tk_split_list(str)
+    return [] if str == ""
+    idx = str.index('{')
+    return tk_tcl2ruby(str) unless idx
+
+    list = tk_tcl2ruby(str[0,idx])
+    list = [] if list == ""
+    str = str[idx+1..-1]
+    i = -1
+    brace = 1
+    str.each_byte {|c|
+      i += 1
+      brace += 1 if c == ?{
+      brace -= 1 if c == ?}
+      break if brace == 0
+    }
+    if str[0, i] == ' '
+      list.push ' '
+    else
+      list.push tk_split_list(str[0, i])
+    end
+    list += tk_split_list(str[i+1..-1])
+    list
+  end
+
+  def tk_split_simplelist(str)
+    return [] if str == ""
+    idx = str.index('{')
+    return str.split unless idx
+
+    list = str[0,idx].split
+    str = str[idx+1..-1]
+    i = -1
+    brace = 1
+    str.each_byte {|c|
+      i += 1
+      brace += 1 if c == ?{
+      brace -= 1 if c == ?}
+      break if brace == 0
+    }
+    if i == 0
+      list.push ''
+    elsif str[0, i] == ' '
+      list.push ' '
+    else
+      list.push str[0..i-1]
+    end
+    list += tk_split_simplelist(str[i+1..-1])
+    list
+  end
+  private :tk_tcl2ruby, :tk_split_list, :tk_split_simplelist
+
+  def hash_kv(keys)
+    conf = []
+    if keys and keys != None
+      for k, v in keys
+	 conf.push("-#{k}")
+	 conf.push(v)
+      end
+    end
+    conf
+  end
+  private :hash_kv
+
+  def array2tk_list(ary)
+    ary.collect{|e|
+      if e.kind_of? Array
+	"{#{array2tk_list(e)}}"
+      elsif e.kind_of? Hash
+	"{#{e.to_a.collect{|ee| array2tk_list(ee)}.join(' ')}}"
+      else
+	s = _get_eval_string(e)
+	(s.index(/\s/))? "{#{s}}": s
+      end
+    }.join(" ")
+  end
+  private :array2tk_list
+
+  def bool(val)
+    case val
+    when "1", 1, 'yes', 'true'
+      TRUE
+    else
+      FALSE
+    end
+  end
+  def number(val)
+    case val
+    when /^-?\d+$/
+      val.to_i
+    when /^-?\d+\.\d*$/
+      val.to_f
+    else
+      val
+    end
+  end
+  def string(val)
+    if val == "{}"
+      ''
+    elsif val[0] == ?{
+      val[1..-2]
+    else
+      val
+    end
+  end
+  def list(val)
+    tk_split_list(val).to_a
+  end
+  def window(val)
+    Tk_WINDOWS[val]
+  end
+  def procedure(val)
+    if val =~ /^rb_out (c\d+)/
+      Tk_CMDTBL[$1]
+    else
+      nil
+    end
+  end
+  private :bool, :number, :string, :list, :window, :procedure
+
+  def _get_eval_string(str)
+    return nil if str == None
+    if str.kind_of?(Hash)
+      str = hash_kv(str).join(" ")
+    elsif str.kind_of?(Array)
+      str = array2tk_list(str)
+    elsif str.kind_of?(Proc)
+      str = install_cmd(str)
+    elsif str == nil
+      str = ""
+    elsif str == false
+      str = "0"
+    elsif str == true
+      str = "1"
+    elsif (str.respond_to?(:to_eval))
+      str = str.to_eval()
+    else
+      str = str.to_s()
+    end
+    return str
+  end
+  private :_get_eval_string
+
+  Tk_IDs = [0, 0]		# [0]-cmdid, [1]-winid
+  def _curr_cmd_id
+    id = format("c%.4d", Tk_IDs[0])
+  end
+  def _next_cmd_id
+    id = _curr_cmd_id
+    Tk_IDs[0] += 1
+    id
+  end
+  def install_cmd(cmd)
+    return '' if cmd == ''
+    id = _next_cmd_id
+    Tk_CMDTBL[id] = cmd
+    @cmdtbl = [] unless @cmdtbl
+    @cmdtbl.push id
+    return format("rb_out %s", id);
+  end
+  def uninstall_cmd(id)
+    id = $1 if /rb_out (c\d+)/
+    Tk_CMDTBL[id] = nil
+  end
+  private :install_cmd, :uninstall_cmd
+
+  def install_win(ppath)
+    id = format("w%.4d", Tk_IDs[1])
+    Tk_IDs[1] += 1
+    if !ppath or ppath == "."
+      @path = format(".%s", id);
+    else
+      @path = format("%s.%s", ppath, id)
+    end
+    Tk_WINDOWS[@path] = self
+  end
+
+  def uninstall_win()
+    Tk_WINDOWS[@path] = nil
+  end
+
+  class Event
+    def initialize(seq,b,f,h,k,s,t,w,x,y,aa,ee,kk,nn,ww,tt,xx,yy)
+      @serial = seq
+      @num = b
+      @focus = (f == 1)
+      @height = h
+      @keycode = k
+      @state = s
+      @time = t
+      @width = w
+      @x = x
+      @y = y
+      @char = aa
+      @send_event = (ee == 1)
+      @keysym = kk
+      @keysym_num = nn
+      @type = tt
+      @widget = ww
+      @x_root = xx
+      @y_root = yy
+    end
+    attr :serial
+    attr :num
+    attr :focus
+    attr :height
+    attr :keycode
+    attr :state
+    attr :time
+    attr :width
+    attr :x
+    attr :y
+    attr :char
+    attr :send_event
+    attr :keysym
+    attr :keysym_num
+    attr :type
+    attr :widget
+    attr :x_root
+    attr :y_root
+  end
+
+  def install_bind(cmd, args=nil)
+    if args
+      id = install_cmd(proc{|arg|
+	TkUtil.eval_cmd cmd, *arg
+      })
+      id + " " + args
+    else
+      id = install_cmd(proc{|arg|
+	TkUtil.eval_cmd cmd, Event.new(*arg)
+      })
+      id + ' %# %b %f %h %k %s %t %w %x %y %A %E %K %N %W %T %X %Y'
+    end
+  end
+
+  def tk_event_sequence(context)
+    if context.kind_of? TkVirtualEvent
+      context = context.path
+    end
+    if context.kind_of? Array
+      context = context.collect{|ev|
+	if context.kind_of? TkVirtualEvent
+	  ev.path
+	else
+	  ev
+	end
+      }.join("><")
+    end
+    if /,/ =~ context
+      context = context.split(/\s*,\s*/).join("><")
+    else
+      context
+    end
+  end
+
+  def _bind_core(mode, path, context, cmd, args=nil)
+    id = install_bind(cmd, args)
+    begin
+      tk_call 'bind', path, "<#{tk_event_sequence(context)}>", mode + id
+    rescue
+      uninstall_cmd(id)
+      fail
+    end
+  end
+
+  def _bind(path, context, cmd, args=nil)
+    _bind_core('', path, context, cmd, args)
+  end
+
+  def _bind_append(path, context, cmd, args=nil)
+    _bind_core('+', path, context, cmd, args)
+  end
+  private :install_bind, :tk_event_sequence, :_bind_core, :_bind, :_bind_append
+
+  def bind_all(context, cmd=Proc.new, args=nil)
+    _bind 'all', context, cmd, args
+  end
+
+  def bind_append_all(context, cmd=Proc.new, args=nil)
+    _bind_append 'all', context, cmd, args
+  end
+
+  def bind(tagOrClass, context, cmd=Proc.new, args=nil)
+    _bind tagOrClass, context, cmd, args
+  end
+
+  def bind_append(tagOrClass, context, cmd=Proc.new, args=nil)
+    _bind_append tagOrClass, context, cmd, args
+  end
+
+  def _bindinfo(tagOrClass, context=nil)
+    if context
+      (tk_call('bind', tagOrClass, 
+	       "<#{tk_event_sequence(context)}>")).collect{|cmdline|
+	if cmdline =~ /^rb_out (c\d+)\s+(.*)$/
+	  [Tk_CMDTBL[$1], $2]
+	else
+	  cmdline
+	end
+      }
+    else
+      tk_split_list(tk_call 'bind', tagOrClass).collect{|seq|
+	seq[1..-2].gsub(/></,',')
+      }
+    end
+  end
+
+  def bindinfo(tagOrClass, context=nil)
+    _bindinfo tagOrClass, context
+  end
+
+  def pack(*args)
+    TkPack.configure *args
+  end
+
+  def grid(*args)
+    TkGrid.configure *args
+  end
+
+  def update(idle=nil)
+    if idle
+      tk_call 'update', 'idletasks'
+    else
+      tk_call 'update'
+    end
+  end
+
+end
+
+module TkCore
+  include TkComm
+  extend TkComm
+
+  INTERP = TclTkIp.new
+
+  INTERP._invoke("proc", "rb_out", "args", "if {[set st [catch {ruby [format \"TkCore.callback %%Q!%s!\" $args]} ret]] != 0} {return -code $st $ret} {return $ret}")
+
+  def callback_break
+    raise TkCallbackBreak, "Tk callback returns 'break' status"
+  end
+
+  def callback_continue
+    raise TkCallbackContinue, "Tk callback returns 'continue' status"
+  end
+
+  def after(ms, cmd=Proc.new)
+    myid = _curr_cmd_id
+    cmdid = install_cmd(cmd)
+    tk_call("after",ms,cmdid)
+    return
+    if false #defined? Thread
+      Thread.start do
+	ms = Float(ms)/1000
+	ms = 10 if ms == 0
+	sleep ms/1000
+	cmd.call
+      end
+    else
+      cmdid = install_cmd(cmd)
+      tk_call("after",ms,cmdid)
+    end
+  end
+
+  def TkCore.callback(arg)
+    arg = Array(tk_split_list(arg))
+    _get_eval_string(TkUtil.eval_cmd(Tk_CMDTBL[arg.shift], *arg))
+  end
+
+  def appname(name=None)
+    tk_call('tk', 'appname', name)
+  end
+
+  def appsend(interp, async, *args)
+    if async
+      tk_call('send', '-async', '--', interp, *args)
+    else
+      tk_call('send', '--', interp, *args)
+    end
+  end
+
+  def rb_appsend(interp, async, *args)
+    args = args.filter{|c| _get_eval_string(c).gsub(/[][$"]/, '\\\\\&')}
+    args.push(').to_s"')
+    appsend(interp, async, 'ruby "(', *args)
+  end
+
+  def appsend_displayof(interp, win, async, *args)
+    win = '.' if win == nil
+    if async
+      tk_call('send', '-async', '-displayof', win, '--', interp, *args)
+    else
+      tk_call('send', '-displayor', win, '--', interp, *args)
+    end
+  end
+
+  def rb_appsend_displayof(interp, win, async, *args)
+    args = args.filter{|c| _get_eval_string(c).gsub(/[][$"]/, '\\\\\&')}
+    args.push(').to_s"')
+    appsend_displayof(interp, win, async, 'ruby "(', *args)
+  end
+
+  def info(*args)
+    tk_call('info', *args)
+  end
+
+  def mainloop
+    TclTkLib.mainloop
+  end
+
+  def event_generate(window, context, keys=nil)
+    window = window.path if window.kind_of? TkObject
+    if keys
+      tk_call('event', 'generate', window, 
+	      "<#{tk_event_sequence(context)}>", *hash_kv(keys))
+    else
+      tk_call('event', 'generate', window, "<#{tk_event_sequence(context)}>")
+    end
+  end
+
+  def messageBox(keys)
+    tk_call 'tk_messageBox', *hash_kv(keys)
+  end
+
+  def getOpenFile(keys)
+    tk_call 'tk_getOpenFile', *hash_kv(keys)
+  end
+
+  def getSaveFile(keys)
+    tk_call 'tk_getSaveFile', *hash_kv(keys)
+  end
+
+  def chooseColor(keys)
+    tk_call 'tk_chooseColor', *hash_kv(keys)
+  end
+
+  def tk_call(*args)
+    print args.join(" "), "\n" if $DEBUG
+    args.filter {|x|_get_eval_string(x)}
+    args.compact!
+    args.flatten!
+    begin
+      res = INTERP._invoke(*args)
+    rescue NameError
+      err = $!
+      begin
+        args.unshift "unknown"
+        res = INTERP._invoke(*args)
+      rescue
+	raise unless /^invalid command/ =~ $!
+	raise err
+      end
+    end
+    if  INTERP._return_value() != 0
+      fail RuntimeError, res, error_at
+    end
+    print "==> ", res, "\n" if $DEBUG
+    return res
+  end
+end
+
+module Tk
+  include TkCore
+  extend Tk
+
+  TCL_VERSION = INTERP._invoke("info", "tclversion")
+  TK_VERSION  = INTERP._invoke("set", "tk_version")
+  JAPANIZED_TK = (INTERP._invoke("info", "commands", "kanji") != "")
+
+  def root
+    TkRoot.new
+  end
+
+  def bell
+    tk_call 'bell'
+  end
+
+  def Tk.focus(display=nil)
+    if display == nil
+      r = tk_call('focus')
+    else
+      r = tk_call('focus', '-displayof', display)
+    end
+    tk_tcl2ruby(r)
+  end
+
+  def Tk.focus_lastfor(win)
+    tk_tcl2ruby(tk_call('focus', '-lastfor', win))
+  end
+
+  def toUTF8(str,encoding)
+    INTERP._toUTF8(str,encoding)
+  end
+  
+  def fromUTF8(str,encoding)
+    INTERP._fromUTF8(str,encoding)
+  end
+
+  module Scrollable
+    def xscrollcommand(cmd=Proc.new)
+      configure_cmd 'xscrollcommand', cmd
+    end
+    def yscrollcommand(cmd=Proc.new)
+      configure_cmd 'yscrollcommand', cmd
+    end
+  end
+
+  module Wm
+    include TkComm
+    def aspect(*args)
+      w = window(tk_call('wm', 'grid', path, *args))
+      w.split.collect{|s|s.to_i} if args.length == 0
+    end
+    def client(name=None)
+      tk_call 'wm', 'client', path, name
+    end
+    def colormapwindows(*args)
+      list(tk_call('wm', 'colormapwindows', path, *args))
+    end
+    def wm_command(value=None)
+      string(tk_call('wm', 'command', path, value))
+    end
+    def deiconify
+      tk_call 'wm', 'deiconify', path
+    end
+    def focusmodel(*args)
+      tk_call 'wm', 'focusmodel', path, *args
+    end
+    def frame
+      tk_call 'wm', 'frame', path
+    end
+    def geometry(*args)
+      list(tk_call('wm', 'geometry', path, *args))
+    end
+    def grid(*args)
+      w = tk_call('wm', 'grid', path, *args)
+      list(w) if args.size == 0
+    end
+    def group(*args)
+      tk_call 'wm', 'group', path, *args
+    end
+    def iconbitmap(*args)
+      tk_call 'wm', 'iconbitmap', path, *args
+    end
+    def iconify
+      tk_call 'wm', 'iconify', path
+    end
+    def iconmask(*args)
+      tk_call 'wm', 'iconmask', path, *args
+    end
+    def iconname(*args)
+      tk_call 'wm', 'iconname', path, *args
+    end
+    def iconposition(*args)
+      w = tk_call('wm', 'iconposition', path, *args)
+      list(w) if args.size == 0
+    end
+    def iconwindow(*args)
+      w = tk_call('wm', 'iconwindow', path, *args)
+      window(w) if args.size == 0
+    end
+    def maxsize(*args)
+      w = tk_call('wm', 'maxsize', path, *args)
+      list(w) if not args.size == 0
+    end
+    def minsize(*args)
+      w = tk_call('wm', 'minsize', path, *args)
+      list(w) if args.size == 0
+    end
+    def overrideredirect(bool=None)
+      if bool == None
+	bool(tk_call('wm', 'overrideredirect', path))
+      else
+	tk_call 'wm', 'overrideredirect', path, bool
+      end
+    end
+    def positionfrom(*args)
+      tk_call 'wm', 'positionfrom', path, *args
+    end
+    def protocol(name=nil, cmd=nil)
+      if cmd
+	tk_call('wm', 'protocol', path, name, cmd)
+      elsif name
+	result = tk_call('wm', 'protocol', path, name)
+	(result == "")? nil : tk_tcl2ruby(result)
+      else
+	tk_split_simplelist(tk_call('wm', 'protocol', path))
+      end
+    end
+    def resizable(*args)
+      w = tk_call('wm', 'resizable', path, *args)
+      if args.length == 0
+	list(w).collect{|e| bool(e)}
+      end
+    end
+    def sizefrom(*args)
+      list(tk_call('wm', 'sizefrom', path, *args))
+    end
+    def state
+      tk_call 'wm', 'state', path
+    end
+    def title(*args)
+      tk_call 'wm', 'title', path, *args
+    end
+    def transient(*args)
+      tk_call 'wm', 'transient', path, *args
+    end
+    def withdraw
+      tk_call 'wm', 'withdraw', path
+    end
+  end
+end
+
+class TkVariable
+  include Tk
+  extend TkCore
+
+  TkVar_CB_TBL = {}
+  Tk_VARIABLE_ID = ["v00000"]
+
+  INTERP._invoke("proc", "rb_var", "args", "ruby [format \"TkVariable.callback %%Q!%s!\" $args]")
+
+  def TkVariable.callback(args)
+    name1,name2,op = tk_split_list(args)
+    if TkVar_CB_TBL[name1]
+      _get_eval_string(TkVar_CB_TBL[name1].trace_callback(name2,op))
+    else
+      ''
+    end
+  end
+
+  def initialize(val="")
+    @id = Tk_VARIABLE_ID[0]
+    Tk_VARIABLE_ID[0] = Tk_VARIABLE_ID[0].succ
+    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(/[][$"]/, '\\\\\&') + '"'
+      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(/[][$"]/, '\\\\\&') + '"'
+      INTERP._eval(format('global %s; array set %s %s', @id, @id, s))
+    else
+      s = '"' + _get_eval_string(val).gsub(/[][$"]/, '\\\\\&') + '"'
+      INTERP._eval(format('global %s; set %s %s', @id, @id, s))
+    end
+  end
+
+  def wait
+    INTERP._eval("tkwait variable #{@id}")
+  end
+
+  def id
+    @id
+  end
+
+  def value
+    begin
+      INTERP._eval(format('global %s; set %s', @id, @id))
+    rescue
+      if INTERP._eval(format('global %s; array exists %s', @id, @id)) != "1"
+	raise
+      else
+	Hash[*tk_split_simplelist(INTERP._eval(format('global %s; array get %s', 
+						      @id, @id)))]
+      end
+    end
+  end
+
+  def value=(val)
+    begin
+      s = '"' + _get_eval_string(val).gsub(/[][$"]/, '\\\\\&') + '"'
+      INTERP._eval(format('global %s; set %s %s', @id, @id, s))
+    rescue
+      if INTERP._eval(format('global %s; array exists %s', @id, @id)) != "1"
+	raise
+      else
+	if val == []
+	  INTERP._eval(format('global %s; unset %s; set %s(0) 0; unset %s(0)', 
+			      @id, @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(/[][$"]/, '\\\\\&') + '"'
+	  INTERP._eval(format('global %s; unset %s; array set %s %s', 
+			      @id, @id, @id, s))
+	elsif  val.kind_of?(Hash)
+	  s = '"' + val.to_a.collect{|e| array2tk_list(e)}.join(" ")\
+	                        .gsub(/[][$"]/, '\\\\\&') + '"'
+	  INTERP._eval(format('global %s; unset %s; array set %s %s', 
+			      @id, @id, @id, s))
+	else
+	  raise
+	end
+      end
+    end
+  end
+
+  def [](index)
+    INTERP._eval(format('global %s; set %s(%s)', 
+			@id, @id, _get_eval_string(index)))
+  end
+
+  def []=(index,val)
+    INTERP._eval(format('global %s; set %s(%s) %s', @id, @id, 
+			_get_eval_string(index), _get_eval_string(val)))
+  end
+
+  def to_i
+    Integer(number(value))
+  end
+
+  def to_f
+    Float(number(value))
+  end
+
+  def to_s
+    String(string(value))
+  end
+
+  def inspect
+    format "<TkVariable: %s>", @id
+  end
+
+  def ==(other)
+    case other
+    when TkVariable
+      self.equal(self)
+    when String
+      self.to_s == other
+    when Integer
+      self.to_i == other
+    when Float
+      self.to_f == other
+    when Array
+      self.to_a == other
+    else
+      false
+    end
+  end
+
+  def to_a
+    list(value)
+  end
+
+  def to_eval
+    @id
+  end
+
+  def unset(elem=nil)
+    if elem
+      INTERP._eval(format('global %s; unset %s(%s)', 
+			  @id, @id, tk_tcl2ruby(elem)))
+    else
+      INTERP._eval(format('global %s; unset %s', @id, @id))
+    end
+  end
+  alias remove unset
+
+  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
+      if @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)
+    @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
+      Tk.tk_call('trace', 'variable', @id, @trace_opts, 'rb_var')
+    else
+      newopts = @trace_opts.dup
+      opts.each_byte{|c| newopts += c.chr unless newopts.index(c)}
+      if newopts != @trace_opts
+	Tk.tk_call('trace', 'vdelete', @id, @trace_opts, 'rb_var')
+	@trace_opts.replace(newopts)
+	Tk.tk_call('trace', 'variable', @id, @trace_opts, 'rb_var')
+      end
+    end
+  end
+
+  def trace_element(elem, opts, cmd)
+    @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
+      Tk.tk_call('trace', 'variable', @id, @trace_opts, 'rb_var')
+    else
+      newopts = @trace_opts.dup
+      opts.each_byte{|c| newopts += c.chr unless newopts.index(c)}
+      if newopts != @trace_opts
+	Tk.tk_call('trace', 'vdelete', @id, @trace_opts, 'rb_var')
+	@trace_opts.replace(newopts)
+	Tk.tk_call('trace', 'variable', @id, @trace_opts, 'rb_var')
+      end
+    end
+  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 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{|i,e| 
+      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
+    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('trace', 'vdelete', @id, @trace_opts, 'rb_var')
+      @trace_opts.replace(newopts)
+      if @trace_opts != ''
+	Tk.tk_call('trace', 'variable', @id, @trace_opts, 'rb_var')
+      end
+    end
+  end
+
+  def trace_vdelete_for_element(elem,opts,cmd)
+    return unless @trace_elem.kind_of? Hash
+    return 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{|i,e| 
+      if idx < 0 && e[0] == opts && e[1] == cmd
+	idx = i
+	next
+      end
+    }
+    if idx >= 0
+      @trace_elem[elem].delete_at(idx)
+    else
+      return
+    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('trace', 'vdelete', @id, @trace_opts, 'rb_var')
+      @trace_opts.replace(newopts)
+      if @trace_opts != ''
+	Tk.tk_call('trace', 'variable', @id, @trace_opts, 'rb_var')
+      end
+    end
+  end
+end
+
+class TkVarAccess<TkVariable
+  def initialize(varname, val=nil)
+    @id = varname
+    if val
+      s = '"' + _get_eval_string(val).gsub(/[][$"]/, '\\\\\&') + '"'
+      INTERP._eval(format('global %s; set %s %s', @id, @id, s))
+    end
+  end
+end
+
+module TkSelection
+  include Tk
+  extend Tk
+  def clear(win=Tk.root)
+    tk_call 'selection', 'clear', win.path
+  end
+  def get(type=None)
+    tk_call 'selection', 'get', type
+  end
+  def TkSelection.handle(win, func, type=None, format=None)
+    id = install_cmd(func)
+    tk_call 'selection', 'handle', win.path, id, type, format
+  end
+  def handle(func, type=None, format=None)
+    TkSelection.handle self, func, type, format
+  end
+  def TkSelection.own(win, func=None)
+    id = install_cmd(func)
+    tk_call 'selection', 'own', win.path, id
+  end
+  def own(func=None)
+    TkSelection.own self, func
+  end
+
+  module_function :clear, :get
+end
+
+module TkKinput
+  include Tk
+  extend Tk
+
+  def TkKinput.start(window, style=None)
+    tk_call 'kinput_start', window.path, style
+  end
+  def kinput_start(style=None)
+    TkKinput.start(self, style)
+  end
+
+  def TkKinput.send_spot(window)
+    tk_call 'kinput_send_spot', window.path
+  end
+  def kinput_send_spot
+    TkKinput.send_spot(self)
+  end
+
+  def TkKinput.input_start(window, keys=nil)
+    tk_call 'kanjiInput', 'start', window.path, *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.path, *hash_kv(slot)
+    else
+      tk_call 'kanjiInput', 'attribute', window.path, "-#{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.path, "-#{slot}"))
+      conf[0] = conf[0][1..-1]
+      conf
+    else
+      tk_split_list(tk_call('kanjiInput', 'attribute', 
+			    window.path)).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.path
+  end
+  def kanji_input_end
+    TkKinput.input_end(self)
+  end
+end
+
+module TkWinfo
+  include Tk
+  extend Tk
+  def TkWinfo.atom(name)
+    tk_call 'winfo', name
+  end
+  def winfo_atom(name)
+    TkWinfo.atom name
+  end
+  def TkWinfo.atomname(id)
+    tk_call 'winfo', id
+  end
+  def winfo_atomname(id)
+    TkWinfo.atomname id
+  end
+  def TkWinfo.cells(window)
+    number(tk_call('winfo', window.path))
+  end
+  def winfo_cells
+    TkWinfo.cells self
+  end
+  def TkWinfo.children(window)
+    c = tk_call('winfo', 'children', window.path)
+    list(c)
+  end
+  def winfo_children
+    TkWinfo.children self
+  end
+  def TkWinfo.classname(window)
+    tk_call 'winfo', 'class', window.path
+  end
+  def winfo_classname
+    TkWinfo.classname self
+  end
+  def TkWinfo.containing(rootX, rootY)
+    path = tk_call('winfo', 'containing', rootX, rootY)
+    window(path)
+  end
+  def winfo_containing(x, y)
+    TkWinfo.containing x, y
+  end
+  def TkWinfo.depth(window)
+    number(tk_call('winfo', 'depth', window.path))
+  end
+  def winfo_depth
+    TkWinfo.depth self
+  end
+  def TkWinfo.exist?(window)
+    bool(tk_call('winfo', 'exists', window.path))
+  end
+  def winfo_exist?
+    TkWinfo.exist? self
+  end
+  def TkWinfo.fpixels(window, number)
+    number(tk_call('winfo', 'fpixels', window.path, number))
+  end
+  def winfo_fpixels(number)
+    TkWinfo.fpixels self, number
+  end
+  def TkWinfo.geometry(window)
+    list(tk_call('winfo', 'geometry', window.path))
+  end
+  def winfo_geometry
+    TkWinfo.geometry self
+  end
+  def TkWinfo.height(window)
+    number(tk_call('winfo', 'height', window.path))
+  end
+  def winfo_height
+    TkWinfo.height self
+  end
+  def TkWinfo.id(window)
+    number(tk_call('winfo', 'id', window.path))
+  end
+  def winfo_id
+    TkWinfo.id self
+  end
+  def TkWinfo.interps(window=nil)
+    if window
+      tk_split_simplelist(tk_call('winfo', '-displayof', window.path, 
+				  'interps'))
+    else
+      tk_split_simplelist(tk_call('winfo', 'interps'))
+    end
+  end
+  def winfo_interps
+    TkWinfo.interps self
+  end
+  def TkWinfo.mapped?(window)
+    bool(tk_call('winfo', 'ismapped', window.path))
+  end
+  def winfo_mapped?
+    TkWinfo.mapped? self
+  end
+  def TkWinfo.appname(window)
+    bool(tk_call('winfo', 'name', window.path))
+  end
+  def winfo_appname
+    TkWinfo.appname self
+  end
+  def TkWinfo.parent(window)
+    window(tk_call('winfo', 'parent', window.path))
+  end
+  def winfo_parent
+    TkWinfo.parent self
+  end
+  def TkWinfo.widget(id)
+    window(tk_call('winfo', 'pathname', id))
+  end
+  def winfo_widget(id)
+    TkWinfo.widget id
+  end
+  def TkWinfo.pixels(window, number)
+    number(tk_call('winfo', 'pixels', window.path, number))
+  end
+  def winfo_pixels(number)
+    TkWinfo.pixels self, number
+  end
+  def TkWinfo.reqheight(window)
+    number(tk_call('winfo', 'reqheight', window.path))
+  end
+  def winfo_reqheight
+    TkWinfo.reqheight self
+  end
+  def TkWinfo.reqwidth(window)
+    number(tk_call('winfo', 'reqwidth', window.path))
+  end
+  def winfo_reqwidth
+    TkWinfo.reqwidth self
+  end
+  def TkWinfo.rgb(window, color)
+    list(tk_call('winfo', 'rgb', window.path, color))
+  end
+  def winfo_rgb(color)
+    TkWinfo.rgb self, color
+  end
+  def TkWinfo.rootx(window)
+    number(tk_call('winfo', 'rootx', window.path))
+  end
+  def winfo_rootx
+    TkWinfo.rootx self
+  end
+  def TkWinfo.rooty(window)
+    number(tk_call('winfo', 'rooty', window.path))
+  end
+  def winfo_rooty
+    TkWinfo.rooty self
+  end
+  def TkWinfo.screen(window)
+    tk_call 'winfo', 'screen', window.path
+  end
+  def winfo_screen
+    TkWinfo.screen self
+  end
+  def TkWinfo.screencells(window)
+    number(tk_call('winfo', 'screencells', window.path))
+  end
+  def winfo_screencells
+    TkWinfo.screencells self
+  end
+  def TkWinfo.screendepth(window)
+    number(tk_call('winfo', 'screendepth', window.path))
+  end
+  def winfo_screendepth
+    TkWinfo.screendepth self
+  end
+  def TkWinfo.screenheight (window)
+    number(tk_call('winfo', 'screenheight', window.path))
+  end
+  def winfo_screenheight
+    TkWinfo.screenheight self
+  end
+  def TkWinfo.screenmmheight(window)
+    number(tk_call('winfo', 'screenmmheight', window.path))
+  end
+  def winfo_screenmmheight
+    TkWinfo.screenmmheight self
+  end
+  def TkWinfo.screenmmwidth(window)
+    number(tk_call('winfo', 'screenmmwidth', window.path))
+  end
+  def winfo_screenmmwidth
+    TkWinfo.screenmmwidth self
+  end
+  def TkWinfo.screenvisual(window)
+    tk_call 'winfo', 'screenvisual', window.path
+  end
+  def winfo_screenvisual
+    TkWinfo.screenvisual self
+  end
+  def TkWinfo.screenwidth(window)
+    number(tk_call('winfo', 'screenwidth', window.path))
+  end
+  def winfo_screenwidth
+    TkWinfo.screenwidth self
+  end
+  def TkWinfo.toplevel(window)
+    window(tk_call('winfo', 'toplevel', window.path))
+  end
+  def winfo_toplevel
+    TkWinfo.toplevel self
+  end
+  def TkWinfo.visual(window)
+    tk_call 'winfo', 'visual', window.path
+  end
+  def winfo_visual
+    TkWinfo.visual self
+  end
+  def TkWinfo.vrootheigh(window)
+    number(tk_call('winfo', 'vrootheight', window.path))
+  end
+  def winfo_vrootheight
+    TkWinfo.vrootheight self
+  end
+  def TkWinfo.vrootwidth(window)
+    number(tk_call('winfo', 'vrootwidth', window.path))
+  end
+  def winfo_vrootwidth
+    TkWinfo.vrootwidth self
+  end
+  def TkWinfo.vrootx(window)
+    number(tk_call('winfo', 'vrootx', window.path))
+  end
+  def winfo_vrootx
+    TkWinfo.vrootx self
+  end
+  def TkWinfo.vrooty(window)
+    number(tk_call('winfo', 'vrooty', window.path))
+  end
+  def winfo_vrooty
+    TkWinfo.vrooty self
+  end
+  def TkWinfo.width(window)
+    number(tk_call('winfo', 'width', window.path))
+  end
+  def winfo_width
+    TkWinfo.width self
+  end
+  def TkWinfo.x(window)
+    number(tk_call('winfo', 'x', window.path))
+  end
+  def winfo_x
+    TkWinfo.x self
+  end
+  def TkWinfo.y(window)
+    number(tk_call('winfo', 'y', window.path))
+  end
+  def winfo_y
+    TkWinfo.y self
+  end
+  def TkWinfo.viewable(window)
+    bool(tk_call 'winfo', 'viewable', window.path)
+  end
+  def winfo_viewable
+    TkWinfo.viewable self
+  end
+  def TkWinfo.pointerx(window)
+    number(tk_call('winfo', 'pointerx', window.path))
+  end
+  def winfo_pointerx
+    TkWinfo.pointerx self
+  end
+  def TkWinfo.pointery(window)
+    number(tk_call('winfo', 'pointery', window.path))
+  end
+  def winfo_pointery
+    TkWinfo.pointery self
+  end
+  def TkWinfo.pointerxy(window)
+    list(tk_call('winfo', 'pointerxy', window.path))
+  end
+  def winfo_pointerxy
+    TkWinfo.pointerxy self
+  end
+end
+
+module TkPack
+  include Tk
+  extend Tk
+  def configure(win, *args)
+    if args[-1].kind_of?(Hash)
+      keys = args.pop
+    end
+    wins = [win.epath]
+    for i in args
+      wins.push i.epath
+    end
+    tk_call "pack", 'configure', *(wins+hash_kv(keys))
+  end
+
+  def forget(*args)
+    tk_call 'pack', 'forget' *args
+  end
+
+  def propagate(master, bool=None)
+    bool(tk_call('pack', 'propagate', master.epath, bool))
+  end
+  module_function :configure, :forget, :propagate
+end
+
+module TkGrid
+  include Tk
+  extend Tk
+
+  def bbox(*args)
+    list(tk_call('grid', 'bbox', *args))
+  end
+
+  def configure(widget, *args)
+    if args[-1].kind_of?(Hash)
+      keys = args.pop
+    end
+    wins = [widget.epath]
+    for i in args
+      wins.push i.epath
+    end
+    tk_call "grid", 'configure', *(wins+hash_kv(keys))
+  end
+
+  def columnconfigure(master, index, args)
+    tk_call "grid", 'columnconfigure', master, index, *hash_kv(args)
+  end
+
+  def rowconfigure(master, index, args)
+    tk_call "grid", 'rowconfigure', master, index, *hash_kv(args)
+  end
+
+  def add(widget, *args)
+    configure(widget, *args)
+  end
+
+  def forget(*args)
+    tk_call 'grid', 'forget', *args
+  end
+
+  def info(slave)
+    list(tk_call('grid', 'info', slave))
+  end
+
+  def location(master, x, y)
+    list(tk_call('grid', 'location', master, x, y))
+  end
+
+  def propagate(master, bool=None)
+    bool(tk_call('grid', 'propagate', master.epath, bool))
+  end
+
+  def remove(*args)
+    tk_call 'grid', 'remove', *args
+  end
+
+  def size(master)
+    tk_call 'grid', 'size', master
+  end
+
+  def slaves(args)
+    list(tk_call('grid', 'slaves', *hash_kv(args)))
+  end
+
+  module_function :bbox, :forget, :propagate, :info
+  module_function :remove, :size, :slaves, :location
+  module_function :configure, :columnconfigure, :rowconfigure
+end
+
+module TkOption
+  include Tk
+  extend Tk
+  def add pat, value, pri=None
+    tk_call 'option', 'add', pat, value, pri
+  end
+  def clear
+    tk_call '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
+end
+
+module TkTreatFont
+  def font_configinfo
+    ret = TkFont.used_on(self.path)
+    if ret == nil
+      ret = TkFont.init_widget_font(self.path, self.path, 'configure')
+    end
+    ret
+  end
+  alias fontobj font_configinfo
+
+  def font_configure(slot)
+    if (fnt = slot['font'])
+      slot['font'] = nil
+      if fnt.kind_of? TkFont
+	return fnt.call_font_configure(self.path, self.path,'configure',slot)
+      else
+	latinfont_configure(fnt) if fnt
+      end
+    end
+    if (ltn = slot['latinfont'])
+      slot['latinfont'] = nil
+      latinfont_configure(ltn) if ltn
+    end
+    if (ltn = slot['asciifont'])
+      slot['asciifont'] = nil
+      latinfont_configure(ltn) if ltn
+    end
+    if (knj = slot['kanjifont'])
+      slot['kanjifont'] = nil
+      kanjifont_configure(knj) if knj
+    end
+
+    tk_call(self.path, 'configure', *hash_kv(slot)) if slot != {}
+    self
+  end
+
+  def latinfont_configure(ltn, keys=nil)
+    fobj = fontobj
+    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
+  alias asciifont_configure latinfont_configure
+
+  def kanjifont_configure(knj, keys=nil)
+    fobj = fontobj
+    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(cond)
+      end
+    else
+      fobj.kanji_replace(knj)
+    end
+  end
+
+  def font_copy(window, tag=nil)
+    if tag
+      window.tagfontobj(tag).configinfo.each{|key,value|
+	fontobj.configure(key,value)
+      }
+      fontobj.replace(window.tagfontobj(tag).latin_font, 
+		      window.tagfontobj(tag).kanji_font)
+    else
+      window.fontobj.configinfo.each{|key,value|
+	fontobj.configure(key,value)
+      }
+      fontobj.replace(window.fontobj.latin_font, window.fontobj.kanji_font)
+    end
+  end
+
+  def latinfont_copy(window, tag=nil)
+    if tag
+      fontobj.latin_replace(window.tagfontobj(tag).latin_font)
+    else
+      fontobj.latin_replace(window.fontobj.latin_font)
+    end
+  end
+  alias asciifont_copy latinfont_copy
+
+  def kanjifont_copy(window, tag=nil)
+    if tag
+      fontobj.kanji_replace(window.tagfontobj(tag).kanji_font)
+    else
+      fontobj.kanji_replace(window.fontobj.kanji_font)
+    end
+  end
+end
+
+class TkObject<TkKernel
+  include Tk
+  include TkTreatFont
+
+  def path
+    return @path
+  end
+
+  def epath
+    return @path
+  end
+
+  def to_eval
+    @path
+  end
+
+  def tk_send(cmd, *rest)
+    tk_call path, cmd, *rest
+  end
+  private :tk_send
+
+  def method_missing(id, *args)
+    name = id.id2name
+    case args.length
+    when 1
+      configure name, args[0]
+    when 0
+      begin
+	cget name
+      rescue
+	fail NameError, "undefined local variable or method `#{name}' for #{self.to_s}", error_at
+      end
+    else
+      fail NameError, "undefined method `#{name}' for #{self.to_s}", error_at
+    end
+  end
+
+  def [](id)
+    cget id
+  end
+
+  def []=(id, val)
+    configure id, val
+  end
+
+  def cget(slot)
+    tk_tcl2ruby tk_call path, 'cget', "-#{slot}"
+  end
+
+  def configure(slot, value=None)
+    if slot.kind_of? Hash
+      if (slot['font'] || slot['kanjifont'] ||
+	  slot['latinfont'] || slot['asciifont'] )
+	font_configure(slot.dup)
+      else
+	tk_call path, 'configure', *hash_kv(slot)
+      end
+
+    else
+      if (slot == 'font' || slot == 'kanjifont' ||
+	  slot == 'latinfont' || slot == 'asciifont')
+	if value == None
+	  fontobj
+	else
+	  font_configure({slot=>value})
+	end
+      else
+	tk_call path, 'configure', "-#{slot}", value
+      end
+    end
+  end
+
+  def configure_cmd(slot, value)
+    configure slot, install_cmd(value)
+  end
+
+  def configinfo(slot = nil)
+    if slot == 'font' || slot == 'kanjifont'
+      fontobj
+    else
+      if slot
+	conf = tk_split_list(tk_send('configure', "-#{slot}") )
+	conf[0] = conf[0][1..-1]
+	conf
+      else
+	ret = tk_split_list(tk_send('configure') ).collect{|conf|
+	  conf[0] = conf[0][1..-1]
+	  conf
+	}
+	if ret.assoc('font')
+	  ret.delete_if{|item| item[0] == 'font' || item[0] == 'kanjifont'}
+	  ret.push(['font', fontobj])
+	else
+	  ret
+	end
+      end
+    end
+  end
+
+  def bind(context, cmd=Proc.new, args=nil)
+    _bind path, context, cmd, args
+  end
+
+  def bind_append(context, cmd=Proc.new, args=nil)
+    _bind_append path, context, cmd, args
+  end
+
+  def bindinfo(context=nil)
+    _bindinfo path, context
+  end
+
+  def event_generate(context, keys=nil)
+    if keys
+      tk_call('event', 'generate', path, 
+	      "<#{tk_event_sequence(context)}>", *hash_kv(keys))
+    else
+      tk_call('event', 'generate', path, "<#{tk_event_sequence(context)}>")
+    end
+  end
+
+  def tk_trace_variable(v)
+    unless v.kind_of?(TkVariable)
+      fail ArgumentError, format("requires TkVariable given %s", v.type)
+    end
+    v
+  end
+  private :tk_trace_variable
+
+  def destroy
+    tk_call 'trace', 'vdelete', @tk_vn, 'w', @var_id if @var_id
+  end
+end
+
+module TkClassBind
+  WidgetClassNameTBL = {}
+
+  def TkClassBind.name2class(name)
+    WidgetClassNameTBL[name]
+  end
+
+  def bind(context, cmd=Proc.new, args=nil)
+    Tk.bind to_eval, context, cmd, args
+  end
+
+  def bind_append(context, cmd=Proc.new, args=nil)
+    Tk.bind_append to_eval, context, cmd, args
+  end
+
+  def bindinfo(context=nil)
+    Tk.bindinfo to_eval, context
+  end
+end
+
+class TkWindow<TkObject
+  extend TkClassBind
+
+  def initialize(parent=nil, keys=nil)
+    install_win(if parent then parent.path end)
+    create_self
+    if keys
+      # tk_call @path, 'configure', *hash_kv(keys)
+      configure(keys)
+    end
+  end
+
+  def create_self
+  end
+  private :create_self
+
+  def pack(keys = nil)
+    tk_call 'pack', epath, *hash_kv(keys)
+    self
+  end
+
+  def unpack(keys = nil)
+    tk_call 'pack', 'forget', epath
+    self
+  end
+
+  def grid(keys = nil)
+    tk_call 'grid', epath, *hash_kv(keys)
+    self
+  end
+
+  def ungrid(keys = nil)
+    tk_call 'grid', 'forget', epath
+    self
+  end
+
+  def place(keys = nil)
+    tk_call 'place', epath, *hash_kv(keys)
+    self
+  end
+
+  def unplace(keys = nil)
+    tk_call 'place', 'forget', epath, *hash_kv(keys)
+    self
+  end
+  alias place_forget unplace
+
+  def place_config(keys)
+    tk_call "place", 'configure', epath, *hash_kv(keys)
+  end
+
+  def place_info()
+    ilist = list(tk_call('place', 'info', epath))
+    info = {}
+    while key = ilist.shift
+      info[key[1..-1]] = ilist.shift
+    end
+    return info
+  end
+
+  def pack_slaves()
+    list(tk_call('pack', 'slaves', epath))
+  end
+
+  def pack_info()
+    ilist = list(tk_call('pack', 'info', epath))
+    info = {}
+    while key = ilist.shift
+      info[key[1..-1]] = ilist.shift
+    end
+    return info
+  end
+
+  def place_slaves()
+    list(tk_call('place', 'slaves', epath))
+  end
+
+  def focus(force=false)
+    if force
+      tk_call 'focus', '-force', path
+    else
+      tk_call 'focus', path
+    end
+    self
+  end
+
+  def grab(*args)
+    if !args or args.length == 0
+      tk_call 'grab', 'set', path
+    elsif args.length == 1
+      case args[0]
+      when 'global'
+	tk_call 'grab', 'set', '-global', path
+      else
+	val = tk_call('grab', args[0], path)
+      end
+      case args[0]
+      when 'current'
+	return window(val)
+      when 'status'
+	return val
+      end
+    else
+      fail ArgumentError, 'wrong # of args'
+    end
+  end
+
+  def lower(below=None)
+    tk_call 'lower', path, below
+    self
+  end
+  def raise(above=None)
+    tk_call 'raise', path, above
+    self
+  end
+
+  def command(cmd=Proc.new)
+    configure_cmd 'command', cmd
+  end
+
+  def colormodel model=None
+    tk_call 'tk', 'colormodel', path, model
+    self
+  end
+
+  def destroy
+    tk_call 'destroy', path
+    if @cmdtbl
+      for id in @cmdtbl
+	uninstall_cmd id
+      end
+    end
+    uninstall_win
+  end
+
+  def wait_visibility
+    tk_call 'tkwait', 'visibility', path
+  end
+  alias wait wait_visibility
+
+  def wait_destroy
+    tk_call 'tkwait', 'window', path
+  end
+
+  def bindtags(taglist=nil)
+    if taglist
+      fail unless taglist.kind_of? Array
+      tk_call('bindtags', path, taglist)
+    else
+      tk_split_list(tk_call('bindtags', path)).collect{|tag|
+	if tag == nil
+	  '.'
+	elsif tag.kind_of?(String) && (cls = TkClassBind.name2class(tag))
+	  cls
+	else
+	  tag
+	end
+      }
+    end
+  end
+end
+
+class TkRoot<TkWindow
+  include Wm
+  ROOT = []
+  def TkRoot.new
+    return ROOT[0] if ROOT[0]
+    new = super
+    ROOT[0] = new
+    Tk_WINDOWS["."] = new
+  end
+
+  WidgetClassName = 'Tk'.freeze
+  TkClassBind::WidgetClassNameTBL[WidgetClassName] = self
+  def self.to_eval
+    WidgetClassName
+  end
+
+  def create_self
+    @path = '.'
+  end
+  def path
+    "."
+  end
+end
+
+class TkToplevel<TkWindow
+  include Wm
+
+  WidgetClassName = 'Toplevel'.freeze
+  TkClassBind::WidgetClassNameTBL[WidgetClassName] = self
+  def self.to_eval
+    WidgetClassName
+  end
+
+  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
+      if keys['classname']
+	@classname = keys['classname']
+	keys['classname'] = nil
+      end
+      if keys['colormap']
+	@colormap = keys['colormap']
+	keys['colormap'] = nil
+      end
+      if keys['container']
+	@classname = keys['container']
+	keys['classname'] = nil
+      end
+      if keys['screen']
+	@screen = keys['screen']
+	keys['screen'] = nil
+      end
+      if keys['use']
+	@use = keys['use']
+	keys['use'] = nil
+      end
+      if keys['visual']
+	@screen = keys['visual']
+	keys['visual'] = nil
+      end
+    end
+    super(parent, keys)
+  end
+
+  def create_self
+    s = []
+    s.push << "-class"     << @classname if @classname
+    s.push << "-colormap"  << @colormap  if @colormap
+    s.push << "-container" << @container if @container
+    s.push << "-screen"    << @screen    if @screen 
+    s.push << "-use"       << @use       if @use
+    s.push << "-visual"    << @visual    if @visual
+    tk_call 'toplevel', @path, *s
+  end
+
+  def specific_class
+    @classname
+  end
+end
+
+class TkFrame<TkWindow
+  WidgetClassName = 'Frame'.freeze
+  TkClassBind::WidgetClassNameTBL[WidgetClassName] = self
+  def self.to_eval
+    WidgetClassName
+  end
+
+  def initialize(parent=nil, keys=nil)
+    if keys.kind_of? Hash
+      keys = keys.dup
+      if keys['classname']
+	@classname = keys['classname']
+	keys['classname'] = nil
+      end
+      if keys['colormap']
+	@colormap = keys['colormap']
+	keys['colormap'] = nil
+      end
+      if keys['container']
+      @classname = keys['container']
+	keys['classname'] = nil
+      end
+      if keys['visual']
+	@screen = keys['visual']
+	keys['visual'] = nil
+      end
+    end
+    super(parent, keys)
+  end
+
+  def create_self
+    s = []
+    s.push << "-class"     << @classname if @classname
+    s.push << "-colormap"  << @colormap  if @colormap
+    s.push << "-container" << @container if @container
+    s.push << "-visual"    << @visual    if @visual
+    tk_call 'frame', @path, *s
+  end
+end
+
+class TkLabel<TkWindow
+  WidgetClassName = 'Label'.freeze
+  TkClassBind::WidgetClassNameTBL[WidgetClassName] = self
+  def self.to_eval
+    WidgetClassName
+  end
+  def create_self
+    tk_call 'label', @path
+  end
+  def textvariable(v)
+    configure 'textvariable', tk_trace_variable(v)
+  end
+end
+
+class TkButton<TkLabel
+  TkClassBind::WidgetClassNameTBL['Button'] = self
+  def TkButton.to_eval
+    'Button'
+  end
+  def create_self
+    tk_call 'button', @path
+  end
+  def invoke
+    tk_send 'invoke'
+  end
+  def flash
+    tk_send 'flash'
+  end
+end
+
+class TkRadioButton<TkButton
+  TkClassBind::WidgetClassNameTBL['Radiobutton'] = self
+  def TkRadioButton.to_eval
+    'Radiobutton'
+  end
+  def create_self
+    tk_call 'radiobutton', @path
+  end
+  def deselect
+    tk_send 'deselect'
+  end
+  def select
+    tk_send 'select'
+  end
+  def variable(v)
+    configure 'variable', tk_trace_variable(v)
+  end
+end
+
+class TkCheckButton<TkRadioButton
+  TkClassBind::WidgetClassNameTBL['Checkbutton'] = self
+  def TkCheckButton.to_eval
+    'Checkbutton'
+  end
+  def create_self
+    tk_call 'checkbutton', @path
+  end
+  def toggle
+    tk_send 'toggle'
+  end
+end
+
+class TkMessage<TkLabel
+  TkClassBind::WidgetClassNameTBL['Message'] = self
+  def TkMessage.to_eval
+    'Message'
+  end
+  def create_self
+    tk_call 'message', @path
+  end
+end
+
+class TkScale<TkWindow
+  WidgetClassName = 'Scale'.freeze
+  TkClassBind::WidgetClassNameTBL[WidgetClassName] = self
+  def self.to_eval
+    WidgetClassName
+  end
+
+  def create_self
+    tk_call 'scale', path
+  end
+
+  def get
+    number(tk_send('get'))
+  end
+
+  def set(val)
+    tk_send "set", val
+  end
+
+  def value
+    get
+  end
+
+  def value= (val)
+    set val
+  end
+end
+
+class TkScrollbar<TkWindow
+  WidgetClassName = 'Scrollbar'.freeze
+  TkClassBind::WidgetClassNameTBL[WidgetClassName] = self
+  def self.to_eval
+    WidgetClassName
+  end
+
+  def create_self
+    tk_call 'scrollbar', path
+  end
+
+  def delta(deltax=None, deltay=None)
+    number(tk_send('delta', deltax, deltay))
+  end
+
+  def fraction(x=None, y=None)
+    number(tk_send('fraction', x, y))
+  end
+
+  def identify(x=None, y=None)
+    tk_send('fraction', x, y)
+  end
+
+  def get
+    ary1 = tk_send('get').split
+    ary2 = []
+    for i in ary1
+      ary2.push number(i)
+    end
+    ary2
+  end
+
+  def set(first, last)
+    tk_send "set", first, last
+  end
+end
+
+class TkTextWin<TkWindow
+  def create_self
+    raise TypeError, "TkTextWin is abstract class"
+  end
+
+  def bbox(index)
+    tk_send 'bbox', index
+  end
+  def delete(first, last=None)
+    tk_send 'delete', first, last
+  end
+  def get(*index)
+    tk_send 'get', *index
+  end
+  def index(index)
+    tk_send 'index', index
+  end
+  def insert(index, chars, *args)
+    tk_send 'insert', index, chars, *args
+  end
+  def scan_mark(x, y)
+    tk_send 'scan', 'mark', x, y
+  end
+  def scan_dragto(x, y)
+    tk_send 'scan', 'dragto', x, y
+  end
+  def see(index)
+    tk_send 'see', index
+  end
+end
+
+class TkListbox<TkTextWin
+  TkClassBind::WidgetClassNameTBL['Listbox'] = self
+  def TkListbox.to_eval
+    'Listbox'
+  end
+  def create_self
+    tk_call 'listbox', path
+  end
+
+  def activate(y)
+    tk_send 'activate', y
+  end
+  def curselection
+    list(tk_send('curselection'))
+  end
+  def nearest(y)
+    tk_send('nearest', y).to_i
+  end
+  def size(y)
+    tk_send('size').to_i
+  end
+  def selection_anchor(index)
+    tk_send 'selection', 'anchor', index
+  end
+  def selection_clear(first, last=None)
+    tk_send 'selection', 'clear', first, last
+  end
+  def selection_includes
+    bool(tk_send('selection', 'includes'))
+  end
+  def selection_set(first, last=None)
+    tk_send 'selection', 'set', first, last
+  end
+  def xview(cmd, *more)
+    v = tk_send('xview', cmd, *more)
+    v.to_i if more.size == 0
+  end
+  def yview(cmd, *more)
+    v = tk_send('yview', cmd, *more)
+    v.to_i if more.size == 0
+  end
+end
+
+module TkTreatMenuEntryFont
+  def tagfont_configinfo(index)
+    pathname = self.path + ';' + index
+    ret = TkFont.used_on(pathname)
+    if ret == nil
+      ret = TkFont.init_widget_font(pathname, 
+				    self.path, 'entryconfigure', index)
+    end
+    ret
+  end
+  alias tagfontobj tagfont_configinfo
+
+  def tagfont_configure(index, slot)
+    pathname = self.path + ';' + index
+    if (fnt = slot['font'])
+      slot['font'] = nil
+      if fnt.kind_of? TkFont
+	return fnt.call_font_configure(pathname, 
+				       self.path,'entryconfigure',index,slot)
+      else
+	latintagfont_configure(index, fnt) if fnt
+      end
+    end
+    if (ltn = slot['latinfont'])
+      slot['latinfont'] = nil
+      latintagfont_configure(index, ltn) if ltn
+    end
+    if (ltn = slot['asciifont'])
+      slot['asciifont'] = nil
+      latintagfont_configure(index, ltn) if ltn
+    end
+    if (knj = slot['kanjifont'])
+      slot['kanjifont'] = nil
+      kanjitagfont_configure(index, knj) if knj
+    end
+
+    tk_call(self.path, 'entryconfigure', index, *hash_kv(slot)) if slot != {}
+    self
+  end
+
+  def latintagfont_configure(index, ltn, keys=nil)
+    fobj = tagfontobj(index)
+    if ltn.kind_of? TkFont
+      conf = {}
+      ltn.latin_configinfo.each{|key,val| conf[key] = val if val != []}
+      if conf == {}
+	fobj.latin_replace(ltn)
+	fobj.latin_configure(keys) if keys
+      elsif keys
+	fobj.latin_configure(conf.update(keys))
+      else
+	fobj.latin_configure(conf)
+      end
+    else
+      fobj.latin_replace(ltn)
+    end
+  end
+  alias asciitagfont_configure latintagfont_configure
+
+  def kanjitagfont_configure(index, knj, keys=nil)
+    fobj = tagfontobj(index)
+    if knj.kind_of? TkFont
+      conf = {}
+      knj.kanji_configinfo.each{|key,val| conf[key] = val if val != []}
+      if conf == {}
+	fobj.kanji_replace(knj)
+	fobj.kanji_configure(keys) if keys
+      elsif keys
+	fobj.kanji_configure(conf.update(keys))
+      else
+	fobj.kanji_configure(conf)
+      end
+    else
+      fobj.kanji_replace(knj)
+    end
+  end
+
+  def tagfont_copy(index, window, wintag=nil)
+    if wintag
+      window.tagfontobj(wintag).configinfo.each{|key,value|
+	tagfontobj(index).configure(key,value)
+      }
+      tagfontobj(index).replace(window.tagfontobj(wintag).latin_font, 
+			      window.tagfontobj(wintag).kanji_font)
+    else
+      window.tagfont(wintag).configinfo.each{|key,value|
+	tagfontobj(index).configure(key,value)
+      }
+      tagfontobj(index).replace(window.fontobj.latin_font, 
+			      window.fontobj.kanji_font)
+    end
+  end
+
+  def latintagfont_copy(index, window, wintag=nil)
+    if wintag
+      tagfontobj(index).latin_replace(window.tagfontobj(wintag).latin_font)
+    else
+      tagfontobj(index).latin_replace(window.fontobj.latin_font)
+    end
+  end
+  alias asciitagfont_copy latintagfont_copy
+
+  def kanjitagfont_copy(index, window, wintag=nil)
+    if wintag
+      tagfontobj(index).kanji_replace(window.tagfontobj(wintag).kanji_font)
+    else
+      tagfontobj(index).kanji_replace(window.fontobj.kanji_font)
+    end
+  end
+end
+
+class TkMenu<TkWindow
+  include TkTreatMenuEntryFont
+
+  WidgetClassName = 'Menu'.freeze
+  TkClassBind::WidgetClassNameTBL[WidgetClassName] = self
+  def self.to_eval
+    WidgetClassName
+  end
+  def create_self
+    tk_call 'menu', path
+  end
+  def activate(index)
+    tk_send 'activate', index
+  end
+  def add(type, keys=nil)
+    tk_send 'add', type, *hash_kv(keys)
+  end
+  def index(index)
+    tk_send 'index', index
+  end
+  def invoke(index)
+    tk_send 'invoke', index
+  end
+  def insert(index, type, keys=nil)
+    tk_send 'add', index, type, *hash_kv(keys)
+  end
+  def delete(index, last=None)
+    tk_send 'delete', index, last
+  end
+  def post(x, y)
+    tk_send 'post', x, y
+  end
+  def postcascade(index)
+    tk_send 'postcascade', index
+  end
+  def postcommand(cmd=Proc.new)
+    configure_cmd 'postcommand', cmd
+  end
+  def menutype(index)
+    tk_send 'type', index
+  end
+  def unpost
+    tk_send 'unpost'
+  end
+  def yposition(index)
+    number(tk_send('yposition', index))
+  end
+  def entrycget(index, key)
+    tk_tcl2ruby tk_send 'entrycget', index, "-#{key}"
+  end
+  def entryconfigure(index, key, val=None)
+    if key.kind_of? Hash
+      if (key['font'] || key['kanjifont'] ||
+	  key['latinfont'] || key['asciifont'])
+	tagfont_configure(index, key.dup)
+      else
+	tk_send 'entryconfigure', index, *hash_kv(key)
+      end
+
+    else
+      if (key == 'font' || key == 'kanjifont' ||
+	  key == 'latinfont' || key == 'asciifont' )
+	tagfont_configure({key=>val})
+      else
+	tk_call 'entryconfigure', index, "-#{key}", val
+      end
+    end
+  end
+
+  def entryconfiginfo(index, key=nil)
+    if key
+      conf = tk_split_list(tk_send('entryconfigure',index,"-#{key}"))
+      conf[0] = conf[0][1..-1]
+      conf
+    else
+      tk_split_list(tk_send('entryconfigure', index)).collect{|conf|
+	conf[0] = conf[0][1..-1]
+	conf
+      }
+    end
+  end
+end
+
+class TkMenubutton<TkLabel
+  TkClassBind::WidgetClassNameTBL['Menubutton'] = self
+  def TkMenubutton.to_eval
+    'Menubutton'
+  end
+  def create_self
+    tk_call 'menubutton', path
+  end
+end
+
+module TkComposite
+  include Tk
+  extend Tk
+
+  def initialize(parent=nil, *args)
+    @frame = TkFrame.new(parent)
+    @path = @epath = @frame.path
+    initialize_composite(*args)
+  end
+
+  def epath
+    @epath
+  end
+
+  def initialize_composite(*args) end
+  private :initialize_composite
+
+  def delegate(option, *wins)
+    unless @delegates
+      @delegates = {} 
+      @delegates['DEFAULT'] = @frame
+    end
+    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
+
+module TkClipboard
+  include Tk
+  extend Tk
+
+  def clear
+    tk_call 'clipboard', 'clear'
+  end
+  def get
+    begin
+      tk_call 'selection', 'get', '-selection', 'CLIPBOARD'
+    rescue
+      ''
+    end
+  end
+  def set(data)
+    clear
+    append(data)
+  end
+  def append(data)
+    tk_call 'clipboard', 'append', data
+  end
+
+  module_function :clear, :set, :get, :append
+end
+
+autoload :TkCanvas, 'tkcanvas'
+autoload :TkImage, 'tkcanvas'
+autoload :TkBitmapImage, 'tkcanvas'
+autoload :TkPhotoImage, 'tkcanvas'
+autoload :TkEntry, 'tkentry'
+autoload :TkText, 'tktext'
+autoload :TkDialog, 'tkdialog'
+autoload :TkMenubar, 'tkmenubar'
+autoload :TkAfter, 'tkafter'
+autoload :TkPalette, 'tkpalette'
+autoload :TkFont, 'tkfont'
+autoload :TkVirtualEvent, 'tkvirtevent'
diff --git a/ext/tk/lib/tkafter.rb b/ext/tk/lib/tkafter.rb
new file mode 100644
index 0000000000..be2e50ff3a
--- /dev/null
+++ b/ext/tk/lib/tkafter.rb
@@ -0,0 +1,296 @@
+#
+#   tkafter.rb : methods for Tcl/Tk after command
+#                     1998/07/02 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+require 'tk'
+
+class TkAfter
+  include TkCore
+  extend TkCore
+
+  Tk_CBID = [0]
+  Tk_CBTBL = {}
+
+  INTERP._invoke("proc", "rb_after", "args", "ruby [format \"TkAfter.callback %%Q!%s!\" $args]")
+
+  ###############################
+  # class methods
+  ###############################
+  def TkAfter.callback(arg)
+    @after_id = nil
+    arg = Array(tk_split_list(arg))
+    obj_id = arg.shift
+    ex_obj = Tk_CBTBL[obj_id]
+    return nil if ex_obj == nil; # canceled
+    _get_eval_string(ex_obj.do_callback(*arg))
+  end
+
+  def TkAfter.info
+    tk_call('after', 'info').split(' ').filter{|id|
+      ret = Tk_CBTBL.find{|key,val| val.after_id == id}
+      (ret == nil)? id: ret[1]
+    }
+  end
+
+  ###############################
+  # instance methods
+  ###############################
+  def do_callback(*args)
+    @in_callback = true
+    ret = @current_proc.call(*args)
+    if @set_next
+      set_next_callback(*args)
+    else
+      @set_next = true
+    end
+    @in_callback = false
+    ret
+  end
+
+  def set_callback(sleep, args=nil)
+    @after_script = "rb_after #{@id} #{_get_eval_string(args)}"
+    @after_id = tk_call('after', sleep, @after_script)
+    @current_script = [sleep, @after_script]
+  end
+
+  def set_next_callback(*args)
+    if @running == false || @proc_max == 0 || @do_loop == 0
+      Tk_CBTBL[@id] = nil ;# for GC
+      @running = false
+      return
+    end
+    if @current_pos >= @proc_max
+      if @do_loop < 0 || (@do_loop -= 1) > 0
+	@current_pos = 0
+      else
+	Tk_CBTBL[@id] = nil ;# for GC
+	@running = false
+	return
+      end
+    end
+
+    @current_args = args
+
+    if @sleep_time.kind_of? Proc
+      sleep = @sleep_time.call(*args)
+    else
+      sleep = @sleep_time
+    end
+    @current_sleep = sleep
+
+    cmd, *cmd_args = @loop_proc[@current_pos]
+    @current_pos += 1
+    @current_proc = cmd
+
+    if cmd_args[0].kind_of? Proc
+      #c = cmd_args.shift
+      #cb_args = c.call(*(cmd_args + args))
+      cb_args = cmd_args[0].call(*args)
+    else
+      cb_args = cmd_args
+    end
+
+    set_callback(sleep, cb_args)
+  end
+
+  def initialize(*args)
+    @id = format("a%.4d", Tk_CBID[0])
+    Tk_CBID[0] += 1
+
+    @set_next = true
+
+    @init_sleep = 0
+    @init_proc = nil
+    @init_args = []
+
+    @current_script = []
+    @current_proc = nil
+    @current_args = 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
+
+    set_procs(*args) if args != []
+
+    @running = false
+  end
+
+  attr :after_id
+  attr :after_script
+  attr :current_proc
+  attr :current_sleep
+
+  attr_accessor :loop_exec
+
+  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]
+  end
+
+  def running?
+    @running
+  end
+
+  def loop_rest
+    @do_loop
+  end
+
+  def loop_rest=(rest)
+    @do_loop = rest
+  end
+
+  def set_procs(interval, loop_exec, *procs)
+    if !interval == 'idle' \
+       && !interval.kind_of?(Integer) && !interval.kind_of?(Proc)
+      fail format("%s need to be Integer or Proc", interval.inspect)
+    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 format("%s need to be Integer", loop_exec.inspect)
+	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 set_start_proc(sleep, init_proc, *init_args)
+    if !sleep == 'idle' && !sleep.kind_of?(Integer)
+      fail format("%s need to be Integer", sleep.inspect)
+    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 format("%s need to be Integer", sleep.inspect)
+      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 format("%s need to be Proc", @init_proc.inspect)
+      end
+      @current_proc = @init_proc
+      set_callback(sleep, @init_args)
+      @set_next = false if @in_callback
+    else
+      set_next_callback(*@init_args)
+    end
+
+    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
+    tk_call 'after', 'cancel', @after_id if @after_id
+    @after_id = nil
+    Tk_CBTBL[@id] = nil ;# for GC
+    self
+  end
+  alias stop cancel
+
+  def continue(wait=nil)
+    sleep, cmd = @current_script
+    return nil if cmd == nil || @running == true
+    if wait
+      if not wait.kind_of? Integer
+	fail format("%s need to be Integer", wait.inspect)
+      end
+      sleep = wait
+    end
+    Tk_CBTBL[@id] = self
+    @running = true
+    @after_id = tk_call('after', sleep, cmd)
+    self
+  end
+
+  def skip
+    return nil if @running == false
+    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('after', 'info', @after_id))
+      [Tk_CBTBL[inf[0][1]], inf[1]]
+    else
+      nil
+    end
+  end
+end
diff --git a/ext/tk/lib/tkbgerror.rb b/ext/tk/lib/tkbgerror.rb
new file mode 100644
index 0000000000..8022077a3f
--- /dev/null
+++ b/ext/tk/lib/tkbgerror.rb
@@ -0,0 +1,17 @@
+#
+#  tkbgerror -- bgerror ( tkerror ) module
+#                     1998/07/16 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+require 'tk'
+
+module TkBgError
+  extend Tk
+
+  def bgerror(message)
+    tk_call 'bgerror', message
+  end
+  alias tkerror bgerror
+  alias show bgerror
+
+  module_function :bgerror, :tkerror, :show
+end
diff --git a/ext/tk/lib/tkcanvas.rb b/ext/tk/lib/tkcanvas.rb
new file mode 100644
index 0000000000..1cf24eeb7b
--- /dev/null
+++ b/ext/tk/lib/tkcanvas.rb
@@ -0,0 +1,829 @@
+#
+#		tkcanvas.rb - Tk canvas classes
+#			$Date$
+#			by Yukihiro Matsumoto <matz@caelum.co.jp>
+#			$Date$
+#			by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+
+require "tk"
+require 'tkfont'
+
+module TkTreatCItemFont
+  def tagfont_configinfo(tagOrId)
+    if tagOrId.kind_of?(TkcItem) || tagOrId.kind_of?(TkcTag)
+      pathname = self.path + ';' + tagOrId.id.to_s
+    else
+      pathname = self.path + ';' + tagOrId.to_s
+    end
+    ret = TkFont.used_on(pathname)
+    if ret == nil
+      ret = TkFont.init_widget_font(pathname, 
+				    self.path, 'itemconfigure', tagOrId)
+    end
+    ret
+  end
+  alias tagfontobj tagfont_configinfo
+
+  def tagfont_configure(tagOrId, slot)
+    if tagOrId.kind_of?(TkcItem) || tagOrId.kind_of?(TkcTag)
+      pathname = self.path + ';' + tagOrId.id.to_s
+    else
+      pathname = self.path + ';' + tagOrId.to_s
+    end
+    if (fnt = slot['font'])
+      slot['font'] = nil
+      if fnt.kind_of? TkFont
+	return fnt.call_font_configure(pathname, 
+				       self.path,'itemconfigure',tagOrId,slot)
+      else
+	latintagfont_configure(tagOrId, fnt) if fnt
+      end
+    end
+    if (ltn = slot['latinfont'])
+      slot['latinfont'] = nil
+      latintagfont_configure(tagOrId, ltn) if ltn
+    end
+    if (ltn = slot['asciifont'])
+      slot['asciifont'] = nil
+      latintagfont_configure(tagOrId, ltn) if ltn
+    end
+    if (knj = slot['kanjifont'])
+      slot['kanjifont'] = nil
+      kanjitagfont_configure(tagOrId, knj) if knj
+    end
+
+    tk_call(self.path, 'itemconfigure', tagOrId, *hash_kv(slot)) if slot != {}
+    self
+  end
+
+  def latintagfont_configure(tagOrId, ltn, keys=nil)
+    fobj = tagfontobj(tagOrId)
+    if ltn.kind_of? TkFont
+      conf = {}
+      ltn.latin_configinfo.each{|key,val| conf[key] = val if val != []}
+      if conf == {}
+	fobj.latin_replace(ltn)
+	fobj.latin_configure(keys) if keys
+      elsif keys
+	fobj.latin_configure(conf.update(keys))
+      else
+	fobj.latin_configure(conf)
+      end
+    else
+      fobj.latin_replace(ltn)
+    end
+  end
+  alias asciitagfont_configure latintagfont_configure
+
+  def kanjitagfont_configure(tagOrId, knj, keys=nil)
+    fobj = tagfontobj(tagOrId)
+    if knj.kind_of? TkFont
+      conf = {}
+      knj.kanji_configinfo.each{|key,val| conf[key] = val if val != []}
+      if conf == {}
+	fobj.kanji_replace(knj)
+	fobj.kanji_configure(keys) if keys
+      elsif keys
+	fobj.kanji_configure(conf.update(keys))
+      else
+	fobj.kanji_configure(conf)
+      end
+    else
+      fobj.kanji_replace(knj)
+    end
+  end
+
+  def tagfont_copy(tagOrId, window, wintag=nil)
+    if wintag
+      window.tagfontobj(wintag).configinfo.each{|key,value|
+	tagfontobj(tagOrId).configure(key,value)
+      }
+      tagfontobj(tagOrId).replace(window.tagfontobj(wintag).latin_font, 
+				  window.tagfontobj(wintag).kanji_font)
+    else
+      window.tagfont(tagOrId).configinfo.each{|key,value|
+	tagfontobj(tagOrId).configure(key,value)
+      }
+      tagfontobj(tagOrId).replace(window.fontobj.latin_font, 
+				  window.fontobj.kanji_font)
+    end
+  end
+
+  def latintagfont_copy(tagOrId, window, wintag=nil)
+    if wintag
+      tagfontobj(tagOrId).latin_replace(window.tagfontobj(wintag).latin_font)
+    else
+      tagfontobj(tagOrId).latin_replace(window.fontobj.latin_font)
+    end
+  end
+  alias asciitagfont_copy latintagfont_copy
+
+  def kanjitagfont_copy(tagOrId, window, wintag=nil)
+    if wintag
+      tagfontobj(tagOrId).kanji_replace(window.tagfontobj(wintag).kanji_font)
+    else
+      tagfontobj(tagOrId).kanji_replace(window.fontobj.kanji_font)
+    end
+  end
+end
+
+class TkCanvas<TkWindow
+  include TkTreatCItemFont
+
+  WidgetClassName = 'Canvas'.freeze
+  TkClassBind::WidgetClassNameTBL[WidgetClassName] = self
+  def self.to_eval
+    WidgetClassName
+  end
+
+  def create_self
+    tk_call 'canvas', path
+  end
+
+  def tagid(tag)
+    if tag.kind_of?(TkcItem) || tag.kind_of?(TkcTag)
+      tag.id
+    else
+      tag
+    end
+  end
+  private :tagid
+
+  def addtag(tag, mode, *args)
+    tk_send 'addtag', tagid(tag), mode, *args
+  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('bbox', tagid(tagOrId), *tags))
+  end
+
+  def itembind(tag, context, cmd=Proc.new, args=nil)
+    id = install_bind(cmd, args)
+    begin
+      tk_send 'bind', tagid(tag), "<#{tk_event_sequence(context)}>", id
+    rescue
+      uninstall_cmd(cmd)
+      fail
+    end
+    # @cmdtbl.push id
+  end
+
+  def itembindinfo(tag, context=nil)
+    if context
+      (tk_send('bind', tagid(tag), 
+	       "<#{tk_event_sequence(context)}>")).collect{|cmdline|
+	if cmdline =~ /^rb_out (c\d+)\s+(.*)$/
+	  [Tk_CMDTBL[$1], $2]
+	else
+	  cmdline
+	end
+      }
+    else
+      tk_split_list(tk_send 'bind', tagid(tag)).filter{|seq|
+	seq[1..-2].gsub(/></,',')
+      }
+    end
+  end
+
+  def canvasx(x, *args)
+    tk_tcl2ruby(tk_send 'canvasx', x, *args)
+  end
+  def canvasy(y, *args)
+    tk_tcl2ruby(tk_send 'canvasy', y, *args)
+  end
+
+  def coords(tag, *args)
+    if args == []
+      tk_split_list(tk_send('coords', tagid(tag)))
+    else
+      tk_send('coords', tagid(tag), *args)
+    end
+  end
+
+  def dchars(tag, first, last=None)
+    tk_send 'dchars', tagid(tag), first, last
+  end
+
+  def delete(*args)
+    tk_send 'delete', *args
+  end
+  alias remove delete
+
+  def dtag(tag, tag_to_del=None)
+    tk_send 'dtag', tagid(tag), tag_to_del
+  end
+
+  def find(mode, *args)
+    list(tk_send 'find', mode, *args).filter{|id| 
+      TkcItem.id2obj(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 'focus', tagid(tagOrId)
+    else
+      ret = tk_send('focus')
+      if ret == ""
+	nil
+      else
+	TkcItem.id2obj(ret)
+      end
+    end
+  end
+
+  def gettags(tagOrId)
+    list(tk_send('gettags', tagid(tagOrId))).collect{|tag|
+      TkcTag.id2obj(tag)
+    }
+  end
+
+  def icursor(tagOrId, index)
+    tk_send 'icursor', tagid(tagOrId), index
+  end
+
+  def index(tagOrId, index)
+    tk_send 'index', tagid(tagOrId), index
+  end
+
+  def insert(tagOrId, index, string)
+    tk_send 'insert', tagid(tagOrId), index, string
+  end
+
+  def itemcget(tagOrId, option)
+    tk_tcl2ruby tk_send 'itemcget', tagid(tagOrId), "-#{option}"
+  end
+
+  def itemconfigure(tagOrId, key, value=None)
+    if key.kind_of? Hash
+      if ( key['font'] || key['kanjifont'] \
+	  || key['latinfont'] || key['asciifont'] )
+	tagfont_configure(tagOrId, key.dup)
+      else
+	tk_send 'itemconfigure', tagid(tagOrId), *hash_kv(key)
+      end
+
+    else
+      if ( key == 'font' || key == 'kanjifont' \
+	  || key == 'latinfont' || key == 'asciifont' )
+	tagfont_configure(tagid(tagOrId), {key=>value})
+      else
+	tk_send 'itemconfigure', tagid(tagOrId), "-#{key}", value
+      end
+    end
+  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 key
+      conf = tk_split_list(tk_send 'itemconfigure', tagid(tagOrId), "-#{key}")
+      conf[0] = conf[0][1..-1]
+      conf
+    else
+      tk_split_list(tk_send 'itemconfigure', tagid(tagOrId)).collect{|conf|
+	conf[0] = conf[0][1..-1]
+	conf
+      }
+    end
+  end
+
+  def lower(tag, below=None)
+    tk_send 'lower', tagid(tag), below
+  end
+
+  def move(tag, x, y)
+    tk_send 'move', tagid(tag), x, y
+  end
+
+  def postscript(keys)
+    tk_send "postscript", *hash_kv(keys)
+  end
+
+  def raise(tag, above=None)
+    tk_send 'raise', tagid(tag), above
+  end
+
+  def scale(tag, x, y, xs, ys)
+    tk_send 'scale', tagid(tag), x, y, xs, ys
+  end
+
+  def scan_mark(x, y)
+    tk_send 'scan', 'mark', x, y
+  end
+  def scan_dragto(x, y)
+    tk_send 'scan', 'dragto', x, y
+  end
+
+  def select(mode, *args)
+    tk_send 'select', mode, *args
+  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
+
+  def xview(*index)
+    tk_send 'xview', *index
+  end
+  def yview(*index)
+    tk_send 'yview', *index
+  end
+end
+
+module TkcTagAccess
+  include TkComm
+  include TkTreatTagFont
+
+  def addtag(tag)
+    @c.addtag(tag, 'with', @id)
+  end
+
+  def bbox
+    @c.bbox(@id)
+  end
+
+  def bind(seq, cmd=Proc.new, args=nil)
+    @c.itembind @id, seq, cmd, args
+  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
+  end
+#  def configure(keys)
+#    @c.itemconfigure @id, keys
+#  end
+
+  def configinfo(key=nil)
+    @c.itemconfiginfo @id, key
+  end
+
+  def coords(*args)
+    @c.coords @id, *args
+  end
+
+  def dchars(first, last=None)
+    @c.dchars @id, first, last
+  end
+
+  def dtag(tag_to_del=None)
+    @c.dtag @id, tag_to_del
+  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
+  end
+
+  def index(index)
+    @c.index @id, index
+  end
+
+  def insert(beforethis, string)
+    @c.insert @id, beforethis, string
+  end
+
+  def lower(belowthis=None)
+    @c.lower @id, belowthis
+  end
+
+  def move(xamount, yamount)
+    @c.move @id, xamount, yamount
+  end
+
+  def raise(abovethis=None)
+    @c.raise @id, abovethis
+  end
+
+  def scale(xorigin, yorigin, xscale, yscale)
+    @c.scale @id, xorigin, yorigin, xscale, yscale
+  end
+
+  def select_adjust(index)
+    @c.select('adjust', @id, index)
+  end
+  def select_from(index)
+    @c.select('from', @id, index)
+  end
+  def select_to(index)
+    @c.select('to', @id, index)
+  end
+
+  def itemtype
+    @c.itemtype @id
+  end
+end
+
+class TkcTag<TkObject
+  include TkcTagAccess
+
+  CTagID_TBL = {}
+
+  def TkcTag.id2obj(id)
+    CTagID_TBL[id]? CTagID_TBL[id]: id
+  end
+
+  $tk_canvas_tag = 'ctag0000'
+  def initialize(parent, mode=nil, *args)
+    if not parent.kind_of?(TkCanvas)
+      fail format("%s need to be TkCanvas", parent.inspect)
+    end
+    @c = parent
+    @path = @id = $tk_canvas_tag
+    CTagID_TBL[@id] = self
+    $tk_canvas_tag = $tk_canvas_tag.succ
+    if mode
+      tk_call @c.path, "addtag", @id, mode, *args
+    end
+  end
+  def id
+    return @id
+  end
+
+  def delete
+    @c.delete @id
+    CTagID_TBL[@id] = nil
+  end
+  alias remove  delete
+  alias destroy delete
+
+  def set_to_above(target)
+    @c.addtag_above(@id, target)
+  end
+  alias above set_to_above
+
+  def set_to_all
+    @c.addtag_all(@id)
+  end
+  alias all set_to_all
+
+  def set_to_below(target)
+    @c.addtag_below(@id, target)
+  end
+  alias below set_to_below
+
+  def set_to_closest(x, y, halo=None, start=None)
+    @c.addtag_closest(@id, x, y, halo, start)
+  end
+  alias closest set_to_closest
+
+  def set_to_enclosed(x1, y1, x2, y2)
+    @c.addtag_enclosest(@id, x1, y1, x2, y2)
+  end
+  alias enclosed set_to_enclosed
+
+  def set_to_overlapping(x1, y1, x2, y2)
+    @c.addtag_overlapping(@id, x1, y1, x2, y2)
+  end
+  alias overlapping set_to_overlapping
+
+  def set_to_withtag(target)
+    @c.addtag_withtag(@id, target)
+  end
+  alias withtag set_to_withtag
+end
+
+class TkcTagAll<TkcTag
+  def initialize(parent)
+    if not parent.kind_of?(TkCanvas)
+      fail format("%s need to be TkCanvas", parent.inspect)
+    end
+    @c = parent
+    @path = @id = 'all'
+    CTagID_TBL[@id] = self
+  end
+end
+
+class TkcTagCurrent<TkcTag
+  def initialize(parent)
+    if not parent.kind_of?(TkCanvas)
+      fail format("%s need to be TkCanvas", parent.inspect)
+    end
+    @c = parent
+    @path = @id = 'current'
+    CTagID_TBL[@id] = self
+  end
+end
+
+class TkcGroup<TkcTag
+  $tk_group_id = 'tkg00000'
+  def create_self(parent, *args)
+    if not parent.kind_of?(TkCanvas)
+      fail format("%s need to be TkCanvas", parent.inspect)
+    end
+    @c = parent
+    @path = @id = $tk_group_id
+    CTagID_TBL[@id] = self
+    $tk_group_id = $tk_group_id.succ
+    add(*args) if args != []
+  end
+  
+  def include(*tags)
+    for i in tags
+      i.addtag @id
+    end
+  end
+
+  def exclude(*tags)
+    for i in tags
+      i.delete @id
+    end
+  end
+end
+
+
+class TkcItem<TkObject
+  include TkcTagAccess
+
+  CItemTypeToClass = {}
+  CItemID_TBL = {}
+
+  def TkcItem.type2class(type)
+    CItemTypeToClass[type]
+  end
+
+  def TkcItem.id2obj(id)
+    CItemID_TBL[id]? CItemID_TBL[id]: id
+  end
+
+  def initialize(parent, *args)
+    if not parent.kind_of?(TkCanvas)
+      fail format("%s need to be TkCanvas", parent.inspect)
+    end
+    @parent = @c = parent
+    @path = parent.path
+    if args[-1].kind_of? Hash
+      keys = args.pop
+    end
+    @id = create_self(*args).to_i ;# 'canvas item id' is integer number
+    CItemID_TBL[@id] = self
+    if keys
+      # tk_call @path, 'itemconfigure', @id, *hash_kv(keys)
+      configure(keys) if keys
+    end
+  end
+  def create_self(*args); end
+  private :create_self
+  def id
+    return @id
+  end
+
+  def delete
+    @c.delete @id
+    CItemID_TBL[@id] = nil
+  end
+  alias remove  delete
+  alias destroy delete
+end
+
+class TkcArc<TkcItem
+  CItemTypeToClass['arc'] = self
+  def create_self(*args)
+    tk_call(@path, 'create', 'arc', *args)
+  end
+end
+class TkcBitmap<TkcItem
+  CItemTypeToClass['bitmap'] = self
+  def create_self(*args)
+    tk_call(@path, 'create', 'bitmap', *args)
+  end
+end
+class TkcImage<TkcItem
+  CItemTypeToClass['image'] = self
+  def create_self(*args)
+    tk_call(@path, 'create', 'image', *args)
+  end
+end
+class TkcLine<TkcItem
+  CItemTypeToClass['line'] = self
+  def create_self(*args)
+    tk_call(@path, 'create', 'line', *args)
+  end
+end
+class TkcOval<TkcItem
+  CItemTypeToClass['oval'] = self
+  def create_self(*args)
+    tk_call(@path, 'create', 'oval', *args)
+  end
+end
+class TkcPolygon<TkcItem
+  CItemTypeToClass['polygon'] = self
+  def create_self(*args)
+    tk_call(@path, 'create', 'polygon', *args)
+  end
+end
+class TkcRectangle<TkcItem
+  CItemTypeToClass['rectangle'] = self
+  def create_self(*args)
+    tk_call(@path, 'create', 'rectangle', *args)
+  end
+end
+class TkcText<TkcItem
+  CItemTypeToClass['text'] = self
+  def create_self(*args)
+    tk_call(@path, 'create', 'text', *args)
+  end
+end
+class TkcWindow<TkcItem
+  CItemTypeToClass['window'] = self
+  def create_self(*args)
+    tk_call(@path, 'create', 'window', *args)
+  end
+end
+
+class TkImage<TkObject
+  include Tk
+
+  Tk_IMGTBL = {}
+
+  $tk_image_id = 'i00000'
+  def initialize(keys=nil)
+    @path = $tk_image_id
+    $tk_image_id = $tk_image_id.succ
+    tk_call 'image', 'create', @type, @path, *hash_kv(keys)
+    Tk_IMGTBL[@path] = self
+  end
+
+  def delete
+    Tk_IMGTBL[@id] = nil if @id
+    tk_call('image', 'delete', @path)
+  end
+  def height
+    number(tk_call('image', 'height', @path))
+  end
+  def itemtype
+    tk_call('image', 'type', @path)
+  end
+  def width
+    number(tk_call('image', 'width', @path))
+  end
+
+  def TkImage.names
+    Tk.tk_call('image', 'names').split.filter{|id|
+      (Tk_IMGTBL[id])? Tk_IMGTBL[id] : id
+    }
+  end
+
+  def TkImage.types
+    Tk.tk_call('image', 'types').split
+  end
+end
+
+class TkBitmapImage<TkImage
+  def initialize(*args)
+    @type = 'bitmap'
+    super
+  end
+end
+
+class TkPhotoImage<TkImage
+  def initialize(*args)
+    @type = 'photo'
+    super
+  end
+
+  def blank
+    tk_send 'blank'
+  end
+
+  def cget(option)
+    tk_tcl2ruby tk_send 'cget', option
+  end
+
+  def copy(source, *opts)
+    args = opts.collect{|term|
+      if term.kind_of?(String) && term.include?(?\s)
+	term.split
+      else
+	term
+      end
+    }.flatten
+
+    tk_send 'copy', source, *args
+  end
+
+  def get(x, y)
+    tk_send 'get', x, y
+  end
+
+  def put(data, *to)
+    if to == []
+      tk_send 'put', data
+    else
+      tk_send 'put', data, '-to', *to
+    end
+  end
+
+  def read(file, *opts)
+    args = opts.collect{|term|
+      if term.kind_of?(String) && term.include?(?\s)
+	term.split
+      else
+	term
+      end
+    }.flatten
+  
+    tk_send 'read', file, *args
+  end
+
+  def redither
+    tk_send 'redither'
+  end
+
+  def write(file, *opts)
+    args = opts.collect{|term|
+      if term.kind_of?(String) && term.include?(?\s)
+	term.split
+      else
+	term
+      end
+    }.flatten
+  
+    tk_send 'write', file, *args
+  end
+end
diff --git a/ext/tk/lib/tkclass.rb b/ext/tk/lib/tkclass.rb
new file mode 100644
index 0000000000..0b33d4ec8b
--- /dev/null
+++ b/ext/tk/lib/tkclass.rb
@@ -0,0 +1,38 @@
+#
+#		tkclass.rb - Tk classes
+#			$Date$
+#			by Yukihiro Matsumoto <matz@caelum.co.jp>
+
+require "tk"
+
+TopLevel = TkToplevel
+Frame = TkFrame
+Label = TkLabel
+Button = TkButton
+Radiobutton = TkRadioButton
+Checkbutton = TkCheckButton
+Message = TkMessage
+Entry = TkEntry
+Text = TkText
+Scale = TkScale
+Scrollbar = TkScrollbar
+Listbox = TkListbox
+Menu = TkMenu
+Menubutton = TkMenubutton
+Canvas = TkCanvas
+Arc = TkcArc
+Bitmap = TkcBitmap
+Line = TkcLine
+Oval = TkcOval
+Polygon = TkcPolygon
+Rectangle = TkcRectangle
+TextItem = TkcText
+WindowItem = TkcWindow
+Selection = TkSelection
+Winfo = TkWinfo
+Pack = TkPack
+Variable = TkVariable
+
+def Mainloop
+  Tk.mainloop
+end
diff --git a/ext/tk/lib/tkdialog.rb b/ext/tk/lib/tkdialog.rb
new file mode 100644
index 0000000000..1133db6ae9
--- /dev/null
+++ b/ext/tk/lib/tkdialog.rb
@@ -0,0 +1,141 @@
+require "tk"
+
+class TkDialog < TkWindow
+  extend Tk
+
+  # initialize tk_dialog
+  def initialize(keys = nil)
+    super()
+    @var = TkVariable.new
+    id = @var.id
+
+    @title   = title
+
+    @message = message
+    @message_config = message_config
+
+    @bitmap  = bitmap
+    @bitmap_config = message_config
+
+    @default_button = default_button
+
+    @buttons = buttons
+    @button_configs = proc{|num| button_configs num}
+
+    if keys.kind_of? Hash
+      @title   = keys['title'] if keys['title']
+      @message = keys['message'] if keys['message']
+      @bitmap  = keys['bitmap'] if keys['bitmap']
+      @default_button = keys['default'] if keys['default']
+      @buttons = keys['buttons'] if keys['buttons']
+
+      @command = keys['prev_command']
+
+      @message_config = keys['message_config'] if keys['message_config']
+      @bitmap_config  = keys['bitmap_config']  if keys['bitmap_config']
+      @button_configs = keys['button_configs'] if keys['button_configs']
+    end
+
+    if @title.include? ?\s
+      @title = '{' + @title + '}'
+    end
+
+    @buttons = tk_split_list(@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
+    }
+
+    config = ""
+    if @message_config.kind_of? Hash
+      config << format("%s.msg configure %s\n", 
+		       @path, hash_kv(@message_config).join(' '))
+    end
+    if @bitmap_config.kind_of? Hash
+      config << format("%s.msg configure %s\n", 
+		       @path, hash_kv(@bitmap_config).join(' '))
+    end
+    if @button_configs.kind_of? Proc
+      @buttons.each_index{|i|
+	if (c = @button_configs.call(i)).kind_of? Hash
+	  config << format("%s.button%s configure %s\n", 
+			   @path, i, hash_kv(c).join(' '))
+	end
+      }
+    end
+    config = 'after idle {' + config + '};' if config != ""
+
+    if @command.kind_of? Proc
+      @command.call(self)
+    end
+
+    INTERP._eval('eval {global '+id+';'+config+
+		 'set '+id+' [tk_dialog '+ 
+		 @path+" "+@title+" {#{@message}} "+@bitmap+" "+
+		 String(@default_button)+" "+@buttons.join(' ')+']}')
+  end
+  def value
+    return @var.value.to_i
+  end
+  ######################################################
+  #                                                    #
+  # these methods must be overridden for each dialog   #
+  #                                                    #
+  ######################################################
+  def title
+    return "DIALOG"
+  end
+  def message
+    return "MESSAGE"
+  end
+  def message_config
+    return nil
+  end
+  def bitmap
+    return "info"
+  end
+  def bitmap_config
+    return nil
+  end
+  def default_button
+    return 0
+  end
+  def buttons
+    #return "BUTTON1 BUTTON2"
+    return ["BUTTON1", "BUTTON2"]
+  end
+  def button_configs(num)
+    return nil
+  end
+end
+
+#
+# dialog for warning
+#
+class TkWarning < TkDialog
+  def initialize(mes)
+    @mes = mes
+    super()
+  end
+  def message
+    return @mes
+  end
+  def title
+    return "WARNING";
+  end
+  def bitmap
+    return "warning";
+  end
+  def default_button
+    return 0;
+  end
+  def buttons
+    return "OK";
+  end
+end
diff --git a/ext/tk/lib/tkentry.rb b/ext/tk/lib/tkentry.rb
new file mode 100644
index 0000000000..b834c455c6
--- /dev/null
+++ b/ext/tk/lib/tkentry.rb
@@ -0,0 +1,73 @@
+#
+#		tkentry.rb - Tk entry classes
+#			$Date$
+#			by Yukihiro Matsumoto <matz@caelum.co.jp>
+
+require 'tk.rb'
+
+class TkEntry<TkLabel
+  WidgetClassName = 'Entry'.freeze
+  TkClassBind::WidgetClassNameTBL[WidgetClassName] = self
+  def self.to_eval
+    WidgetClassName
+  end
+
+  def create_self
+    tk_call 'entry', @path
+  end
+  def scrollcommand(cmd)
+    configure 'scrollcommand', cmd
+  end
+
+  def delete(s, e=None)
+    tk_send 'delete', s, e
+  end
+
+  def cursor
+    tk_send 'index', 'insert'
+  end
+  def cursor=(index)
+    tk_send 'icursor', index
+  end
+  def index(index)
+    number(tk_send('index', index))
+  end
+  def insert(pos,text)
+    tk_send 'insert', pos, text
+  end
+  def mark(pos)
+    tk_send 'scan', 'mark', pos
+  end
+  def dragto(pos)
+    tk_send 'scan', 'dragto', pos
+  end
+  def selection_adjust(index)
+    tk_send 'selection', 'adjust', index
+  end
+  def selection_clear
+    tk_send 'selection', 'clear', 'end'
+  end
+  def selection_from(index)
+    tk_send 'selection', 'from', index
+  end
+  def selection_present()
+    tk_send('selection', 'present') == 1
+  end
+  def selection_range(s, e)
+    tk_send 'selection', 'range', s, e
+  end
+  def selection_to(index)
+    tk_send 'selection', 'to', index
+  end
+  def xview(*index)
+    tk_send 'xview', *index
+  end
+
+  def value
+    tk_send 'get'
+  end
+  def value= (val)
+    tk_send 'delete', 0, 'end'
+    tk_send 'insert', 0, val
+  end
+end
diff --git a/ext/tk/lib/tkfont.rb b/ext/tk/lib/tkfont.rb
new file mode 100644
index 0000000000..c680d166e7
--- /dev/null
+++ b/ext/tk/lib/tkfont.rb
@@ -0,0 +1,953 @@
+#
+#  tkfont.rb - the class to treat fonts on Ruby/Tk
+#
+#                               by  Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+require 'tk'
+
+class TkFont
+  include Tk
+  extend TkCore
+
+  Tk_FontID = [0]
+  Tk_FontNameTBL = {}
+  Tk_FontUseTBL = {}
+
+  DEFAULT_LATIN_FONT_NAME = 'a14'.freeze
+  DEFAULT_KANJI_FONT_NAME = 'k14'.freeze
+
+  ###################################
+  # class methods
+  ###################################
+  def TkFont.families(window=nil)
+    case (Tk::TK_VERSION)
+    when /^4\.*/
+      ['fixed']
+
+    when /^8\.*/
+      if window
+	tk_split_simplelist(tk_call('font', 'families', '-displayof', window))
+      else
+	tk_split_simplelist(tk_call('font', 'families'))
+      end
+    end
+  end
+
+  def TkFont.names
+    case (Tk::TK_VERSION)
+    when /^4\.*/
+      r = ['fixed']
+      r += ['a14', 'k14'] if JAPANIZED_TK
+      Tk_FontNameTBL.each_value{|obj| r.push(obj)}
+      r | []
+
+    when /^8\.*/
+      tk_split_simplelist(tk_call('font', 'names'))
+
+    end
+  end
+
+  def TkFont.create_copy(font)
+    keys = {}
+    font.configure.each{|key,value| keys[key] = value }
+    new_font = TkFont.new(font.latin_font, font.kanji_font, keys)
+  end
+
+  def TkFont.get_obj(name)
+    if name =~ /^(@font[0-9]+)(|c|l|k)$/
+      Tk_FontNameTBL[$1]
+    else
+      nil
+    end
+  end
+
+  def TkFont.init_widget_font(path, *args)
+    case (Tk::TK_VERSION)
+    when /^4\.*/
+      conf = tk_split_simplelist(tk_call(*args)).
+	find_all{|prop| prop[0..5]=='-font ' || prop[0..10]=='-kanjifont '}.
+	collect{|prop| tk_split_simplelist(prop)}
+      if font_inf = conf.assoc('-font')
+	ltn = font_inf[4]
+	ltn = nil if ltn == []
+      else 
+	#ltn = nil
+	raise RuntimeError, "unknown option '-font'"
+      end
+      if font_inf = conf.assoc('-kanjifont')
+	knj = font_inf[4]
+	knj = nil if knj == []
+      else
+	knj = nil
+      end
+      TkFont.new(ltn, knj).call_font_configure(path, *(args + [{}]))
+
+    when /^8\.*/
+      font_prop = tk_split_simplelist(tk_call(*args)).find{|prop| 
+	prop[0..5] == '-font '
+      }
+      unless font_prop
+	raise RuntimeError, "unknown option '-font'"
+      end
+      fnt = tk_split_simplelist(font_prop)[4]
+      if fnt == ""
+	TkFont.new(nil, nil).call_font_configure(path, *(args + [{}]))
+      else
+	begin
+	  compound = Hash[*list(tk_call('font', 'configure', 
+					fnt))].collect{|key,value|
+	    [key[1..-1], value]
+	  }.assoc('compound')[1]
+	rescue
+	  compound = []
+	end
+	if compound == []
+	  TkFont.new(fnt, DEFAULT_KANJI_FONT_NAME) \
+	  .call_font_configure(path, *(args + [{}]))
+	else
+	  TkFont.new(compound[0], compound[1]) \
+	  .call_font_configure(path, *(args + [{}]))
+	end
+      end
+    end
+  end
+
+  def TkFont.used_on(path=nil)
+    if path
+      Tk_FontUseTBL[path]
+    else
+      Tk_FontUseTBL.values | []
+    end
+  end
+
+  ###################################
+  private
+  ###################################
+  def initialize(ltn=nil, knj=nil, keys=nil)
+    @id = format("@font%.4d", Tk_FontID[0])
+    Tk_FontID[0] += 1
+    Tk_FontNameTBL[@id] = self
+
+    ltn = DEFAULT_LATIN_FONT_NAME unless ltn
+    create_latinfont(ltn)
+
+    knj = DEFAULT_KANJI_FONT_NAME unless knj
+    create_kanjifont(knj)
+
+    create_compoundfont(keys)
+  end
+
+  def _get_font_info_from_hash(font)
+    foundry  = (info = font['foundry'] .to_s)?  info: '*'
+    family   = (info = font['family']  .to_s)?  info: '*'
+    weight   = (info = font['weight']  .to_s)?  info: '*'
+    slant    = (info = font['slant']   .to_s)?  info: '*'
+    swidth   = (info = font['swidth']  .to_s)?  info: '*'
+    adstyle  = (info = font['adstyle'] .to_s)?  info: '*'
+    pixels   = (info = font['pixels']  .to_s)?  info: '*'
+    points   = (info = font['points']  .to_s)?  info: '*'
+    resx     = (info = font['resx']    .to_s)?  info: '*'
+    resy     = (info = font['resy']    .to_s)?  info: '*'
+    space    = (info = font['space']   .to_s)?  info: '*'
+    avgWidth = (info = font['avgWidth'].to_s)?  info: '*'
+    charset  = (info = font['charset'] .to_s)?  info: '*'
+    encoding = (info = font['encoding'].to_s)?  info: '*'
+
+    [foundry, family, weight, slant, swidth, adstyle,
+      pixels, points, resx, resy, space, avgWidth, charset, encoding]
+  end
+
+  def create_latinfont_tk4x(font)
+    if font.kind_of? Hash
+      @latinfont = '-' + _get_font_info_from_hash(font).join('-') + '-'
+
+    elsif font.kind_of? Array
+      finfo = {}
+      finfo['family'] = font[0].to_s
+      if font[1]
+	fsize = font[1].to_s
+	if fsize != '0' && fsize =~ /^(|\+|-)([0-9]+)$/
+	  if $1 == '-'
+	    finfo['pixels'] = $2
+	  else
+	    finfo['points'] = $2
+	  end
+	else
+	  finfo['points'] = '13'
+	end
+      end
+      font[2..-1].each{|style|
+	case (style)
+	when 'normal'
+	  finfo['weight'] = style
+	when 'bold'
+	  finfo['weight'] = style
+	when 'roman'
+	  finfo['slant'] = 'r'
+	when 'italic'
+	  finfo['slant'] = 'i'
+	end
+      }
+
+      @latinfont = '-' + _get_font_info_from_hash(finfo).join('-') + '-'
+
+    elsif font.kind_of? TkFont
+      @latinfont = font.latin_font
+
+    else
+      @latinfont = font
+
+    end
+  end
+
+  def create_kanjifont_tk4x(font)
+    unless JAPANIZED_TK
+      @kanjifont = ""
+      return
+    end
+
+    if font.kind_of? Hash
+      @kanjifont = '-' + _get_font_info_from_hash(font).join('-') + '-'
+
+    elsif font.kind_of? Array
+      finfo = {}
+      finfo['family'] = font[0].to_s
+      if font[1]
+	fsize = font[1].to_s
+	if fsize != '0' && fsize =~ /^(|\+|-)([0-9]+)$/
+	  if $1 == '-'
+	    finfo['pixels'] = $2
+	  else
+	    finfo['points'] = $2
+	  end
+	else
+	  finfo['points'] = '13'
+	end
+      end
+      font[2..-1].each{|style|
+	case (style)
+	when 'normal'
+	  finfo['weight'] = style
+	when 'bold'
+	  finfo['weight'] = style
+	when 'roman'
+	  finfo['slant'] = 'r'
+	when 'italic'
+	  finfo['slant'] = 'i'
+	end
+      }
+
+      @kanjifont = '-' + _get_font_info_from_hash(finfo).join('-') + '-'
+    elsif font.kind_of? TkFont
+      @kanjifont = font.kanji_font
+    else
+      @kanjifont = font
+    end
+  end
+
+  def create_compoundfont_tk4x(keys)
+    if JAPANIZED_TK
+      @compoundfont = [[@latinfont], [@kanjifont]]
+      @fontslot = {'font'=>@latinfont, 'kanjifont'=>@kanjifont}
+    else
+      @compoundfont = @latinfont
+      @fontslot = {'font'=>@latinfont}
+    end
+  end
+
+  def create_latinfont_tk8x(font)
+    @latinfont = @id + 'l'
+
+    if JAPANIZED_TK
+      if font.kind_of? Hash
+	tk_call('font', 'create', @latinfont, *hash_kv(font))
+      elsif font.kind_of? Array
+	tk_call('font', 'create', @latinfont, '-copy', array2tk_list(font))
+      elsif font.kind_of? TkFont
+	tk_call('font', 'create', @latinfont, '-copy', font.latin_font)
+      else
+	tk_call('font', 'create', @latinfont, '-copy', font)
+      end
+    else
+      if font.kind_of? Hash
+	tk_call('font', 'create', @latinfont, *hash_kv(font))
+      else
+	keys = {}
+	if font.kind_of? Array
+	  actual_core(array2tk_list(font)).each{|key,val| keys[key] = val}
+	elsif font.kind_of? TkFont
+	  actual_core(font.latin_font).each{|key,val| keys[key] = val}
+	else
+	  actual_core(font).each{|key,val| keys[key] = val}
+	end
+	tk_call('font', 'create', @latinfont, *hash_kv(keys))
+      end
+    end
+  end
+
+  def create_kanjifont_tk80(font)
+    unless JAPANIZED_TK
+      @kanjifont = ""
+      return
+    end
+
+    @kanjifont = @id + 'k'
+
+    if font.kind_of? Hash
+      if font['charset']
+	tk_call('font', 'create', @kanjifont, *hash_kv(font))
+      else
+	tk_call('font', 'create', @kanjifont, 
+		'-charset', 'jisx0208.1983', *hash_kv(font))
+      end
+    elsif font.kind_of? Array
+      tk_call('font', 'create', @kanjifont, '-copy', array2tk_list(font))
+      tk_call('font', 'configure', @kanjifont, '-charset', 'jisx0208.1983')
+
+    elsif font.kind_of? TkFont
+      tk_call('font', 'create', @kanjifont, '-copy', font.kanji_font)
+    else
+      tk_call('font', 'create', @kanjifont, '-copy', font, 
+	      '-charset', 'jisx0208.1983')
+    end
+  end
+
+  def create_kanjifont_tk81(font)
+    @kanjifont = @id + 'k'
+
+    if font.kind_of? Hash
+      tk_call('font', 'create', @kanjifont, *hash_kv(font))
+    else
+      keys = {}
+      if font.kind_of? Array
+	actual_core(array2tk_list(font)).each{|key,val| keys[key] = val}
+      elsif font.kind_of? TkFont
+	actual_core(font.kanji_font).each{|key,val| keys[key] = val}
+      else
+	actual_core(font).each{|key,val| keys[key] = val}
+      end
+      tk_call('font', 'create', @kanjifont, *hash_kv(keys))
+    end
+
+    keys = {}
+    actual_core(@kanjifont).each{|key,val| keys[key] = val}
+    begin
+      tk_call('font', 'configure', @compoundfont, *hash_kv(keys))
+    rescue
+    end
+  end
+
+  def create_compoundfont_tk80(keys)
+    @compoundfont = @id + 'c'
+    if JAPANIZED_TK
+      @fontslot = {'font'=>@compoundfont}
+      tk_call('font', 'create', @compoundfont, 
+	      '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
+    else
+      tk_call('font', 'create', @compoundfont)
+      latinkeys = {}
+      begin
+	actual_core(@latinfont).each{|key,val| latinkeys[key] = val}
+      rescue
+	latinkeys {}
+      end
+      if latinkeys != {}
+	tk_call('font', 'configure', @compoundfont, *hash_kv(latinkeys))
+      end
+      @fontslot = {'font'=>@compoundfont}
+      tk_call('font', 'configure', @compoundfont, *hash_kv(keys))
+    end
+  end
+
+  def create_compoundfont_tk81(keys)
+    @compoundfont = @id + 'c'
+    tk_call('font', 'create', @compoundfont)
+
+    latinkeys = {}
+    begin
+      actual_core(@latinfont).each{|key,val| latinkeys[key] = val}
+    rescue
+      latinkeys {}
+    end
+    if latinkeys != {}
+      tk_call('font', 'configure', @compoundfont, *hash_kv(latinkeys))
+    end
+
+    kanjikeys = {}
+    begin
+      actual_core(@kanjifont).each{|key,val| kanjikeys[key] = val}
+    rescue
+      kanjikeys {}
+    end
+    if kanjikeys != {}
+      tk_call('font', 'configure', @compoundfont, *hash_kv(kanjikeys))
+    end
+
+    @fontslot = {'font'=>@compoundfont}
+    tk_call('font', 'configure', @compoundfont, *hash_kv(keys))
+  end
+
+  def actual_core_tk4x(font, window=nil, option=nil)
+    # dummy
+    if option
+      ""
+    else
+      [['family',[]], ['size',[]], ['weight',[]], ['slant',[]], 
+	['underline',[]], ['overstrike',[]], ['charset',[]], 
+	['pointadjust',[]]]
+    end
+  end
+
+  def actual_core_tk8x(font, window=nil, option=nil)
+    if option == 'compound'
+      ""
+    elsif option
+      if window
+	tk_call('font', 'actual', font, "-#{option}")
+      else
+	tk_call('font', 'actual', font, "-displayof", window, "-#{option}")
+      end
+    else
+      l = tk_split_simplelist(if window
+			 	 tk_call('font', 'actual', font, 
+					             "-displayof", window)
+			      else
+			  	 tk_call('font', 'actual', font)
+			      end)
+      r = []
+      while key=l.shift
+	if key == '-compound'
+	  l.shift
+	else
+	  r.push [key[1..-1], l.shift]
+	end
+      end
+      r
+    end
+  end
+
+  def configure_core_tk4x(font, slot, value=None)
+    ""
+  end
+
+  def configinfo_core_tk4x(font, option=nil)
+    # dummy
+    if option
+      ""
+    else
+      [['family',[]], ['size',[]], ['weight',[]], ['slant',[]], 
+	['underline',[]], ['overstrike',[]], ['charset',[]], 
+	['pointadjust',[]]]
+    end
+  end
+
+  def configure_core_tk8x(font, slot, value=None)
+    if slot.kind_of? Hash
+      tk_call 'font', 'configure', font, *hash_kv(slot)
+    else
+      tk_call 'font', 'configure', font, "-#{slot}", value
+    end
+  end
+
+  def configinfo_core_tk8x(font, option=nil)
+    if option == 'compound'
+      ""
+    elsif option
+      tk_call('font', 'configure', font, "-#{option}")
+    else
+      l = tk_split_simplelist(tk_call('font', 'configure', font))
+      r = []
+      while key=l.shift
+	if key == '-compound'
+	  l.shift
+	else
+	  r.push [key[1..-1], l.shift]
+	end
+      end
+      r
+    end
+  end
+
+  def delete_core_tk4x
+    Tk_FontNameTBL[@id] = nil
+    Tk_FontUseTBL.delete_if{|key,value| value == self}
+  end
+
+  def delete_core_tk8x
+    begin
+      tk_call('font', 'delete', @latinfont)
+    rescue
+    end
+    begin
+      tk_call('font', 'delete', @kanjifont)
+    rescue
+    end
+    begin
+      tk_call('font', 'delete', @compoundfont)
+    rescue
+    end
+    Tk_FontNameTBL[@id] = nil
+    Tk_FontUseTBL.delete_if{|key,value| value == self}
+  end
+
+  def latin_replace_core_tk4x(ltn)
+    create_latinfont_tk4x(ltn)
+    @compoundfont[0] = [@latinfont] if JAPANIZED_TK
+    @fontslot['font'] = @latinfont
+    Tk_FontUseTBL.dup.each{|w, fobj|
+      if self == fobj
+	begin
+	  if w.include?(';')
+	    win, tag = w.split(';')
+	    winobj = tk_tcl2ruby(win)
+#	    winobj.tagfont_configure(tag, {'font'=>@latinfont})
+	    if winobj.kind_of? TkText
+	      tk_call(win, 'tag', 'configure', tag, '-font', @latinfont)
+	    elsif winobj.kind_of? TkCanvas
+	      tk_call(win, 'itemconfigure', tag, '-font', @latinfont)
+	    elsif winobj.kind_of? TkMenu
+	      tk_call(win, 'entryconfigure', tag, '-font', @latinfont)
+	    else
+	      raise RuntimeError, "unknown widget type"
+	    end
+	  else
+#	    tk_tcl2ruby(w).font_configure('font'=>@latinfont)
+	    tk_call(w, 'configure', '-font', @latinfont)
+	  end
+	rescue
+	  Tk_FontUseTBL[w] = nil
+	end
+      end
+    }
+    self
+  end
+
+  def kanji_replace_core_tk4x(knj)
+    return self unless JAPANIZED_TK
+
+    create_kanjifont_tk4x(knj)
+    @compoundfont[1] = [@kanjifont]
+    @fontslot['kanjifont'] = @kanjifont
+    Tk_FontUseTBL.dup.each{|w, fobj|
+      if self == fobj
+	begin
+	  if w.include?(';')
+	    win, tag = w.split(';')
+	    winobj = tk_tcl2ruby(win)
+#	    winobj.tagfont_configure(tag, {'kanjifont'=>@kanjifont})
+	    if winobj.kind_of? TkText
+	      tk_call(win, 'tag', 'configure', tag, '-kanjifont', @kanjifont)
+	    elsif winobj.kind_of? TkCanvas
+	      tk_call(win, 'itemconfigure', tag, '-kanjifont', @kanjifont)
+	    elsif winobj.kind_of? TkMenu
+	      tk_call(win, 'entryconfigure', tag, '-kanjifont', @latinfont)
+	    else
+	      raise RuntimeError, "unknown widget type"
+	    end
+	  else
+#	    tk_tcl2ruby(w).font_configure('kanjifont'=>@kanjifont)
+	    tk_call(w, 'configure', '-kanjifont', @kanjifont)
+	  end
+	rescue
+	  Tk_FontUseTBL[w] = nil
+	end
+      end
+    }
+    self
+  end
+
+  def latin_replace_core_tk8x(ltn)
+    begin
+      tk_call('font', 'delete', @latinfont)
+    rescue
+    end
+    create_latinfont(ltn)
+    self
+  end
+
+  def kanji_replace_core_tk80(knj)
+    return self unless JAPANIZED_TK
+
+    begin
+      tk_call('font', 'delete', @kanjifont)
+    rescue
+    end
+    create_kanjifont(knj)
+    self
+  end
+
+  def kanji_replace_core_tk81(knj)
+    if font.kind_of? Hash
+      tk_call('font', 'configure', @compoundfont, *hash_kv(knj))
+    else
+      keys = {}
+      if knj.kind_of? Array
+	actual_core(array2tk_list(knj)).each{|key,val| keys[key] = val}
+      elsif knj.kind_of? TkFont
+	actual_core(knj.latin_font).each{|key,val| keys[key] = val}
+      else
+	actual_core(knj).each{|key,val| keys[key] = val}
+      end
+      tk_call('font', 'configure', @compoundfont, *hash_kv(keys))
+    end
+    self
+  end
+
+  def measure_core_tk4x(window, text)
+    0
+  end
+
+  def measure_core_tk8x(window, text)
+    if window
+      number(tk_call('font', 'measure', @compoundfont, 
+		     '-displayof', window, text))
+    else
+      number(tk_call('font', 'measure', @compoundfont, text))
+    end
+  end
+
+  def metrics_core_tk4x(font, window, option=nil)
+    # dummy
+    if option
+      ""
+    else
+      [['ascent',[]], ['descent',[]], ['linespace',[]], ['fixed',[]]]
+    end
+  end
+
+  def metrics_core_tk8x(font, window, option=nil)
+    if option
+      if window
+	number(tk_call('font', 'metrics', font, "-#{option}"))
+      else
+	number(tk_call('font', 'metrics', font, 
+		       "-displayof", window, "-#{option}"))
+      end
+    else
+      l = tk_split_list(if window
+			  tk_call('font','metrics',font,"-displayof",window)
+			else
+			  tk_call('font','metrics',font)
+			end)
+      r = []
+      while key=l.shift
+	r.push [key[1..-1], l.shift.to_i]
+      end
+      r
+    end
+  end
+
+  ###################################
+  # private alias
+  ###################################
+  case (Tk::TK_VERSION)
+  when /^4\.*/
+    alias create_latinfont    create_latinfont_tk4x
+    alias create_kanjifont    create_kanjifont_tk4x
+    alias create_compoundfont create_compoundfont_tk4x
+    alias actual_core         actual_core_tk4x
+    alias configure_core      configure_core_tk4x
+    alias configinfo_core     configinfo_core_tk4x
+    alias delete_core         delete_core_tk4x
+    alias latin_replace_core  latin_replace_core_tk4x
+    alias kanji_replace_core  kanji_replace_core_tk4x
+    alias measure_core        measure_core_tk4x
+    alias metrics_core        metrics_core_tk4x
+
+  when /^8\.0/
+    alias create_latinfont    create_latinfont_tk8x
+    alias create_kanjifont    create_kanjifont_tk80
+    alias create_compoundfont create_compoundfont_tk80
+    alias actual_core         actual_core_tk8x
+    alias configure_core      configure_core_tk8x
+    alias configinfo_core     configinfo_core_tk8x
+    alias delete_core         delete_core_tk8x
+    alias latin_replace_core  latin_replace_core_tk8x
+    alias kanji_replace_core  kanji_replace_core_tk80
+    alias measure_core        measure_core_tk8x
+    alias metrics_core        metrics_core_tk8x
+
+  when /^8\.1/
+    alias create_latinfont    create_latinfont_tk8x
+    alias create_kanjifont    create_kanjifont_tk81
+    alias create_compoundfont create_compoundfont_tk81
+    alias actual_core         actual_core_tk8x
+    alias configure_core      configure_core_tk8x
+    alias configinfo_core     configinfo_core_tk8x
+    alias delete_core         delete_core_tk8x
+    alias latin_replace_core  latin_replace_core_tk8x
+    alias kanji_replace_core  kanji_replace_core_tk81
+    alias measure_core        measure_core_tk8x
+    alias metrics_core        metrics_core_tk8x
+
+  end
+
+  ###################################
+  public
+  ###################################
+  def call_font_configure(path, *args)
+    args += hash_kv(args.pop.update(@fontslot))
+    tk_call *args
+    Tk_FontUseTBL[path] = self
+    self
+  end
+
+  def used
+    ret = []
+    Tk_FontUseTBL.each{|key,value|
+      if key.include?(';')
+	win, tag = key.split(';')
+	winobj = tk_tcl2ruby(win)
+	if winobj.kind_of? TkText
+	  ret.push([winobj, winobj.tagid2obj(tag)])
+	elsif winobj.kind_of? TkCanvas
+	  if (tagobj = TkcTag.id2obj(tag)).kind_of? TkcTag
+	    ret.push([winobj, tagobj])
+	  elsif (tagobj = TkcItem.id2obj(tag)).kind_of? TkcItem
+	    ret.push([winobj, tagobj])
+	  else
+	    ret.push([winobj, tag])
+	  end
+	elsif winobj.kind_of? TkMenu
+	  ret.push([winobj, tag])
+	else
+	  ret.push([win, tag])
+	end
+      else
+	ret.push(tk_tcl2ruby(key)) if value == self
+      end
+    }
+    ret
+  end
+
+  def id
+    @id
+  end
+
+  def to_eval
+    font
+  end
+
+  def font
+    @compoundfont
+  end
+
+  def latin_font
+    @latinfont
+  end
+
+  def kanji_font
+    @kanjifont
+  end
+
+  def actual(option=nil)
+    actual_core(@compoundfont, nil, option)
+  end
+
+  def actual_displayof(window, option=nil)
+    window = '.' unless window
+    actual_core(@compoundfont, window, option)
+  end
+
+  def latin_actual(option=nil)
+    actual_core(@latinfont, nil, option)
+  end
+
+  def latin_actual_displayof(window, option=nil)
+    window = '.' unless window
+    actual_core(@latinfont, window, option)
+  end
+
+  def kanji_actual(option=nil)
+    #if JAPANIZED_TK
+    if @kanjifont != ""
+      actual_core(@kanjifont, nil, option)
+    else
+      actual_core_tk4x(nil, nil, option)
+    end
+  end
+
+  def kanji_actual_displayof(window, option=nil)
+    #if JAPANIZED_TK
+    if @kanjifont != ""
+      window = '.' unless window
+      actual_core(@kanjifont, window, option)
+    else
+      actual_core_tk4x(nil, window, option)
+    end
+  end
+
+  def [](slot)
+    configinfo slot
+  end
+
+  def []=(slot, val)
+    configure slot, val
+  end
+
+  def configure(slot, value=None)
+    configure_core(@compoundfont, slot, value)
+  end
+
+  def configinfo(slot=nil)
+    configinfo_core(@compoundfont, slot)
+  end
+
+  def delete
+    delete_core
+  end
+
+  def latin_configure(slot, value=None)
+    if JAPANIZED_TK
+      configure_core(@latinfont, slot, value)
+    else
+      configure(slot, value)
+    end
+  end
+
+  def latin_configinfo(slot=nil)
+    if JAPANIZED_TK
+      configinfo_core(@latinfont, slot)
+    else
+      configure(slot, value)
+    end
+  end
+
+  def kanji_configure(slot, value=None)
+    #if JAPANIZED_TK
+    if @kanjifont != ""
+      configure_core(@kanjifont, slot, value)
+      configure('size'=>configinfo('size')) # to reflect new configuration
+    else
+      #""
+      configure(slot, value)
+    end
+  end
+
+  def kanji_configinfo(slot=nil)
+    #if JAPANIZED_TK
+    if @kanjifont != ""
+      configinfo_core(@kanjifont, slot)
+    else
+      #[]
+      configinfo(slot)
+    end
+  end
+
+  def replace(ltn, knj)
+    latin_replace(ltn)
+    kanji_replace(knj)
+    self
+  end
+
+  def latin_replace(ltn)
+    latin_replace_core(ltn)
+    reset_pointadjust
+  end
+
+  def kanji_replace(knj)
+    kanji_replace_core(knj)
+    reset_pointadjust
+  end
+
+  def measure(text)
+    measure_core(nil, text)
+  end
+
+  def measure_displayof(window, text)
+    window = '.' unless window
+    measure_core(window, text)
+  end
+
+  def metrics(option=nil)
+    metrics_core(@compoundfont, nil, option)
+  end
+
+  def metrics_displayof(window, option=nil)
+    window = '.' unless window
+    metrics_core(@compoundfont, window, option)
+  end
+
+  def latin_metrics(option=nil)
+    metrics_core(@latinfont, nil, option)
+  end
+
+  def latin_metrics_displayof(window, option=nil)
+    window = '.' unless window
+    metrics_core(@latinfont, window, option)
+  end
+
+  def kanji_metrics(option=nil)
+    if JAPANIZED_TK
+      metrics_core(@kanjifont, nil, option)
+    else
+      metrics_core_tk4x(nil, nil, option)
+    end
+  end
+
+  def kanji_metrics_displayof(window, option=nil)
+    if JAPANIZED_TK
+      window = '.' unless window
+      metrics_core(@kanjifont, window, option)
+    else
+      metrics_core_tk4x(nil, window, option)
+    end
+  end
+
+  def reset_pointadjust
+    begin
+      if /^8\.*/ === Tk::TK_VERSION  && JAPANIZED_TK
+        configure('pointadjust' => latin_actual.assoc('size')[1].to_f / 
+                                      kanji_actual.assoc('size')[1].to_f )
+      end
+    rescue
+    end
+    self
+  end
+
+  ###################################
+  # public alias
+  ###################################
+  alias ascii_font             latin_font
+  alias create_asciifont       create_latinfont
+  alias ascii_actual           latin_actual
+  alias ascii_actual_displayof latin_actual_displayof
+  alias ascii_configure        latin_configure
+  alias ascii_configinfo       latin_configinfo
+  alias ascii_replace          latin_replace
+  alias ascii_metrics          latin_metrics
+
+end
+
+module TkTreatTagFont
+  def font_configinfo
+    @parent.tagfont_configinfo(@id)
+  end
+  alias font font_configinfo
+
+  def font_configure(slot)
+    @parent.tagfont_configure(@id, slot)
+  end
+
+  def latinfont_configure(ltn, keys=nil)
+    @parent.latintagfont_configure(@id, ltn, keys)
+  end
+  alias asciifont_configure latinfont_configure
+
+  def kanjifont_configure(knj, keys=nil)
+    @parent.kanjitagfont_configure(@id, ltn, keys)
+  end
+
+  def font_copy(window, wintag=nil)
+    @parent.tagfont_copy(@id, window, wintag)
+  end
+
+  def latinfont_copy(window, wintag=nil)
+    @parent.latintagfont_copy(@id, window, wintag)
+  end
+  alias asciifont_copy latinfont_copy
+
+  def kanjifont_copy(window, wintag=nil)
+    @parent.kanjitagfont_copy(@id, window, wintag)
+  end
+end
diff --git a/ext/tk/lib/tkmenubar.rb b/ext/tk/lib/tkmenubar.rb
new file mode 100644
index 0000000000..441f3f5c03
--- /dev/null
+++ b/ext/tk/lib/tkmenubar.rb
@@ -0,0 +1,137 @@
+#
+# tkmenubar.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"
+
+class TkMenubar<TkFrame
+  
+  include TkComposite
+  
+  def initialize(parent = nil, spec = nil, options = nil)
+    super(parent, options)
+    
+    @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
diff --git a/ext/tk/lib/tkmngfocus.rb b/ext/tk/lib/tkmngfocus.rb
new file mode 100644
index 0000000000..921fb646e7
--- /dev/null
+++ b/ext/tk/lib/tkmngfocus.rb
@@ -0,0 +1,27 @@
+#
+#   tkmngfocus.rb : methods for Tcl/Tk standard library 'focus.tcl'
+#                     1998/07/16 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+require 'tk'
+
+module TkManageFocus
+  extend Tk
+
+  def TkManageFocus.followsMouse
+    tk_call 'tk_focusFollowsMouse'
+  end
+
+  def TkManageFocus.next(window)
+    tk_call 'tk_focusNext', window
+  end
+  def focusNext
+    TkManageFocus.next(self)
+  end
+
+  def TkManageFocus.prev(window)
+    tk_call 'tk_focusPrev', window
+  end
+  def focusPrev
+    TkManageFocus.prev(self)
+  end
+end
diff --git a/ext/tk/lib/tkpalette.rb b/ext/tk/lib/tkpalette.rb
new file mode 100644
index 0000000000..a2dc7c87cb
--- /dev/null
+++ b/ext/tk/lib/tkpalette.rb
@@ -0,0 +1,48 @@
+#
+#   tkpalette.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
+
+  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
diff --git a/ext/tk/lib/tkscrollbox.rb b/ext/tk/lib/tkscrollbox.rb
new file mode 100644
index 0000000000..6236430491
--- /dev/null
+++ b/ext/tk/lib/tkscrollbox.rb
@@ -0,0 +1,29 @@
+#
+#		tkscrollbox.rb - Tk Listbox with Scrollbar
+#                                 as an example of Composite Widget
+#			$Date$
+#			by Yukihiro Matsumoto <matz@netlab.co.jp>
+
+require 'tk.rb'
+
+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
+end
diff --git a/ext/tk/lib/tktext.rb b/ext/tk/lib/tktext.rb
new file mode 100644
index 0000000000..324af90f85
--- /dev/null
+++ b/ext/tk/lib/tktext.rb
@@ -0,0 +1,946 @@
+#
+#		tktext.rb - Tk text classes
+#			$Date$
+#			by Yukihiro Matsumoto <matz@caelum.co.jp>
+
+require 'tk.rb'
+require 'tkfont'
+
+module TkTreatTextTagFont
+  def tagfont_configinfo(tag)
+    if tag.kind_of? TkTextTag
+      pathname = self.path + ';' + tag.id
+    else
+      pathname = self.path + ';' + tag
+    end
+    ret = TkFont.used_on(pathname)
+    if ret == nil
+      ret = TkFont.init_widget_font(pathname, 
+				    self.path, 'tag', 'configure', tag)
+    end
+    ret
+  end
+  alias tagfontobj tagfont_configinfo
+
+  def tagfont_configure(tag, slot)
+    if tag.kind_of? TkTextTag
+      pathname = self.path + ';' + tag.id
+    else
+      pathname = self.path + ';' + tag
+    end
+    if (fnt = slot['font'])
+      slot['font'] = nil
+      if fnt.kind_of? TkFont
+	return fnt.call_font_configure(pathname, 
+				       self.path,'tag','configure',tag,slot)
+      else
+	latintagfont_configure(tag, fnt) if fnt
+      end
+    end
+    if (ltn = slot['latinfont'])
+      slot['latinfont'] = nil
+      latintagfont_configure(tag, ltn) if ltn
+    end
+    if (ltn = slot['asciifont'])
+      slot['asciifont'] = nil
+      latintagfont_configure(tag, ltn) if ltn
+    end
+    if (knj = slot['kanjifont'])
+      slot['kanjifont'] = nil
+      kanjitagfont_configure(tag, knj) if knj
+    end
+
+    tk_call(self.path, 'tag', 'configure', tag, *hash_kv(slot)) if slot != {}
+    self
+  end
+
+  def latintagfont_configure(tag, ltn, keys=nil)
+    fobj = tagfontobj(tag)
+    if ltn.kind_of? TkFont
+      conf = {}
+      ltn.latin_configinfo.each{|key,val| conf[key] = val if val != []}
+      if conf == {}
+	fobj.latin_replace(ltn)
+	fobj.latin_configure(keys) if keys
+      elsif keys
+	fobj.latin_configure(conf.update(keys))
+      else
+	fobj.latin_configure(conf)
+      end
+    else
+      fobj.latin_replace(ltn)
+    end
+  end
+  alias asciitagfont_configure latintagfont_configure
+
+  def kanjitagfont_configure(tag, knj, keys=nil)
+    fobj = tagfontobj(tag)
+    if knj.kind_of? TkFont
+      conf = {}
+      knj.kanji_configinfo.each{|key,val| conf[key] = val if val != []}
+      if conf == {}
+	fobj.kanji_replace(knj)
+	fobj.kanji_configure(keys) if keys
+      elsif keys
+	fobj.kanji_configure(conf.update(keys))
+      else
+	fobj.kanji_configure(conf)
+      end
+    else
+      fobj.kanji_replace(knj)
+    end
+  end
+
+  def tagfont_copy(tag, window, wintag=nil)
+    if wintag
+      window.tagfontobj(wintag).configinfo.each{|key,value|
+	tagfontobj(tag).configure(key,value)
+      }
+      tagfontobj(tag).replace(window.tagfontobj(wintag).latin_font, 
+			      window.tagfontobj(wintag).kanji_font)
+    else
+      window.tagfont(wintag).configinfo.each{|key,value|
+	tagfontobj(tag).configure(key,value)
+      }
+      tagfontobj(tag).replace(window.fontobj.latin_font, 
+			      window.fontobj.kanji_font)
+    end
+  end
+
+  def latintagfont_copy(tag, window, wintag=nil)
+    if wintag
+      tagfontobj(tag).latin_replace(window.tagfontobj(wintag).latin_font)
+    else
+      tagfontobj(tag).latin_replace(window.fontobj.latin_font)
+    end
+  end
+  alias asciitagfont_copy latintagfont_copy
+
+  def kanjitagfont_copy(tag, window, wintag=nil)
+    if wintag
+      tagfontobj(tag).kanji_replace(window.tagfontobj(wintag).kanji_font)
+    else
+      tagfontobj(tag).kanji_replace(window.fontobj.kanji_font)
+    end
+  end
+end
+
+class TkText<TkTextWin
+  include TkTreatTextTagFont
+
+  WidgetClassName = 'Text'.freeze
+  TkClassBind::WidgetClassNameTBL[WidgetClassName] = self
+  def self.to_eval
+    WidgetClassName
+  end
+  include Scrollable
+  def create_self
+    tk_call 'text', @path
+    @tags = {}
+  end
+  def index(index)
+    tk_send 'index', index
+  end
+  def value
+    tk_send 'get', "1.0", "end - 1 char"
+  end
+  def value= (val)
+    tk_send 'delete', "1.0", 'end'
+    tk_send 'insert', "1.0", val
+  end
+  def _addcmd(cmd)
+    @cmdtbl.push cmd
+  end
+  def _addtag(name, obj)
+    @tags[name] = obj
+  end
+
+  def tagid2obj(tagid)
+    if not @tags[tagid]
+      tagid
+    else
+      @tags[tagid]
+    end
+  end
+
+  def tag_names(index=None)
+    tk_split_list(tk_send('tag', 'names', index)).collect{|elt|
+      tagid2obj(elt)
+    }
+  end
+  def window_names
+    tk_send('window', 'names').collect{|elt|
+      tagid2obj(elt)
+    }
+  end
+  def image_names
+    tk_send('image', 'names').collect{|elt|
+      tagid2obj(elt)
+    }
+  end
+
+  def set_insert(index)
+    tk_send 'mark', 'set', 'insert', index
+  end
+  def set_current(index)
+    tk_send 'mark', 'set', 'current', index
+  end
+
+  def insert(index, chars, *tags)
+    super index, chars, tags.collect{|x|_get_eval_string(x)}.join(' ')
+  end
+
+  def destroy
+    @tags.each_value do |t|
+      t.destroy
+    end
+    super
+  end
+
+  def backspace
+    self.delete 'insert'
+  end
+
+  def compare(idx1, op, idx2)
+    bool(tk_send('compare', idx1, op, idx2))
+  end
+
+  def debug
+    bool(tk_send('debug'))
+  end
+  def debug=(boolean)
+    tk_send 'debug', boolean
+  end
+
+  def bbox(index)
+    inf = tk_send('bbox', index)
+    (inf == "")?  [0,0,0,0]: inf
+  end
+  def dlineinfo(index)
+    inf = tk_send('dlineinfo', index)
+    (inf == "")?  [0,0,0,0,0]: inf
+  end
+
+  def yview(*what)
+    tk_send 'yview', *what
+  end
+  def yview_pickplace(*what)
+    tk_send 'yview', '-pickplace', *what
+  end
+
+  def xview(*what)
+    tk_send 'xview', *what
+  end
+  def xview_pickplace(*what)
+    tk_send 'xview', '-pickplace', *what
+  end
+
+  def tag_add(tag,index1,index2=None)
+    tk_send 'tag', 'add', tag, index1, index2
+  end
+
+  def _tag_bind_core(mode, tag, seq, cmd=Proc.new, args=nil)
+    id = install_bind(cmd, args)
+    tk_send 'tag', 'bind', tag, "<#{tk_event_sequence(seq)}>", mode + id
+    # _addcmd cmd
+  end
+  private :_tag_bind_core
+
+  def tag_bind(tag, seq, cmd=Proc.new, args=nil)
+    _tag_bind_core('', tag, seq, cmd, args=nil)
+  end
+
+  def tag_bind_append(tag, seq, cmd=Proc.new, args=nil)
+    _tag_bind_core('+', tag, seq, cmd, args=nil)
+  end
+
+  def tag_bindinfo(tag, context=nil)
+    if context
+      (tk_send('tag', 'bind', tag, 
+	       "<#{tk_event_sequence(context)}>")).collect{|cmdline|
+	if cmdline =~ /^rb_out (c\d+)\s+(.*)$/
+	  [Tk_CMDTBL[$1], $2]
+	else
+	  cmdline
+	end
+      }
+    else
+      tk_split_list(tk_send('tag', 'bind', tag)).filter{|seq|
+	seq[1..-2].gsub(/></,',')
+      }
+    end
+  end
+
+  def tag_cget(tag, key)
+    tk_tcl2ruby tk_call @path, 'tag', 'cget', tag, "-#{key}"
+  end
+
+  def tag_configure(tag, key, val=None)
+    if key.kind_of? Hash
+      if ( key['font'] || key['kanjifont'] \
+	  || key['latinfont'] || key['asciifont'] )
+	tagfont_configure(tag, key.dup)
+      else
+	tk_send 'tag', 'configure', tag, *hash_kv(key)
+      end
+
+    else
+      if  key == 'font' || key == 'kanjifont' ||
+	  key == 'latinfont' || key == 'asciifont'
+	tagfont_configure({key=>val})
+      else
+	tk_send 'tag', 'configure', tag, "-#{key}", val
+      end
+    end
+  end
+
+  def tag_configinfo(tag, key=nil)
+    if key
+      conf = tk_split_list(tk_send('tag','configure',tag,"-#{key}"))
+      conf[0] = conf[0][1..-1]
+      conf
+    else
+      tk_split_list(tk_send('tag', 'configure', tag)).collect{|conf|
+	conf[0] = conf[0][1..-1]
+	conf
+      }
+    end
+  end
+
+  def tag_raise(tag, above=None)
+    tk_send 'tag', 'raise', tag, above
+  end
+
+  def tag_lower(tag, below=None)
+    tk_send 'tag', 'lower', tag, below
+  end
+
+  def tag_remove(tag, *index)
+    tk_send 'tag', 'remove', tag, *index
+  end
+
+  def tag_ranges(tag)
+    l = tk_split_simplelist(tk_send('tag', 'ranges', tag))
+    r = []
+    while key=l.shift
+      r.push [key, l.shift]
+    end
+    r
+  end
+
+  def tag_nextrange(tag, first, last=None)
+    tk_split_simplelist(tk_send('tag', 'nextrange', tag, first, last))
+  end
+
+  def tag_prevrange(tag, first, last=None)
+    tk_split_simplelist(tk_send('tag', 'prevrange', tag, first, last))
+  end
+
+  def search_with_length(pat,start,stop=None)
+    pat = pat.char if pat.kind_of? Integer
+    if stop != None
+      return ["", 0] if compare(start,'>=',stop)
+      txt = get(start,stop)
+      if (pos = txt.index(pat))
+	pos = txt[0..(pos-1)].split('').length if pos > 0
+	if pat.kind_of? String
+	  return [index(start + " + #{pos} chars"), pat.split('').length]
+	else
+	  return [index(start + " + #{pos} chars"), $&.split('').length]
+	end
+      else
+	return ["", 0]
+      end
+    else
+      txt = get(start,'end - 1 char')
+      if (pos = txt.index(pat))
+	pos = txt[0..(pos-1)].split('').length if pos > 0
+	if pat.kind_of? String
+	  return [index(start + " + #{pos} chars"), pat.split('').length]
+	else
+	  return [index(start + " + #{pos} chars"), $&.split('').length]
+	end
+      else
+	txt = get('1.0','end - 1 char')
+	if (pos = txt.index(pat))
+	  pos = txt[0..(pos-1)].split('').length if pos > 0
+	  if pat.kind_of? String
+	    return [index("1.0 + #{pos} chars"), pat.split('').length]
+	  else
+	    return [index("1.0 + #{pos} chars"), $&.split('').length]
+	  end
+	else
+	  return ["", 0]
+	end
+      end
+    end
+  end
+
+  def search(pat,start,stop=None)
+    search_with_length(pat,start,stop)[0]
+  end
+
+  def rsearch_with_length(pat,start,stop=None)
+    pat = pat.char if pat.kind_of? Integer
+    if stop != None
+      return ["", 0] if compare(start,'<=',stop)
+      txt = get(stop,start)
+      if (pos = txt.rindex(pat))
+	pos = txt[0..(pos-1)].split('').length if pos > 0
+	if pat.kind_of? String
+	  return [index(stop + " + #{pos} chars"), pat.split('').length]
+	else
+	  return [index(stop + " + #{pos} chars"), $&.split('').length]
+	end
+      else
+	return ["", 0]
+      end
+    else
+      txt = get('1.0',start)
+      if (pos = txt.rindex(pat))
+	pos = txt[0..(pos-1)].split('').length if pos > 0
+	if pat.kind_of? String
+	  return [index("1.0 + #{pos} chars"), pat.split('').length]
+	else
+	  return [index("1.0 + #{pos} chars"), $&.split('').length]
+	end
+      else
+	txt = get('1.0','end - 1 char')
+	if (pos = txt.rindex(pat))
+	  pos = txt[0..(pos-1)].split('').length if pos > 0
+	  if pat.kind_of? String
+	    return [index("1.0 + #{pos} chars"), pat.split('').length]
+	  else
+	    return [index("1.0 + #{pos} chars"), $&.split('').length]
+	  end
+	else
+	  return ["", 0]
+	end
+      end
+    end
+  end
+
+  def rsearch(pat,start,stop=None)
+    rsearch_with_length(pat,start,stop)[0]
+  end
+end
+
+class TkTextTag<TkObject
+  include TkTreatTagFont
+
+  $tk_text_tag = 'tag0000'
+  def initialize(parent, *args)
+    if not parent.kind_of?(TkText)
+      fail format("%s need to be TkText", parent.inspect)
+    end
+    @parent = @t = parent
+    @path = @id = $tk_text_tag
+    $tk_text_tag = $tk_text_tag.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
+    return @id
+  end
+
+  def first
+    @id + '.first'
+  end
+
+  def last
+    @id + '.last'
+  end
+
+  def add(*index)
+    tk_call @t.path, 'tag', 'add', @id, *index
+  end
+
+  def remove(*index)
+    tk_call @t.path, 'tag', 'remove', @id, *index
+  end
+
+  def ranges
+    l = tk_split_simplelist(tk_call(@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_simplelist(tk_call(@t.path, 'tag', 'nextrange', @id, first, last))
+  end
+
+  def prevrange(first, last=None)
+    tk_split_simplelist(tk_call(@t.path, 'tag', 'prevrange', @id, first, last))
+  end
+
+  def [](key)
+    cget key
+  end
+
+  def []=(key,val)
+    configure key, val
+  end
+
+  def cget(key)
+    tk_tcl2ruby tk_call @t.path, 'tag', 'cget', @id, "-#{key}"
+  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 configinfo(key=nil)
+#    if key
+#      conf = tk_split_list(tk_call(@t.path, 'tag','configure',@id,"-#{key}"))
+#      conf[0] = conf[0][1..-1]
+#      conf
+#    else
+#      tk_split_list(tk_call(@t.path, 'tag', 'configure', @id)).collect{|conf|
+#	conf[0] = conf[0][1..-1]
+#	conf
+#      }
+#    end
+#  end
+
+  def bind(seq, cmd=Proc.new, args=nil)
+    id = install_bind(cmd, args)
+    tk_call @t.path, 'tag', 'bind', @id, "<#{tk_event_sequence(seq)}>", id
+    # @t._addcmd cmd
+  end
+
+  def bindinfo(context=nil)
+    if context
+      (tk_call(@t.path, 'tag', 'bind', @id, 
+	       "<#{tk_event_sequence(context)}>")).collect{|cmdline|
+	if cmdline =~ /^rb_out (c\d+)\s+(.*)$/
+	  [Tk_CMDTBL[$1], $2]
+	else
+	  cmdline
+	end
+      }
+    else
+      tk_split_list(tk_call(@t.path, 'tag', 'bind', @id)).filter{|seq|
+	seq[1..-2].gsub(/></,',')
+      }
+    end
+  end
+
+  def raise(above=None)
+    tk_call @t.path, 'tag', 'raise', @id, above
+  end
+
+  def lower(below=None)
+    tk_call @t.path, 'tag', 'lower', @id, below
+  end
+
+  def destroy
+    tk_call @t.path, 'tag', 'delete', @id
+  end
+end
+
+class TkTextTagSel<TkTextTag
+  def initialize(parent, keys=nil)
+    if not parent.kind_of?(TkText)
+      fail format("%s need to be TkText", parent.inspect)
+    end
+    @t = parent
+    @path = @id = 'sel'
+    #tk_call @t.path, "tag", "configure", @id, *hash_kv(keys)
+    configure(keys) if keys
+    @t._addtag id, self
+  end
+end
+
+class TkTextMark<TkObject
+  $tk_text_mark = 'mark0000'
+  def initialize(parent, index)
+    if not parent.kind_of?(TkText)
+      fail format("%s need to be TkText", parent.inspect)
+    end
+    @t = parent
+    @path = @id = $tk_text_mark
+    $tk_text_mark = $tk_text_mark.succ
+    tk_call @t.path, 'mark', 'set', @id, index
+    @t._addtag id, self
+  end
+  def id
+    return @id
+  end
+
+  def set(where)
+    tk_call @t.path, 'mark', 'set', @id, where
+  end
+
+  def unset
+    tk_call @t.path, 'mark', 'unset', @id
+  end
+  alias destroy unset
+
+  def gravity
+    tk_call @t.path, 'mark', 'gravity', @id
+  end
+
+  def gravity=(direction)
+    tk_call @t.path, 'mark', 'gravity', @id, direction
+  end
+end
+
+class TkTextMarkInsert<TkTextMark
+  def initialize(parent, index=nil)
+    if not parent.kind_of?(TkText)
+      fail format("%s need to be TkText", parent.inspect)
+    end
+    @t = parent
+    @path = @id = 'insert'
+    tk_call @t.path, 'mark', 'set', @id, index if index
+    @t._addtag id, self
+  end
+end
+
+class TkTextMarkCurrent<TkTextMark
+  def initialize(parent,index=nil)
+    if not parent.kind_of?(TkText)
+      fail format("%s need to be TkText", parent.inspect)
+    end
+    @t = parent
+    @path = @id = 'current'
+    tk_call @t.path, 'mark', 'set', @id, index if index
+    @t._addtag id, self
+  end
+end
+
+class TkTextMarkAnchor<TkTextMark
+  def initialize(parent,index=nil)
+    if not parent.kind_of?(TkText)
+      fail format("%s need to be TkText", parent.inspect)
+    end
+    @t = parent
+    @path = @id = 'anchor'
+    tk_call @t.path, 'mark', 'set', @id, index if index
+    @t._addtag id, self
+  end
+end
+
+class TkTextWindow<TkObject
+  def initialize(parent, index, keys)
+    if not parent.kind_of?(TkText)
+      fail format("%s need to be TkText", parent.inspect)
+    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(@t.path,'index',index.path) == tk_call(@t.path,'index','end')
+	@path = TkTextMark.new(@t, tk_call(@t.path, 'index', 'end - 1 chars'))
+      else
+	@path = TkTextMark.new(@t, tk_call(@t.path, 'index', index.path))
+      end
+    else
+      @path = TkTextMark.new(@t, tk_call(@t.path, 'index', index))
+    end
+    @path.gravity = 'left'
+    @index = @path.path
+    @id = keys['window']
+    if keys['create']
+      @p_create = keys['create']
+      if @p_create.kind_of? Proc
+	keys['create'] = install_cmd(proc{@id = @p_create.call; @id.path})
+      end
+    end
+    tk_call @t.path, 'window', 'create', @index, *hash_kv(keys)
+  end
+
+  def [](slot)
+    cget(slot)
+  end
+  def []=(slot, value)
+    configure(slot, value)
+  end
+
+  def cget(slot)
+    tk_tcl2ruby tk_call @t.path, 'window', 'cget', @index, "-#{slot}"
+  end
+
+  def configure(slot, value=None)
+    if slot.kind_of? Hash
+      @id = slot['window'] if slot['window']
+      if slot['create']
+	self.create=value
+	slot['create']=nil
+      end
+      if slot.size > 0
+	tk_call @t.path, 'window', 'configure', @index, *hash_kv(slot)
+      end
+    else
+      @id = value if slot == 'window'
+      if slot == 'create'
+	self.create=value
+      else
+	tk_call @t.path, 'window', 'configure', @index, "-#{slot}", value
+      end
+    end
+  end
+
+  def window
+    @id
+  end
+
+  def window=(value)
+    tk_call @t.path, 'window', 'configure', @index, '-window', value
+    @id = 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})
+    end
+    tk_call @t.path, 'window', 'configure', @index, '-create', value
+  end
+
+  def configinfo(slot = nil)
+    if slot
+      conf = tk_split_list(tk_call @t.path, 'window', 'configure', 
+			   @index, "-#{slot}")
+      conf[0] = conf[0][1..-1]
+      conf
+    else
+      tk_split_list(tk_call @t.path, 'window', 'configure', 
+		    @index).collect{|conf|
+	conf[0] = conf[0][1..-1]
+	conf
+      }
+    end
+  end
+
+  def _dump(type, *index)
+    str = tk_send('dump', type, *index)
+    result = []
+    sel = nil
+    i = 0
+    while i < str.size
+      # retrieve key
+      idx = str.index(/ /, i)
+      result.push str[i..(idx-1)]
+      i = idx + 1
+      
+      # retrieve value
+      case result[-1]
+      when 'text'
+	if str[i] == ?{
+	  # text formed as {...}
+	  val, i = _retrieve_braced_text(str, i)
+	  result.push val
+	else
+	  # text which may contain backslahes
+	  val, i = _retrieve_backslashed_text(str, i)
+	  result.push val
+	end
+      else
+	idx = str.index(/ /, i)
+	val = str[i..(idx-1)]
+	case result[-1]
+	when 'mark'
+	  case val
+	  when 'insert'
+	    result.push TkTextMarkInsert.new(self)
+	  when 'current'
+	    result.push TkTextMarkCurrent.new(self)
+	  when 'anchor'
+	    result.push TkTextMarkAnchor.new(self)
+	  else
+	    result.push tk_tcl2rb(val)
+	  end
+	when 'tagon'
+	  if val == 'sel'
+	    if sel
+	      result.push sel
+	    else
+	      result.push TkTextTagSel.new(self)
+	    end
+	  else
+	    result.push tk_tcl2rb val
+	  end
+	when 'tagoff'
+	    result.push tk_tcl2rb sel
+	when 'window'
+	  result.push tk_tcl2rb val
+	end
+	i = idx + 1
+      end
+
+      # retrieve index
+      idx = str.index(/ /, i)
+      if idx
+	result.push str[i..(idx-1)]
+	i = idx + 1
+      else
+	result.push str[i..-1]
+	break
+      end
+    end
+    
+    kvis = []
+    until result.empty?
+      kvis.push [result.shift, result.shift, result.shift]
+    end
+    kvis  # result is [[key1, value1, index1], [key2, value2, index2], ...]
+  end
+  private :_dump
+
+  def _retrieve_braced_text(str, i)
+    cnt = 0
+    idx = i
+    while idx < str.size
+      case str[idx]
+      when ?{
+	cnt += 1
+      when ?}
+	cnt -= 1
+	if cnt == 0
+	  break
+	end
+      end
+      idx += 1
+    end
+    return str[i+1..idx-1], idx + 2
+  end
+  private :_retrieve_braced_text
+
+  def _retrieve_backslashed_text(str, i)
+    j = i
+    idx = nil
+    loop {
+      idx = str.index(/ /, j)
+      if str[idx-1] == ?\\
+	j += 1
+      else
+	break
+      end
+    }
+    val = str[i..(idx-1)]
+    val.gsub!(/\\( |\{|\})/, '\1')
+    return val, idx + 1
+  end
+  private :_retrieve_backslashed_text
+
+  def dump_all(*index)
+    _dump('-all', *index)
+  end
+  def dump_mark(*index)
+    _dump('-mark', *index)
+  end
+  def dump_tag(*index)
+    _dump('-tag', *index)
+  end
+  def dump_text(*index)
+    _dump('-text', *index)
+  end
+  def dump_window(*index)
+    _dump('-window', *index)
+  end
+end
+
+class TkTextImage<TkObject
+  def initialize(parent, index, keys)
+    if not parent.kind_of?(TkText)
+      fail format("%s need to be TkText", parent.inspect)
+    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(@t.path,'index',index.path) == tk_call(@t.path,'index','end')
+	@path = TkTextMark.new(@t, tk_call(@t.path, 'index', 'end - 1 chars'))
+      else
+	@path = TkTextMark.new(@t, tk_call(@t.path, 'index', index.path))
+      end
+    else
+      @path = TkTextMark.new(@t, tk_call(@t.path, 'index', index))
+    end
+    @path.gravity = 'left'
+    @index = @path.path
+    @id = tk_call(@t.path, 'image', 'create', @index, *hash_kv(keys))
+  end
+
+  def [](slot)
+    cget(slot)
+  end
+  def []=(slot, value)
+    configure(slot, value)
+  end
+
+  def cget(slot)
+    tk_tcl2ruby tk_call @t.path, 'image', 'cget', @index, "-#{slot}"
+  end
+
+  def configure(slot, value=None)
+    if slot.kind_of? Hash
+      tk_call @t.path, 'image', 'configure', @index, *hash_kv(slot)
+    else
+      tk_call @t.path, 'image', 'configure', @index, "-#{slot}", value
+    end
+  end
+#  def configure(slot, value)
+#    tk_call @t.path, 'image', 'configure', @index, "-#{slot}", value
+#  end
+
+  def image
+    tk_call @t.path, 'image', 'configure', @index, '-image'
+  end
+
+  def image=(value)
+    tk_call @t.path, 'image', 'configure', @index, '-image', value
+  end
+
+  def configinfo(slot = nil)
+    if slot
+      conf = tk_split_list(tk_call @t.path, 'image', 'configure', 
+			   @index, "-#{slot}")
+      conf[0] = conf[0][1..-1]
+      conf
+    else
+      tk_split_list(tk_call @t.path, 'image', 'configure', 
+		    @index).collect{|conf|
+	conf[0] = conf[0][1..-1]
+	conf
+      }
+    end
+  end
+end
diff --git a/ext/tk/lib/tkvirtevent.rb b/ext/tk/lib/tkvirtevent.rb
new file mode 100644
index 0000000000..0d100c2186
--- /dev/null
+++ b/ext/tk/lib/tkvirtevent.rb
@@ -0,0 +1,66 @@
+#
+#   tkvirtevent.rb : treats virtual events
+#                     1998/07/16 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
+#
+require 'tk'
+
+class TkVirtualEvent<TkObject
+  extend Tk
+
+  TkVirturlEventID = [0]
+  TkVirturlEventTBL = {}
+
+  def TkVirtualEvent.getobj(event)
+    obj = TkVirturlEventTBL[event]
+    obj ? obj : event
+  end
+
+  def TkVirtualEvent.info
+    tk_call('event', 'info').split(/\s+/).filter{|seq|
+      TkVirtualEvent.getobj(seq[1..-2])
+    }
+  end
+
+  def initialize(*sequences)
+    @path = @id = format("<VirtEvent%.4d>", TkVirturlEventID[0])
+    TkVirturlEventID[0] += 1
+    add(*sequences)
+  end
+
+  def add(*sequences)
+    if sequences != []
+      tk_call('event', 'add', "<#{@id}>", 
+	      *(sequences.collect{|seq| "<#{tk_event_sequence(seq)}>"}) )
+      TkVirturlEventTBL[@id] = self
+    end
+    self
+  end
+
+  def delete(*sequences)
+    if sequences == []
+      tk_call('event', 'delete', "<#{@id}>")
+      TkVirturlEventTBL[@id] = nil
+    else
+      tk_call('event', 'delete', "<#{@id}>", 
+	      *(sequences.collect{|seq| "<#{tk_event_sequence(seq)}>"}) )
+      TkVirturlEventTBL[@id] = nil if info == []
+    end
+    self
+  end
+
+  def info
+    tk_call('event', 'info', "<#{@id}>").split(/\s+/).filter{|seq|
+      l = seq.scan(/<*[^<>]+>*/).filter{|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
-- 
cgit v1.2.3