tk_as_gem 0.0.0

data/ext/lib/tk/text.rb

@@ -0,0 +1,1596 @@
+#
+#               tk/text.rb - Tk text classes
+#                       by Yukihiro Matsumoto <matz@caelum.co.jp>
+require 'tk'
+require 'tk/itemfont'
+require 'tk/itemconfig'
+require 'tk/scrollable'
+require 'tk/txtwin_abst'
+
+module TkTextTagConfig
+  include TkTreatItemFont
+  include TkItemConfigMethod
+
+  def __item_cget_cmd(id)  # id := [ type, tagOrId ]
+    [self.path, id[0], 'cget', id[1]]
+  end
+  private :__item_cget_cmd
+
+  def __item_config_cmd(id)  # id := [ type, tagOrId ]
+    [self.path, id[0], 'configure', id[1]]
+  end
+  private :__item_config_cmd
+
+  def __item_pathname(id)
+    if id.kind_of?(Array)
+      id = tagid(id[1])
+    end
+    [self.path, id].join(';')
+  end
+  private :__item_pathname
+
+  def tag_cget(tagOrId, option)
+    itemcget(['tag', tagOrId], option)
+  end
+  def tag_cget_strict(tagOrId, option)
+    itemcget_strict(['tag', tagOrId], option)
+  end
+  def tag_configure(tagOrId, slot, value=None)
+    itemconfigure(['tag', tagOrId], slot, value)
+  end
+  def tag_configinfo(tagOrId, slot=nil)
+    itemconfiginfo(['tag', tagOrId], slot)
+  end
+  def current_tag_configinfo(tagOrId, slot=nil)
+    current_itemconfiginfo(['tag', tagOrId], slot)
+  end
+
+  def window_cget(tagOrId, option)
+    itemcget(['window', tagOrId], option)
+  end
+  def window_cget_strict(tagOrId, option)
+    itemcget_strict(['window', tagOrId], option)
+  end
+  def window_configure(tagOrId, slot, value=None)
+    itemconfigure(['window', tagOrId], slot, value)
+  end
+  def window_configinfo(tagOrId, slot=nil)
+    itemconfiginfo(['window', tagOrId], slot)
+  end
+  def current_window_configinfo(tagOrId, slot=nil)
+    current_itemconfiginfo(['window', tagOrId], slot)
+  end
+
+  private :itemcget, :itemcget_strict
+  private :itemconfigure, :itemconfiginfo, :current_itemconfiginfo
+end
+
+class Tk::Text<TkTextWin
+  ItemConfCMD = ['tag'.freeze, 'configure'.freeze].freeze
+  #include TkTreatTextTagFont
+  include TkTextTagConfig
+  include Scrollable
+
+  #######################################
+
+  module IndexModMethods
+    def +(mod)
+      return chars(mod) if mod.kind_of?(Numeric)
+
+      mod = mod.to_s
+      if mod =~ /^\s*[+-]?\d/
+        Tk::Text::IndexString.new(String.new(id) << ' + ' << mod)
+      else
+        Tk::Text::IndexString.new(String.new(id) << ' ' << mod)
+      end
+    end
+
+    def -(mod)
+      return chars(-mod) if mod.kind_of?(Numeric)
+
+      mod = mod.to_s
+      if mod =~ /^\s*[+-]?\d/
+        Tk::Text::IndexString.new(String.new(id) << ' - ' << mod)
+      elsif mod =~ /^\s*[-]\s+(\d.*)$/
+        Tk::Text::IndexString.new(String.new(id) << ' - -' << $1)
+      else
+        Tk::Text::IndexString.new(String.new(id) << ' ' << mod)
+      end
+    end
+
+    def chars(mod)
+      fail ArgumentError, 'expect Integer'  unless mod.kind_of?(Integer)
+      if mod < 0
+        Tk::Text::IndexString.new(String.new(id) << ' ' << mod.to_s << ' chars')
+      else
+        Tk::Text::IndexString.new(String.new(id) << ' + ' << mod.to_s << ' chars')
+      end
+    end
+    alias char chars
+
+    def display_chars(mod)
+      # Tk8.5 feature
+      fail ArgumentError, 'expect Integer'  unless mod.kind_of?(Integer)
+      if mod < 0
+        Tk::Text::IndexString.new(String.new(id) << ' ' << mod.to_s << ' display chars')
+      else
+        Tk::Text::IndexString.new(String.new(id) << ' + ' << mod.to_s << ' display chars')
+      end
+    end
+    alias display_char display_chars
+
+    def any_chars(mod)
+      # Tk8.5 feature
+      fail ArgumentError, 'expect Integer'  unless mod.kind_of?(Integer)
+      if mod < 0
+        Tk::Text::IndexString.new(String.new(id) << ' ' << mod.to_s << ' any chars')
+      else
+        Tk::Text::IndexString.new(String.new(id) << ' + ' << mod.to_s << ' any chars')
+      end
+    end
+    alias any_char any_chars
+
+    def indices(mod)
+      # Tk8.5 feature
+      fail ArgumentError, 'expect Integer'  unless mod.kind_of?(Integer)
+      if mod < 0
+        Tk::Text::IndexString.new(String.new(id) << ' ' << mod.to_s << ' indices')
+      else
+        Tk::Text::IndexString.new(String.new(id) << ' + ' << mod.to_s << ' indices')
+      end
+    end
+
+    def display_indices(mod)
+      # Tk8.5 feature
+      fail ArgumentError, 'expect Integer'  unless mod.kind_of?(Integer)
+      if mod < 0
+        Tk::Text::IndexString.new(String.new(id) << ' ' << mod.to_s << ' display indices')
+      else
+        Tk::Text::IndexString.new(String.new(id) << ' + ' << mod.to_s << ' display indices')
+      end
+    end
+
+    def any_indices(mod)
+      # Tk8.5 feature
+      fail ArgumentError, 'expect Integer'  unless mod.kind_of?(Integer)
+      if mod < 0
+        Tk::Text::IndexString.new(String.new(id) << ' ' << mod.to_s << ' any indices')
+      else
+        Tk::Text::IndexString.new(String.new(id) << ' + ' << mod.to_s << ' any indices')
+      end
+    end
+
+    def lines(mod)
+      fail ArgumentError, 'expect Integer'  unless mod.kind_of?(Integer)
+      if mod < 0
+        Tk::Text::IndexString.new(String.new(id) << ' ' << mod.to_s << ' lines')
+      else
+        Tk::Text::IndexString.new(String.new(id) << ' + ' << mod.to_s << ' lines')
+      end
+    end
+    alias line lines
+
+    def display_lines(mod)
+      # Tk8.5 feature
+      fail ArgumentError, 'expect Integer'  unless mod.kind_of?(Integer)
+      if mod < 0
+        Tk::Text::IndexString.new(String.new(id) << ' ' << mod.to_s << ' display_lines')
+      else
+        Tk::Text::IndexString.new(String.new(id) << ' + ' << mod.to_s << ' display lines')
+      end
+    end
+    alias display_line display_lines
+
+    def any_lines(mod)
+      # Tk8.5 feature
+      fail ArgumentError, 'expect Integer'  unless mod.kind_of?(Integer)
+      if mod < 0
+        Tk::Text::IndexString.new(String.new(id) << ' ' << mod.to_s << ' any_lines')
+      else
+        Tk::Text::IndexString.new(String.new(id) << ' + ' << mod.to_s << ' any lines')
+      end
+    end
+    alias any_line any_lines
+
+    def linestart
+      Tk::Text::IndexString.new(String.new(id) << ' linestart')
+    end
+    def lineend
+      Tk::Text::IndexString.new(String.new(id) << ' lineend')
+    end
+
+    def display_linestart
+      # Tk8.5 feature
+      Tk::Text::IndexString.new(String.new(id) << ' display linestart')
+    end
+    def display_lineend
+      # Tk8.5 feature
+      Tk::Text::IndexString.new(String.new(id) << ' display lineend')
+    end
+
+    def wordstart
+      Tk::Text::IndexString.new(String.new(id) << ' wordstart')
+    end
+    def wordend
+      Tk::Text::IndexString.new(String.new(id) << ' wordend')
+    end
+
+    def display_wordstart
+      # Tk8.5 feature
+      Tk::Text::IndexString.new(String.new(id) << ' display wordstart')
+    end
+    def display_wordend
+      # Tk8.5 feature
+      Tk::Text::IndexString.new(String.new(id) << ' display wordend')
+    end
+  end
+
+  class IndexString < String
+    include IndexModMethods
+
+    def self.at(x,y)
+      self.new("@#{x},#{y}")
+    end
+
+    def self.new(str)
+      if str.kind_of?(String)
+        super(str)
+      elsif str.kind_of?(Symbol)
+        super(str.to_s)
+      else
+        str
+      end
+    end
+
+    def id
+      self
+    end
+  end
+
+  #######################################
+
+  TkCommandNames = ['text'.freeze].freeze
+  WidgetClassName = 'Text'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+  def self.new(*args, &block)
+    obj = super(*args){}
+    obj.init_instance_variable
+    if TkCore::WITH_RUBY_VM  ### Ruby 1.9 !!!!
+      obj.instance_exec(obj, &block) if defined? yield
+    else
+      obj.instance_eval(&block) if defined? yield
+    end
+    obj
+  end
+
+  def init_instance_variable
+    @cmdtbl = []
+    @tags = {}
+  end
+
+  def __destroy_hook__
+    TkTextTag::TTagID_TBL.mutex.synchronize{
+      TkTextTag::TTagID_TBL.delete(@path)
+    }
+    TkTextTag::TMarkID_TBL.mutex.synchronize{
+      TkTextMark::TMarkID_TBL.delete(@path)
+    }
+  end
+
+  def create_self(keys)
+    #if keys and keys != None
+    #  #tk_call_without_enc('text', @path, *hash_kv(keys, true))
+    #  tk_call_without_enc(self.class::TkCommandNames[0], @path, 
+    #                     *hash_kv(keys, true))
+    #else
+    #  #tk_call_without_enc('text', @path)
+    #  tk_call_without_enc(self.class::TkCommandNames[0], @path)
+    #end
+    super(keys)
+    init_instance_variable
+  end
+  private :create_self
+
+  def __strval_optkeys
+    super() << 'inactiveseletcionbackground'
+  end
+  private :__strval_optkeys
+
+  def self.at(x, y)
+    Tk::Text::IndexString.at(x, y)
+  end
+
+  def at(x, y)
+    Tk::Text::IndexString.at(x, y)
+  end
+
+  def index(idx)
+    Tk::Text::IndexString.new(tk_send_without_enc('index', 
+                                                  _get_eval_enc_str(idx)))
+  end
+
+  def get_displaychars(*index)
+    # Tk8.5 feature
+    get('-displaychars', *index)
+  end
+
+  def value
+    _fromUTF8(tk_send_without_enc('get', "1.0", "end - 1 char"))
+  end
+
+  def value= (val)
+    tk_send_without_enc('delete', "1.0", 'end')
+    tk_send_without_enc('insert', "1.0", _get_eval_enc_str(val))
+    val
+  end
+
+  def clear
+    tk_send_without_enc('delete', "1.0", 'end')
+    self
+  end
+  alias erase clear
+
+  def _addcmd(cmd)
+    @cmdtbl.push cmd
+  end
+
+  def _addtag(name, obj)
+    @tags[name] = obj
+  end
+
+  def tagid(tag)
+    if tag.kind_of?(TkTextTag) \
+      || tag.kind_of?(TkTextMark) \
+      || tag.kind_of?(TkTextImage) \
+      || tag.kind_of?(TkTextWindow)
+      tag.id
+    else
+      tag  # maybe an Array of configure paramters
+    end
+  end
+  private :tagid
+
+  def tagid2obj(tagid)
+    if @tags[tagid]
+      @tags[tagid]
+    else
+      tagid
+    end
+  end
+
+  def tag_names(index=None)
+    #tk_split_simplelist(_fromUTF8(tk_send_without_enc('tag', 'names', _get_eval_enc_str(index)))).collect{|elt|
+    tk_split_simplelist(tk_send_without_enc('tag', 'names', _get_eval_enc_str(index)), false, true).collect{|elt|
+      tagid2obj(elt)
+    }
+  end
+
+  def mark_names
+    #tk_split_simplelist(_fromUTF8(tk_send_without_enc('mark', 'names'))).collect{|elt|
+    tk_split_simplelist(tk_send_without_enc('mark', 'names'), false, true).collect{|elt|
+      tagid2obj(elt)
+    }
+  end
+
+  def mark_gravity(mark, direction=nil)
+    if direction
+      tk_send_without_enc('mark', 'gravity', 
+                          _get_eval_enc_str(mark), direction)
+      self
+    else
+      tk_send_without_enc('mark', 'gravity', _get_eval_enc_str(mark))
+    end
+  end
+
+  def mark_set(mark, index)
+    tk_send_without_enc('mark', 'set', _get_eval_enc_str(mark), 
+                        _get_eval_enc_str(index))
+    self
+  end
+  alias set_mark mark_set
+
+  def mark_unset(*marks)
+    tk_send_without_enc('mark', 'unset', 
+                        *(marks.collect{|mark| _get_eval_enc_str(mark)}))
+    self
+  end
+  alias unset_mark mark_unset
+
+  def mark_next(index)
+    tagid2obj(_fromUTF8(tk_send_without_enc('mark', 'next', 
+                                            _get_eval_enc_str(index))))
+  end
+  alias next_mark mark_next
+
+  def mark_previous(index)
+    tagid2obj(_fromUTF8(tk_send_without_enc('mark', 'previous', 
+                                            _get_eval_enc_str(index))))
+  end
+  alias previous_mark mark_previous
+
+  def image_cget_strict(index, slot)
+    case slot.to_s
+    when 'text', 'label', 'show', 'data', 'file'
+      _fromUTF8(tk_send_without_enc('image', 'cget', 
+                                    _get_eval_enc_str(index), "-#{slot}"))
+    else
+      tk_tcl2ruby(_fromUTF8(tk_send_without_enc('image', 'cget', 
+                                                _get_eval_enc_str(index), 
+                                                "-#{slot}")))
+    end
+  end
+
+  def image_cget(index, slot)
+    unless TkItemConfigMethod.__IGNORE_UNKNOWN_CONFIGURE_OPTION__
+      image_cget_strict(index, slot)
+    else
+      begin
+        image_cget_strict(index, slot)
+      rescue => e
+        begin
+          if current_image_configinfo(index).has_key?(slot.to_s)
+            # not tag error & option is known -> error on known option
+            fail e
+          else
+            # not tag error & option is unknown
+            nil
+          end
+        rescue
+          fail e  # tag error
+        end
+      end
+    end
+  end
+
+  def image_configure(index, slot, value=None)
+    if slot.kind_of?(Hash)
+      _fromUTF8(tk_send_without_enc('image', 'configure', 
+                                    _get_eval_enc_str(index), 
+                                    *hash_kv(slot, true)))
+    else
+      _fromUTF8(tk_send_without_enc('image', 'configure', 
+                                    _get_eval_enc_str(index), 
+                                    "-#{slot}", 
+                                    _get_eval_enc_str(value)))
+    end
+    self
+  end
+
+  def image_configinfo(index, slot = nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if slot
+        case slot.to_s
+        when 'text', 'label', 'show', 'data', 'file'
+          #conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('image', 'configure', _get_eval_enc_str(index), "-#{slot}")))
+          conf = tk_split_simplelist(tk_send_without_enc('image', 'configure', _get_eval_enc_str(index), "-#{slot}"), false, true)
+        else
+          #conf = tk_split_list(_fromUTF8(tk_send_without_enc('image', 'configure', _get_eval_enc_str(index), "-#{slot}")))
+          conf = tk_split_list(tk_send_without_enc('image', 'configure', _get_eval_enc_str(index), "-#{slot}"), 0, false, true)
+        end
+        conf[0] = conf[0][1..-1]
+        conf
+      else
+        # tk_split_simplelist(_fromUTF8(tk_send_without_enc('image', 'configure', _get_eval_enc_str(index)))).collect{|conflist|
+        #  conf = tk_split_simplelist(conflist)
+        tk_split_simplelist(tk_send_without_enc('image', 'configure', _get_eval_enc_str(index)), false, false).collect{|conflist|
+          conf = tk_split_simplelist(conflist, false, true)
+          conf[0] = conf[0][1..-1]
+          case conf[0]
+          when 'text', 'label', 'show', 'data', 'file'
+          else
+            if conf[3]
+              if conf[3].index('{')
+                conf[3] = tk_split_list(conf[3]) 
+              else
+                conf[3] = tk_tcl2ruby(conf[3]) 
+              end
+            end
+            if conf[4]
+              if conf[4].index('{')
+                conf[4] = tk_split_list(conf[4]) 
+              else
+                conf[4] = tk_tcl2ruby(conf[4]) 
+              end
+            end
+          end
+          conf[1] = conf[1][1..-1] if conf.size == 2 # alias info
+          conf
+        }
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      if slot
+        case slot.to_s
+        when 'text', 'label', 'show', 'data', 'file'
+          #conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('image', 'configure', _get_eval_enc_str(index), "-#{slot}")))
+          conf = tk_split_simplelist(tk_send_without_enc('image', 'configure', _get_eval_enc_str(index), "-#{slot}"), false, true)
+        else
+          #conf = tk_split_list(_fromUTF8(tk_send_without_enc('image', 'configure', _get_eval_enc_str(index), "-#{slot}")))
+          conf = tk_split_list(tk_send_without_enc('image', 'configure', _get_eval_enc_str(index), "-#{slot}"), 0, false, true)
+        end
+        key = conf.shift[1..-1]
+        { key => conf }
+      else
+        ret = {}
+        #tk_split_simplelist(_fromUTF8(tk_send_without_enc('image', 'configure', _get_eval_enc_str(index)))).each{|conflist|
+        #  conf = tk_split_simplelist(conflist)
+        tk_split_simplelist(tk_send_without_enc('image', 'configure', _get_eval_enc_str(index)), false, false).each{|conflist|
+          conf = tk_split_simplelist(conflist, false, true)
+          key = conf.shift[1..-1]
+          case key
+          when 'text', 'label', 'show', 'data', 'file'
+          else
+            if conf[2]
+              if conf[2].index('{')
+                conf[2] = tk_split_list(conf[2]) 
+              else
+                conf[2] = tk_tcl2ruby(conf[2]) 
+              end
+            end
+            if conf[3]
+              if conf[3].index('{')
+                conf[3] = tk_split_list(conf[3]) 
+              else
+                conf[3] = tk_tcl2ruby(conf[3]) 
+              end
+            end
+          end
+          if conf.size == 1
+            ret[key] = conf[0][1..-1]  # alias info
+          else
+            ret[key] = conf
+          end
+        }
+        ret
+      end
+    end
+  end
+
+  def current_image_configinfo(index, slot = nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if slot
+        conf = image_configinfo(index, slot)
+        {conf[0] => conf[4]}
+      else
+        ret = {}
+        image_configinfo(index).each{|conf|
+          ret[conf[0]] = conf[4] if conf.size > 2
+        }
+        ret
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      ret = {}
+      image_configinfo(index, slot).each{|k, conf|
+        ret[k] = conf[-1] if conf.kind_of?(Array)
+      }
+      ret
+    end
+  end
+
+  def image_names
+    #tk_split_simplelist(_fromUTF8(tk_send_without_enc('image', 'names'))).collect{|elt|
+    tk_split_simplelist(tk_send_without_enc('image', 'names'), false, true).collect{|elt|
+      tagid2obj(elt)
+    }
+  end
+
+  def set_insert(index)
+    tk_send_without_enc('mark','set','insert', _get_eval_enc_str(index))
+    self
+  end
+
+  def set_current(index)
+    tk_send_without_enc('mark','set','current', _get_eval_enc_str(index))
+    self
+  end
+
+  def insert(index, chars, *tags)
+    if tags[0].kind_of?(Array)
+      # multiple chars-taglist argument :: str, [tag,...], str, [tag,...], ...
+      args = [chars]
+      while tags.size > 0
+        args << tags.shift.collect{|x|_get_eval_string(x)}.join(' ')  # taglist
+        args << tags.shift if tags.size > 0                           # chars
+      end
+      super(index, *args)
+    else
+      # single chars-taglist argument :: str, tag, tag, ...
+      if tags.size == 0
+        super(index, chars)
+      else
+        super(index, chars, tags.collect{|x|_get_eval_string(x)}.join(' '))
+      end
+    end
+  end
+
+  def destroy
+    @tags = {} unless @tags
+    @tags.each_value do |t|
+      t.destroy
+    end
+    super()
+  end
+
+  def backspace
+    self.delete 'insert'
+  end
+
+  def bbox(index)
+    list(tk_send_without_enc('bbox', _get_eval_enc_str(index)))
+  end
+
+  def compare(idx1, op, idx2)
+    bool(tk_send_without_enc('compare', _get_eval_enc_str(idx1), 
+                             op, _get_eval_enc_str(idx2)))
+  end
+
+  def count(idx1, idx2, *opts)
+    # opts are Tk8.5 feature
+    cnt = 0
+    args = opts.collect{|opt|
+      str = opt.to_s
+      cnt += 1 if str != 'update'
+      '-' + str
+    }
+    args << _get_eval_enc_str(idx1) << _get_eval_enc_str(idx2)
+    if cnt <= 1
+      number(tk_send_without_enc('count', *opts))
+    else
+      list(tk_send_without_enc('count', *opts))
+    end
+  end
+
+  def count_info(idx1, idx2, update=true)
+    # Tk8.5 feature
+    opts = [
+      :chars, :displaychars, :displayindices, :displaylines, 
+      :indices, :lines, :xpixels, :ypixels
+    ]
+    if update
+      lst = count(idx1, idx2, :update, *opts)
+    else
+      lst = count(idx1, idx2, *opts)
+    end
+    info = {}
+    opts.each_with_index{|key, idx| info[key] = lst[idx]}
+    info
+  end
+
+  def peer_names()
+    # Tk8.5 feature
+    list(tk_send_without_enc('peer', 'names'))
+  end
+
+  def replace(idx1, idx2, *opts)
+    tk_send('replace', idx1, idx2, *opts)
+    self
+  end
+
+  def debug
+    bool(tk_send_without_enc('debug'))
+  end
+  def debug=(boolean)
+    tk_send_without_enc('debug', boolean)
+    #self
+    boolean
+  end
+
+  def dlineinfo(index)
+    list(tk_send_without_enc('dlineinfo', _get_eval_enc_str(index)))
+  end
+
+  def modified?
+    bool(tk_send_without_enc('edit', 'modified'))
+  end
+  def modified(mode)
+    tk_send_without_enc('edit', 'modified', mode)
+    self
+  end
+  def modified=(mode)
+    modified(mode)
+    mode
+  end
+
+  def edit_redo
+    tk_send_without_enc('edit', 'redo')
+    self
+  end
+  def edit_reset
+    tk_send_without_enc('edit', 'reset')
+    self
+  end
+  def edit_separator
+    tk_send_without_enc('edit', 'separator')
+    self
+  end
+  def edit_undo
+    tk_send_without_enc('edit', 'undo')
+    self
+  end
+
+  def xview_pickplace(index)
+    tk_send_without_enc('xview', '-pickplace', _get_eval_enc_str(index))
+    self
+  end
+
+  def yview_pickplace(index)
+    tk_send_without_enc('yview', '-pickplace', _get_eval_enc_str(index))
+    self
+  end
+
+  def text_copy
+    # Tk8.4 feature
+    tk_call_without_enc('tk_textCopy', @path)
+    self
+  end
+
+  def text_cut
+    # Tk8.4 feature
+    tk_call_without_enc('tk_textCut', @path)
+    self
+  end
+
+  def text_paste
+    # Tk8.4 feature
+    tk_call_without_enc('tk_textPaste', @path)
+    self
+  end
+
+  def tag_add(tag, index1, index2=None)
+    tk_send_without_enc('tag', 'add', _get_eval_enc_str(tag), 
+                        _get_eval_enc_str(index1), 
+                        _get_eval_enc_str(index2))
+    self
+  end
+  alias addtag tag_add
+  alias add_tag tag_add
+
+  def tag_delete(*tags)
+    tk_send_without_enc('tag', 'delete', 
+                        *(tags.collect{|tag| _get_eval_enc_str(tag)}))
+    TkTextTag::TTagID_TBL.mutex.synchronize{
+      if TkTextTag::TTagID_TBL[@path]
+        tags.each{|tag|
+          if tag.kind_of?(TkTextTag)
+            TkTextTag::TTagID_TBL[@path].delete(tag.id) 
+          else
+            TkTextTag::TTagID_TBL[@path].delete(tag) 
+          end
+        }
+      end
+    }
+    self
+  end
+  alias deltag tag_delete
+  alias delete_tag tag_delete
+
+  #def tag_bind(tag, seq, cmd=Proc.new, *args)
+  #  _bind([@path, 'tag', 'bind', tag], seq, cmd, *args)
+  #  self
+  #end
+  def tag_bind(tag, seq, *args)
+    # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
+    if TkComm._callback_entry?(args[0]) || !block_given?
+      cmd = args.shift
+    else
+      cmd = Proc.new
+    end
+    _bind([@path, 'tag', 'bind', tag], seq, cmd, *args)
+    self
+  end
+
+  #def tag_bind_append(tag, seq, cmd=Proc.new, *args)
+  #  _bind_append([@path, 'tag', 'bind', tag], seq, cmd, *args)
+  #  self
+  #end
+  def tag_bind_append(tag, seq, *args)
+    # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
+    if TkComm._callback_entry?(args[0]) || !block_given?
+      cmd = args.shift
+    else
+      cmd = Proc.new
+    end
+    _bind_append([@path, 'tag', 'bind', tag], seq, cmd, *args)
+    self
+  end
+
+  def tag_bind_remove(tag, seq)
+    _bind_remove([@path, 'tag', 'bind', tag], seq)
+    self
+  end
+
+  def tag_bindinfo(tag, context=nil)
+    _bindinfo([@path, 'tag', 'bind', tag], context)
+  end
+
+=begin
+  def tag_cget(tag, key)
+    case key.to_s
+    when 'text', 'label', 'show', 'data', 'file'
+      tk_call_without_enc(@path, 'tag', 'cget', 
+                          _get_eval_enc_str(tag), "-#{key}")
+    when 'font', 'kanjifont'
+      #fnt = tk_tcl2ruby(tk_send('tag', 'cget', tag, "-#{key}"))
+      fnt = tk_tcl2ruby(_fromUTF8(tk_send_without_enc('tag','cget',_get_eval_enc_str(tag),'-font')))
+      unless fnt.kind_of?(TkFont)
+        fnt = tagfontobj(tag, fnt)
+      end
+      if key.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
+        # obsolete; just for compatibility
+        fnt.kanji_font
+      else
+        fnt
+      end
+    else
+      tk_tcl2ruby(_fromUTF8(tk_call_without_enc(@path,'tag','cget',_get_eval_enc_str(tag),"-#{key}")))
+    end
+  end
+
+  def tag_configure(tag, key, val=None)
+    if key.kind_of?(Hash)
+      key = _symbolkey2str(key)
+      if ( key['font'] || key['kanjifont'] \
+          || key['latinfont'] || key['asciifont'] )
+        tagfont_configure(tag, key)
+      else
+        tk_send_without_enc('tag', 'configure', _get_eval_enc_str(tag), 
+                            *hash_kv(key, true))
+      end
+
+    else
+      if  key == 'font' || key == :font || 
+          key == 'kanjifont' || key == :kanjifont ||
+          key == 'latinfont' || key == :latinfont || 
+          key == 'asciifont' || key == :asciifont
+        if val == None
+          tagfontobj(tag)
+        else
+          tagfont_configure(tag, {key=>val})
+        end
+      else
+        tk_send_without_enc('tag', 'configure', _get_eval_enc_str(tag), 
+                            "-#{key}", _get_eval_enc_str(val))
+      end
+    end
+    self
+  end
+
+  def tag_configinfo(tag, key=nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+        case key.to_s
+        when 'text', 'label', 'show', 'data', 'file'
+          conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('tag','configure',_get_eval_enc_str(tag),"-#{key}")))
+        when 'font', 'kanjifont'
+          conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('tag','configure',_get_eval_enc_str(tag),"-#{key}")))
+          conf[4] = tagfont_configinfo(tag, conf[4])
+        else
+          conf = tk_split_list(_fromUTF8(tk_send_without_enc('tag','configure',_get_eval_enc_str(tag),"-#{key}")))
+        end
+        conf[0] = conf[0][1..-1]
+        conf
+      else
+        ret = tk_split_simplelist(_fromUTF8(tk_send('tag','configure',_get_eval_enc_str(tag)))).collect{|conflist|
+          conf = tk_split_simplelist(conflist)
+          conf[0] = conf[0][1..-1]
+          case conf[0]
+          when 'text', 'label', 'show', 'data', 'file'
+          else
+            if conf[3]
+              if conf[3].index('{')
+                conf[3] = tk_split_list(conf[3]) 
+              else
+                conf[3] = tk_tcl2ruby(conf[3]) 
+              end
+            end
+            if conf[4]
+              if conf[4].index('{')
+                conf[4] = tk_split_list(conf[4]) 
+              else
+                conf[4] = tk_tcl2ruby(conf[4]) 
+              end
+            end
+          end
+          conf[1] = conf[1][1..-1] if conf.size == 2 # alias info
+          conf
+        }
+        fontconf = ret.assoc('font')
+        if fontconf
+          ret.delete_if{|item| item[0] == 'font' || item[0] == 'kanjifont'}
+          fontconf[4] = tagfont_configinfo(tag, fontconf[4])
+          ret.push(fontconf)
+        else
+          ret
+        end
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+        case key.to_s
+        when 'text', 'label', 'show', 'data', 'file'
+          conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('tag','configure',_get_eval_enc_str(tag),"-#{key}")))
+        when 'font', 'kanjifont'
+          conf = tk_split_simplelist(_fromUTF8(tk_send_without_enc('tag','configure',_get_eval_enc_str(tag),"-#{key}")))
+          conf[4] = tagfont_configinfo(tag, conf[4])
+        else
+          conf = tk_split_list(_fromUTF8(tk_send_without_enc('tag','configure',_get_eval_enc_str(tag),"-#{key}")))
+        end
+        key = conf.shift[1..-1]
+        { key => conf }
+      else
+        ret = {}
+        tk_split_simplelist(_fromUTF8(tk_send('tag','configure',_get_eval_enc_str(tag)))).each{|conflist|
+          conf = tk_split_simplelist(conflist)
+          key = conf.shift[1..-1]
+          case key
+          when 'text', 'label', 'show', 'data', 'file'
+          else
+            if conf[2]
+              if conf[2].index('{')
+                conf[2] = tk_split_list(conf[2]) 
+              else
+                conf[2] = tk_tcl2ruby(conf[2]) 
+              end
+            end
+            if conf[3]
+              if conf[3].index('{')
+                conf[3] = tk_split_list(conf[3]) 
+              else
+                conf[3] = tk_tcl2ruby(conf[3]) 
+              end
+            end
+          end
+          if conf.size == 1
+            ret[key] = conf[0][1..-1]  # alias info
+          else
+            ret[key] = conf
+          end
+        }
+        fontconf = ret['font']
+        if fontconf
+          ret.delete('font')
+          ret.delete('kanjifont')
+          fontconf[3] = tagfont_configinfo(tag, fontconf[3])
+          ret['font'] = fontconf
+        end
+        ret
+      end
+    end
+  end
+
+  def current_tag_configinfo(tag, key=nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if key
+        conf = tag_configinfo(tag, key)
+        {conf[0] => conf[4]}
+      else
+        ret = {}
+        tag_configinfo(tag).each{|conf|
+          ret[conf[0]] = conf[4] if conf.size > 2
+        }
+        ret
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      ret = {}
+      tag_configinfo(tag, key).each{|k, conf|
+        ret[k] = conf[-1] if conf.kind_of?(Array)
+      }
+      ret
+    end
+  end
+=end
+
+  def tag_raise(tag, above=None)
+    tk_send_without_enc('tag', 'raise', _get_eval_enc_str(tag), 
+                        _get_eval_enc_str(above))
+    self
+  end
+
+  def tag_lower(tag, below=None)
+    tk_send_without_enc('tag', 'lower', _get_eval_enc_str(tag), 
+                        _get_eval_enc_str(below))
+    self
+  end
+
+  def tag_remove(tag, *indices)
+    tk_send_without_enc('tag', 'remove', _get_eval_enc_str(tag), 
+                        *(indices.collect{|idx| _get_eval_enc_str(idx)}))
+    self
+  end
+
+  def tag_ranges(tag)
+    #l = tk_split_simplelist(tk_send_without_enc('tag', 'ranges',
+    #                                            _get_eval_enc_str(tag)))
+    l = tk_split_simplelist(tk_send_without_enc('tag', 'ranges',
+                                                _get_eval_enc_str(tag)), 
+                            false, true)
+    r = []
+    while key=l.shift
+      r.push [Tk::Text::IndexString.new(key), Tk::Text::IndexString.new(l.shift)]
+    end
+    r
+  end
+
+  def tag_nextrange(tag, first, last=None)
+    simplelist(tk_send_without_enc('tag', 'nextrange', 
+                                   _get_eval_enc_str(tag), 
+                                   _get_eval_enc_str(first), 
+                                   _get_eval_enc_str(last))).collect{|idx|
+      Tk::Text::IndexString.new(idx)
+    }
+  end
+
+  def tag_prevrange(tag, first, last=None)
+    simplelist(tk_send_without_enc('tag', 'prevrange', 
+                                   _get_eval_enc_str(tag), 
+                                   _get_eval_enc_str(first), 
+                                   _get_eval_enc_str(last))).collect{|idx|
+      Tk::Text::IndexString.new(idx)
+    }
+  end
+
+=begin
+  def window_cget(index, slot)
+    case slot.to_s
+    when 'text', 'label', 'show', 'data', 'file'
+      _fromUTF8(tk_send_without_enc('window', 'cget', 
+                                    _get_eval_enc_str(index), "-#{slot}"))
+    when 'font', 'kanjifont'
+      #fnt = tk_tcl2ruby(tk_send('window', 'cget', index, "-#{slot}"))
+      fnt = tk_tcl2ruby(_fromUTF8(tk_send_without_enc('window', 'cget', _get_eval_enc_str(index), '-font')))
+      unless fnt.kind_of?(TkFont)
+        fnt = tagfontobj(index, fnt)
+      end
+      if slot.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
+        # obsolete; just for compatibility
+        fnt.kanji_font
+      else
+        fnt
+      end
+    else
+      tk_tcl2ruby(_fromUTF8(tk_send_without_enc('window', 'cget', _get_eval_enc_str(index), "-#{slot}")))
+    end
+  end
+
+  def window_configure(index, slot, value=None)
+    if index.kind_of?(TkTextWindow)
+      index.configure(slot, value)
+    else
+      if slot.kind_of?(Hash)
+        slot = _symbolkey2str(slot)
+        win = slot['window']
+        # slot['window'] = win.epath if win.kind_of?(TkWindow)
+        slot['window'] = _epath(win) if win
+        if slot['create']
+          p_create = slot['create']
+          if p_create.kind_of?(Proc)
+#=begin
+            slot['create'] = install_cmd(proc{
+                                           id = p_create.call
+                                           if id.kind_of?(TkWindow)
+                                             id.epath
+                                           else
+                                             id
+                                           end
+                                         })
+#=end
+            slot['create'] = install_cmd(proc{_epath(p_create.call)})
+          end
+        end
+        tk_send_without_enc('window', 'configure', 
+                            _get_eval_enc_str(index), 
+                            *hash_kv(slot, true))
+      else
+        if slot == 'window' || slot == :window
+          # id = value 
+          # value = id.epath if id.kind_of?(TkWindow)
+          value = _epath(value)
+        end
+        if slot == 'create' || slot == :create
+          p_create = value
+          if p_create.kind_of?(Proc)
+#=begin
+            value = install_cmd(proc{
+                                  id = p_create.call
+                                  if id.kind_of?(TkWindow)
+                                    id.epath
+                                  else
+                                    id
+                                  end
+                                })
+#=end
+            value = install_cmd(proc{_epath(p_create.call)})
+          end
+        end
+        tk_send_without_enc('window', 'configure', 
+                            _get_eval_enc_str(index), 
+                            "-#{slot}", _get_eval_enc_str(value))
+      end
+    end
+    self
+  end
+
+  def window_configinfo(win, slot = nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if slot
+        case slot.to_s
+        when 'text', 'label', 'show', 'data', 'file'
+          conf = tk_split_simplelist(_fromUTF8(tk_send('window', 'configure', _get_eval_enc_str(win), "-#{slot}")))
+        else
+          conf = tk_split_list(_fromUTF8(tk_send('window', 'configure', _get_eval_enc_str(win), "-#{slot}")))
+        end
+        conf[0] = conf[0][1..-1]
+        conf
+      else
+        tk_split_simplelist(_fromUTF8(tk_send('window', 'configure', _get_eval_enc_str(win)))).collect{|conflist|
+          conf = tk_split_simplelist(conflist)
+          conf[0] = conf[0][1..-1]
+          case conf[0]
+          when 'text', 'label', 'show', 'data', 'file'
+          else
+            if conf[3]
+              if conf[3].index('{')
+                conf[3] = tk_split_list(conf[3]) 
+              else
+                conf[3] = tk_tcl2ruby(conf[3]) 
+              end
+            end
+            if conf[4]
+              if conf[4].index('{')
+                conf[4] = tk_split_list(conf[4]) 
+              else
+                conf[4] = tk_tcl2ruby(conf[4]) 
+              end
+            end
+          end
+          conf[1] = conf[1][1..-1] if conf.size == 2 # alias info
+          conf
+        }
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      if slot
+        case slot.to_s
+        when 'text', 'label', 'show', 'data', 'file'
+          conf = tk_split_simplelist(_fromUTF8(tk_send('window', 'configure', _get_eval_enc_str(win), "-#{slot}")))
+        else
+          conf = tk_split_list(_fromUTF8(tk_send('window', 'configure', _get_eval_enc_str(win), "-#{slot}")))
+        end
+        key = conf.shift[1..-1]
+        { key => conf }
+      else
+        ret = {}
+        tk_split_simplelist(_fromUTF8(tk_send('window', 'configure', _get_eval_enc_str(win)))).each{|conflist|
+          conf = tk_split_simplelist(conflist)
+          key = conf.shift[1..-1]
+          case key
+          when 'text', 'label', 'show', 'data', 'file'
+          else
+            if conf[2]
+              if conf[2].index('{')
+                conf[2] = tk_split_list(conf[2]) 
+              else
+                conf[2] = tk_tcl2ruby(conf[2]) 
+              end
+            end
+            if conf[3]
+              if conf[3].index('{')
+                conf[3] = tk_split_list(conf[3]) 
+              else
+                conf[3] = tk_tcl2ruby(conf[3]) 
+              end
+            end
+          end
+          if conf.size == 1
+            ret[key] = conf[0][1..-1]  # alias info
+          else
+            ret[key] = conf
+          end
+        }
+        ret
+      end
+    end
+  end
+
+  def current_window_configinfo(win, slot = nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if slot
+        conf = window_configinfo(win, slot)
+        {conf[0] => conf[4]}
+      else
+        ret = {}
+        window_configinfo(win).each{|conf|
+          ret[conf[0]] = conf[4] if conf.size > 2
+        }
+        ret
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      ret = {}
+      window_configinfo(win, slot).each{|k, conf|
+        ret[k] = conf[-1] if conf.kind_of?(Array)
+      }
+      ret
+    end
+  end
+=end
+
+  def window_names
+    # tk_split_simplelist(_fromUTF8(tk_send_without_enc('window', 'names'))).collect{|elt|
+    tk_split_simplelist(tk_send_without_enc('window', 'names'), false, true).collect{|elt|
+      tagid2obj(elt)
+    }
+  end
+
+  def _ktext_length(txt)
+    if TkCore::WITH_ENCODING ### Ruby 1.9 !!!!!!!!!!!!!
+      return txt.length
+    end
+    ###########################
+
+    if $KCODE !~ /n/i
+      return txt.gsub(/[^\Wa-zA-Z_\d]/, ' ').length
+    end
+
+    # $KCODE == 'NONE'
+    if JAPANIZED_TK
+      tk_call_without_enc('kstring', 'length', 
+                          _get_eval_enc_str(txt)).to_i
+    else
+      begin
+        tk_call_without_enc('encoding', 'convertto', 'ascii', 
+                            _get_eval_enc_str(txt)).length
+      rescue StandardError, NameError
+        # sorry, I have no plan
+        txt.length
+      end
+    end
+  end
+  private :_ktext_length
+
+  def tksearch(*args)
+    # call 'search' subcommand of text widget
+    #   args ::= [<array_of_opts>] <pattern> <start_index> [<stop_index>]
+    # If <pattern> is regexp, then it must be a regular expression of Tcl
+    nocase = false
+    if args[0].kind_of?(Array)
+      opts = args.shift.collect{|opt|
+        s_opt = opt.to_s
+        nocase = true if s_opt == 'nocase'
+        '-' + s_opt
+      }
+    else
+      opts = []
+    end
+
+    if args[0].kind_of?(Regexp)
+      regexp = args.shift
+      if !nocase && (regexp.options & Regexp::IGNORECASE) != 0
+        opts << '-nocase'
+      end
+      args.unshift(regexp.source)
+    end
+
+    opts << '--'
+
+    ret = tk_send('search', *(opts + args))
+    if ret == ""
+      nil
+    else
+      Tk::Text::IndexString.new(ret)
+    end
+  end
+
+  def tksearch_with_count(*args)
+    # call 'search' subcommand of text widget
+    #   args ::= [<array_of_opts>] <var> <pattern> <start_index> [<stop_index>]
+    # If <pattern> is regexp, then it must be a regular expression of Tcl
+    nocase = false
+    if args[0].kind_of?(Array)
+      opts = args.shift.collect{|opt|
+        s_opt = opt.to_s
+        nocase = true if s_opt == 'nocase'
+        '-' + s_opt
+      }
+    else
+      opts = []
+    end
+
+    opts << '-count' << args.shift
+
+    if args[0].kind_of?(Regexp)
+      regexp = args.shift
+      if !nocase && (regexp.options & Regexp::IGNORECASE) != 0
+        opts << '-nocase'
+      end
+      args.unshift(regexp.source)
+    end
+
+    opts << '--'
+
+    ret = tk_send('search', *(opts + args))
+    if ret == ""
+      nil
+    else
+      Tk::Text::IndexString.new(ret)
+    end
+  end
+
+  def search_with_length(pat,start,stop=None)
+    pat = pat.chr if pat.kind_of?(Integer)
+    if stop != None
+      return ["", 0] if compare(start,'>=',stop)
+      txt = get(start,stop)
+      if (pos = txt.index(pat))
+        match = $&
+        #pos = txt[0..(pos-1)].split('').length if pos > 0
+        pos = _ktext_length(txt[0..(pos-1)]) if pos > 0
+        if pat.kind_of?(String)
+          #return [index(start + " + #{pos} chars"), pat.split('').length]
+          return [index(start + " + #{pos} chars"), 
+                  _ktext_length(pat), pat.dup]
+        else
+          #return [index(start + " + #{pos} chars"), $&.split('').length]
+          return [index(start + " + #{pos} chars"), 
+                  _ktext_length(match), match]
+        end
+      else
+        return ["", 0]
+      end
+    else
+      txt = get(start,'end - 1 char')
+      if (pos = txt.index(pat))
+        match = $&
+        #pos = txt[0..(pos-1)].split('').length if pos > 0
+        pos = _ktext_length(txt[0..(pos-1)]) if pos > 0
+        if pat.kind_of?(String)
+          #return [index(start + " + #{pos} chars"), pat.split('').length]
+          return [index(start + " + #{pos} chars"), 
+                  _ktext_length(pat), pat.dup]
+        else
+          #return [index(start + " + #{pos} chars"), $&.split('').length]
+          return [index(start + " + #{pos} chars"), 
+                  _ktext_length(match), match]
+        end
+      else
+        txt = get('1.0','end - 1 char')
+        if (pos = txt.index(pat))
+          match = $&
+          #pos = txt[0..(pos-1)].split('').length if pos > 0
+          pos = _ktext_length(txt[0..(pos-1)]) if pos > 0
+          if pat.kind_of?(String)
+            #return [index("1.0 + #{pos} chars"), pat.split('').length]
+            return [index("1.0 + #{pos} chars"), 
+                    _ktext_length(pat), pat.dup]
+          else
+            #return [index("1.0 + #{pos} chars"), $&.split('').length]
+            return [index("1.0 + #{pos} chars"), _ktext_length(match), match]
+          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.chr if pat.kind_of?(Integer)
+    if stop != None
+      return ["", 0] if compare(start,'<=',stop)
+      txt = get(stop,start)
+      if (pos = txt.rindex(pat))
+        match = $&
+        #pos = txt[0..(pos-1)].split('').length if pos > 0
+        pos = _ktext_length(txt[0..(pos-1)]) if pos > 0
+        if pat.kind_of?(String)
+          #return [index(stop + " + #{pos} chars"), pat.split('').length]
+          return [index(stop + " + #{pos} chars"), _ktext_length(pat), pat.dup]
+        else
+          #return [index(stop + " + #{pos} chars"), $&.split('').length]
+          return [index(stop + " + #{pos} chars"), _ktext_length(match), match]
+        end
+      else
+        return ["", 0]
+      end
+    else
+      txt = get('1.0',start)
+      if (pos = txt.rindex(pat))
+        match = $&
+        #pos = txt[0..(pos-1)].split('').length if pos > 0
+        pos = _ktext_length(txt[0..(pos-1)]) if pos > 0
+        if pat.kind_of?(String)
+          #return [index("1.0 + #{pos} chars"), pat.split('').length]
+          return [index("1.0 + #{pos} chars"), _ktext_length(pat), pat.dup]
+        else
+          #return [index("1.0 + #{pos} chars"), $&.split('').length]
+          return [index("1.0 + #{pos} chars"), _ktext_length(match), match]
+        end
+      else
+        txt = get('1.0','end - 1 char')
+        if (pos = txt.rindex(pat))
+          match = $&
+          #pos = txt[0..(pos-1)].split('').length if pos > 0
+          pos = _ktext_length(txt[0..(pos-1)]) if pos > 0
+          if pat.kind_of?(String)
+            #return [index("1.0 + #{pos} chars"), pat.split('').length]
+            return [index("1.0 + #{pos} chars"), _ktext_length(pat), pat.dup]
+          else
+            #return [index("1.0 + #{pos} chars"), $&.split('').length]
+            return [index("1.0 + #{pos} chars"), _ktext_length(match), match]
+          end
+        else
+          return ["", 0]
+        end
+      end
+    end
+  end
+
+  def rsearch(pat,start,stop=None)
+    rsearch_with_length(pat,start,stop)[0]
+  end
+
+  def dump(type_info, *index, &block)
+    if type_info.kind_of?(Symbol)
+      type_info = [ type_info.to_s ]
+    elsif type_info.kind_of?(String)
+      type_info = [ type_info ]
+    end
+    args = type_info.collect{|inf| '-' + inf}
+    args << '-command' << block if block
+    str = tk_send('dump', *(args + index))
+    result = []
+    sel = nil
+    i = 0
+    while i < str.size
+      # retrieve key
+      idx = str.index(/ /, i)
+      result.push str[i..(idx-1)]
+      i = idx + 1
+      
+      # retrieve value
+      case result[-1]
+      when 'text'
+        if str[i] == ?{
+          # text formed as {...}
+          val, i = _retrieve_braced_text(str, i)
+          result.push val
+        else
+          # text which may contain backslahes
+          val, i = _retrieve_backslashed_text(str, i)
+          result.push val
+        end
+      else
+        idx = str.index(/ /, i)
+        val = str[i..(idx-1)]
+        case result[-1]
+        when 'mark'
+          case val
+          when 'insert'
+            result.push TkTextMarkInsert.new(self)
+          when 'current'
+            result.push TkTextMarkCurrent.new(self)
+          when 'anchor'
+            result.push TkTextMarkAnchor.new(self)
+          else
+            result.push tk_tcl2ruby(val)
+          end
+        when 'tagon'
+          if val == 'sel'
+            if sel
+              result.push sel
+            else
+              result.push TkTextTagSel.new(self)
+            end
+          else
+            result.push tk_tcl2ruby(val)
+          end
+        when 'tagoff'
+            result.push tk_tcl2ruby(val)
+        when 'window'
+          result.push tk_tcl2ruby(val)
+        when 'image'
+          result.push tk_tcl2ruby(val)
+        end
+        i = idx + 1
+      end
+
+      # retrieve index
+      idx = str.index(/ /, i)
+      if idx
+        result.push(Tk::Text::IndexString.new(str[i..(idx-1)]))
+        i = idx + 1
+      else
+        result.push(Tk::Text::IndexString.new(str[i..-1]))
+        break
+      end
+    end
+    
+    kvis = []
+    until result.empty?
+      kvis.push [result.shift, result.shift, result.shift]
+    end
+    kvis  # result is [[key1, value1, index1], [key2, value2, index2], ...]
+  end
+
+  def _retrieve_braced_text(str, i)
+    cnt = 0
+    idx = i
+    while idx < str.size
+      case str[idx]
+      when ?{
+        cnt += 1
+      when ?}
+        cnt -= 1
+        if cnt == 0
+          break
+        end
+      end
+      idx += 1
+    end
+    return str[i+1..idx-1], idx + 2
+  end
+  private :_retrieve_braced_text
+
+  def _retrieve_backslashed_text(str, i)
+    j = i
+    idx = nil
+    loop {
+      idx = str.index(/ /, j)
+      if str[idx-1] == ?\\
+        j += 1
+      else
+        break
+      end
+    }
+    val = str[i..(idx-1)]
+    val.gsub!(/\\( |\{|\})/, '\1')
+    return val, idx + 1
+  end
+  private :_retrieve_backslashed_text
+
+  def dump_all(*index, &block)
+    dump(['all'], *index, &block)
+  end
+  def dump_mark(*index, &block)
+    dump(['mark'], *index, &block)
+  end
+  def dump_tag(*index, &block)
+    dump(['tag'], *index, &block)
+  end
+  def dump_text(*index, &block)
+    dump(['text'], *index, &block)
+  end
+  def dump_window(*index, &block)
+    dump(['window'], *index, &block)
+  end
+  def dump_image(*index, &block)
+    dump(['image'], *index, &block)
+  end
+end
+
+#TkText = Tk::Text unless Object.const_defined? :TkText
+Tk.__set_toplevel_aliases__(:Tk, Tk::Text, :TkText)
+
+
+#######################################
+
+class Tk::Text::Peer < Tk::Text
+  # Tk8.5 feature
+  def initialize(text, parent=nil, keys={})
+    unless text.kind_of?(Tk::Text)
+      fail ArgumentError, "Tk::Text is expected for 1st argument"
+    end
+    @src_text = text
+    super(parent, keys)
+  end
+
+  def create_self(keys)
+    if keys and keys != None
+      tk_call_without_enc(@src_text.path, 'peer', 'create', @path)
+    else
+      tk_call_without_enc(@src_text.path, 'peer', 'create', @path)
+    end
+  end
+  private :create_self
+end