1.1c8

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

14 files changed, 0 insertions, 5934 deletions

diff --git a/lib/tk.rb b/lib/tk.rb
deleted file mode 100644
index e32723be96..0000000000
--- a/lib/tk.rb
+++ /dev/null
@@ -1,2499 +0,0 @@
-#
-#		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 = [] if not @cmdtbl
-    @cmdtbl.push id
-    return format("rb_out %s", id);
-  end
-  def uninstall_cmd(id)
-    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
-    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
-	INTERP._eval(format('global %s; unset %s'), @id, @id)
-	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; 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' )
-	font_configure({slot=>value})
-      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
-  WidgetClassName = 'Button'.freeze
-  TkClassBind::WidgetClassNameTBL[WidgetClassName] = self
-#  def TkButton.to_eval
-  def self.to_eval
-    WidgetClassName
-  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
-  WidgetClassName = 'Radiobutton'.freeze
-  TkClassBind::WidgetClassNameTBL[WidgetClassName] = self
-  def TkRadioButton.to_eval
-    WidgetClassName
-  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', path).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, index, *more)
-    v = tk_send('xview', cmd, index, *more)
-    v.to_i if more.size == 0
-  end
-  def yview(cmd, index, *more)
-    v = tk_send('yview', cmd, index, *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 entryconfigure(index, keys=nil)
-    tk_send 'entryconfigure', index, *hash_kv(keys)
-  end
-#  def entryconfigure(index, keys=nil)
-#    tk_send 'entryconfigure', index, *hash_kv(keys)
-#  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
-  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/lib/tkafter.rb b/lib/tkafter.rb
deleted file mode 100644
index be2e50ff3a..0000000000
--- a/lib/tkafter.rb
+++ /dev/null
@@ -1,296 +0,0 @@
-#
-#   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/lib/tkbgerror.rb b/lib/tkbgerror.rb
deleted file mode 100644
index 8022077a3f..0000000000
--- a/lib/tkbgerror.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-#
-#  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/lib/tkcanvas.rb b/lib/tkcanvas.rb
deleted file mode 100644
index 1cf24eeb7b..0000000000
--- a/lib/tkcanvas.rb
+++ /dev/null
@@ -1,829 +0,0 @@
-#
-#		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/lib/tkclass.rb b/lib/tkclass.rb
deleted file mode 100644
index 0b33d4ec8b..0000000000
--- a/lib/tkclass.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-#
-#		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/lib/tkdialog.rb b/lib/tkdialog.rb
deleted file mode 100644
index 1133db6ae9..0000000000
--- a/lib/tkdialog.rb
+++ /dev/null
@@ -1,141 +0,0 @@
-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/lib/tkentry.rb b/lib/tkentry.rb
deleted file mode 100644
index b834c455c6..0000000000
--- a/lib/tkentry.rb
+++ /dev/null
@@ -1,73 +0,0 @@
-#
-#		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/lib/tkfont.rb b/lib/tkfont.rb
deleted file mode 100644
index 1c11f8f842..0000000000
--- a/lib/tkfont.rb
+++ /dev/null
@@ -1,939 +0,0 @@
-#
-#  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
-	list(tk_call('font', 'families', '-displayof', window))
-      else
-	list(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_list(tk_call(*args))
-      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\.*/
-      conf = tk_split_list(tk_call(*args))
-      unless font_inf = conf.assoc('-font')
-	raise RuntimeError, "unknown option '-font'"
-      end
-      fnt = font_inf[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: '*'
-
-    Array([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
-      Array([ ['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_list(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
-      Array([ ['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_list(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(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', '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
-      Array([ ['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)
-    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)
-  end
-
-  def kanji_replace(knj)
-    kanji_replace_core(knj)
-  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
-
-  ###################################
-  # 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/lib/tkmenubar.rb b/lib/tkmenubar.rb
deleted file mode 100644
index 441f3f5c03..0000000000
--- a/lib/tkmenubar.rb
+++ /dev/null
@@ -1,137 +0,0 @@
-#
-# 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/lib/tkmngfocus.rb b/lib/tkmngfocus.rb
deleted file mode 100644
index 921fb646e7..0000000000
--- a/lib/tkmngfocus.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-#
-#   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/lib/tkpalette.rb b/lib/tkpalette.rb
deleted file mode 100644
index a2dc7c87cb..0000000000
--- a/lib/tkpalette.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-#
-#   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/lib/tkscrollbox.rb b/lib/tkscrollbox.rb
deleted file mode 100644
index 8d129b2f4b..0000000000
--- a/lib/tkscrollbox.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-#
-#		tkscrollbox.rb - Tk Listbox with Scrollbar
-#                                 as an example of Composite Widget
-#			$Date$
-#			by Yukihiro Matsumoto <matz@caelum.co.jp>
-
-require 'tk.rb'
-
-class TkScrollbox<TkListbox
-  include TkComposite
-  def initialize_composite
-    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)
-  end
-end
diff --git a/lib/tktext.rb b/lib/tktext.rb
deleted file mode 100644
index 02d5a7f3e0..0000000000
--- a/lib/tktext.rb
+++ /dev/null
@@ -1,797 +0,0 @@
-#
-#		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=Proc.new, args=nil)
-  end
-
-  def tag_bind_append(tag, seq, cmd=Proc.new, args=nil)
-    _tag_bind_core('+', tag, seq, cmd=Proc.new, 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 @t.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_call '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_list(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_list(tk_send('tag', 'nextrange', tag, first, last))
-  end
-
-  def tag_prevrange(tag, first, last=None)
-    tk_split_list(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, keys=nil)
-    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)
-    configure(keys) if keys
-    @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_list(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_list(tk_call(@t.path, 'tag', 'nextrange', @id, first, last))
-  end
-
-  def prevrange(first, last=None)
-    tk_split_list(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 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
-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/lib/tkvirtevent.rb b/lib/tkvirtevent.rb
deleted file mode 100644
index 0d100c2186..0000000000
--- a/lib/tkvirtevent.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-#
-#   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