tk 0.1.0

data/lib/tk/image.rb

@@ -0,0 +1,396 @@
+# frozen_string_literal: false
+#
+# tk/image.rb : treat Tk image objects
+#
+
+require 'tk'
+
+class TkImage<TkObject
+  include Tk
+
+  TkCommandNames = ['image'.freeze].freeze
+
+  Tk_IMGTBL = TkCore::INTERP.create_table
+
+  (Tk_Image_ID = ['i'.freeze, TkUtil.untrust('00000')]).instance_eval{
+    @mutex = Mutex.new
+    def mutex; @mutex; end
+    freeze
+  }
+
+  TkCore::INTERP.init_ip_env{
+    Tk_IMGTBL.mutex.synchronize{ Tk_IMGTBL.clear }
+  }
+
+  def self.new(keys=nil)
+    if keys.kind_of?(Hash)
+      name = nil
+      if keys.key?(:imagename)
+        name = keys[:imagename]
+      elsif keys.key?('imagename')
+        name = keys['imagename']
+      end
+      if name
+        if name.kind_of?(TkImage)
+          obj = name
+        else
+          name = _get_eval_string(name)
+          obj = nil
+          Tk_IMGTBL.mutex.synchronize{
+            obj = Tk_IMGTBL[name]
+          }
+        end
+        if obj
+          if !(keys[:without_creating] || keys['without_creating'])
+            keys = _symbolkey2str(keys)
+            keys.delete('imagename')
+            keys.delete('without_creating')
+            obj.instance_eval{
+              tk_call_without_enc('image', 'create',
+                                  @type, @path, *hash_kv(keys, true))
+            }
+          end
+          return obj
+        end
+      end
+    end
+    (obj = self.allocate).instance_eval{
+      Tk_IMGTBL.mutex.synchronize{
+        initialize(keys)
+        Tk_IMGTBL[@path] = self
+      }
+    }
+    obj
+  end
+
+  def initialize(keys=nil)
+    @path = nil
+    without_creating = false
+    if keys.kind_of?(Hash)
+      keys = _symbolkey2str(keys)
+      @path = keys.delete('imagename')
+      without_creating = keys.delete('without_creating')
+    end
+    unless @path
+      Tk_Image_ID.mutex.synchronize{
+        @path = Tk_Image_ID.join(TkCore::INTERP._ip_id_)
+        Tk_Image_ID[1].succ!
+      }
+    end
+    unless without_creating
+      tk_call_without_enc('image', 'create',
+                          @type, @path, *hash_kv(keys, true))
+    end
+  end
+
+  def delete
+    Tk_IMGTBL.mutex.synchronize{
+      Tk_IMGTBL.delete(@id) if @id
+    }
+    tk_call_without_enc('image', 'delete', @path)
+    self
+  end
+  def height
+    number(tk_call_without_enc('image', 'height', @path))
+  end
+  def inuse
+    bool(tk_call_without_enc('image', 'inuse', @path))
+  end
+  def itemtype
+    tk_call_without_enc('image', 'type', @path)
+  end
+  def width
+    number(tk_call_without_enc('image', 'width', @path))
+  end
+
+  def TkImage.names
+    Tk_IMGTBL.mutex.synchronize{
+      Tk.tk_call_without_enc('image', 'names').split.collect!{|id|
+        (Tk_IMGTBL[id])? Tk_IMGTBL[id] : id
+      }
+    }
+  end
+
+  def TkImage.types
+    Tk.tk_call_without_enc('image', 'types').split
+  end
+end
+
+class TkBitmapImage<TkImage
+  def __strval_optkeys
+    super() + ['maskdata', 'maskfile']
+  end
+  private :__strval_optkeys
+
+  def initialize(*args)
+    @type = 'bitmap'
+    super(*args)
+  end
+end
+
+# A photo is an image whose pixels can display any color or be transparent.
+# At present, only GIF and PPM/PGM formats are supported, but an interface
+# exists to allow additional image file formats to be added easily.
+#
+# This class documentation is a copy from the original Tcl/Tk at
+# http://www.tcl.tk/man/tcl8.5/TkCmd/photo.htm with some rewritten parts.
+class TkPhotoImage<TkImage
+  NullArgOptionKeys = [ "shrink", "grayscale" ]
+
+  def _photo_hash_kv(keys)
+    keys = _symbolkey2str(keys)
+    NullArgOptionKeys.collect{|opt|
+      if keys[opt]
+        keys[opt] = None
+      else
+        keys.delete(opt)
+      end
+    }
+    keys.collect{|k,v|
+      ['-' << k, v]
+    }.flatten
+  end
+  private :_photo_hash_kv
+
+  # Create a new image with the given options.
+  # == Examples of use :
+  # === Create an empty image of 300x200 pixels
+  #
+  #		image = TkPhotoImage.new(:height => 200, :width => 300)
+  #
+  # === Create an image from a file
+  #
+  #		image = TkPhotoImage.new(:file: => 'my_image.gif')
+  #
+  # == Options
+  # Photos support the following options:
+  # * :data
+  #   Specifies the contents of the image as a string.
+  # * :format
+  #   Specifies the name of the file format for the data.
+  # * :file
+  #   Gives the name of a file that is to be read to supply data for the image.
+  # * :gamma
+  #   Specifies that the colors allocated for displaying this image in a window
+  #   should be corrected for a non-linear display with the specified gamma
+  #   exponent value.
+  # * height
+  #   Specifies the height of the image, in pixels. This option is useful
+  #   primarily in situations where the user wishes to build up the contents of
+  #   the image piece by piece. A value of zero (the default) allows the image
+  #   to expand or shrink vertically to fit the data stored in it.
+  # * palette
+  #   Specifies the resolution of the color cube to be allocated for displaying
+  #   this image.
+  # * width
+  #   Specifies the width of the image, in pixels. This option is useful
+  #   primarily in situations where the user wishes to build up the contents of
+  #   the image piece by piece. A value of zero (the default) allows the image
+  #   to expand or shrink horizontally to fit the data stored in it.
+  def initialize(*args)
+    @type = 'photo'
+    super(*args)
+  end
+
+  # Blank the image; that is, set the entire image to have no data, so it will
+  # be displayed as transparent, and the background of whatever window it is
+  # displayed in will show through.
+  def blank
+    tk_send_without_enc('blank')
+    self
+  end
+
+  def cget_strict(option)
+    case option.to_s
+    when 'data', 'file'
+      tk_send 'cget', '-' << option.to_s
+    else
+      tk_tcl2ruby(tk_send('cget', '-' << option.to_s))
+    end
+  end
+
+  # Returns the current value of the configuration option given by option.
+  # Example, display name of the file from which <tt>image</tt> was created:
+  # 	puts image.cget :file
+  def cget(option)
+    unless TkConfigMethod.__IGNORE_UNKNOWN_CONFIGURE_OPTION__
+      cget_strict(option)
+    else
+      begin
+        cget_strict(option)
+      rescue => e
+        if current_configinfo.has_key?(option.to_s)
+          # error on known option
+          fail e
+        else
+          # unknown option
+          nil
+        end
+      end
+    end
+  end
+
+  # Copies a region from the image called source to the image called
+  # destination, possibly with pixel zooming and/or subsampling. If no options
+  # are specified, this method copies the whole of source into destination,
+  # starting at coordinates (0,0) in destination. The following options may be
+  # specified:
+  #
+  # * :from [x1, y1, x2, y2]
+  #   Specifies a rectangular sub-region of the source image to be copied.
+  #   (x1,y1) and (x2,y2) specify diagonally opposite corners of the rectangle.
+  #   If x2 and y2 are not specified, the default value is the bottom-right
+  #   corner of the source image. The pixels copied will include the left and
+  #   top edges of the specified rectangle but not the bottom or right edges.
+  #   If the :from option is not given, the default is the whole source image.
+  # * :to [x1, y1, x2, y2]
+  #   Specifies a rectangular sub-region of the destination image to be
+  #   affected. (x1,y1) and (x2,y2) specify diagonally opposite corners of the
+  #   rectangle. If x2 and y2 are not specified, the default value is (x1,y1)
+  #   plus the size of the source region (after subsampling and zooming, if
+  #   specified). If x2 and  y2 are specified, the source region will be
+  #   replicated if necessary to fill the destination region in a tiled fashion.
+  # * :shrink
+  #   Specifies that the size of the destination image should be reduced, if
+  #   necessary, so that the region being copied into is at the bottom-right
+  #   corner of the image. This option will not affect the width or height of
+  #   the image if the user has specified a non-zero value for the :width or
+  #   :height configuration option, respectively.
+  # * :zoom [x, y]
+  #   Specifies that the source region should be magnified by a factor of x
+  #   in the X direction and y in the Y direction. If y is not given, the
+  #   default value is the same as x. With this option, each pixel in the
+  #   source image will be expanded into a block of x x y pixels in the
+  #   destination image, all the same color. x and y must be greater than 0.
+  # * :subsample [x, y]
+  #   Specifies that the source image should be reduced in size by using only
+  #   every xth pixel in the X direction and yth pixel in the Y direction.
+  #   Negative values will cause the image to be flipped about the Y or X axes,
+  #   respectively. If y is not given, the default value is the same as x.
+  # * :compositingrule rule
+  #   Specifies how transparent pixels in the source image are combined with
+  #   the destination image. When a compositing rule of <tt>overlay</tt> is set,
+  #   the old  contents of the destination image are visible, as if the source
+  #   image were  printed on a piece of transparent film and placed over the
+  #   top of the  destination. When a compositing rule of <tt>set</tt> is set,
+  #   the old contents of  the destination image are discarded and the source
+  #   image is used as-is. The default compositing rule is <tt>overlay</tt>.
+  def copy(src, *opts)
+    if opts.size == 0
+      tk_send('copy', src)
+    elsif opts.size == 1 && opts[0].kind_of?(Hash)
+      tk_send('copy', src, *_photo_hash_kv(opts[0]))
+    else
+      # for backward compatibility
+      args = opts.collect{|term|
+        if term.kind_of?(String) && term.include?(?\s)
+          term.split
+        else
+          term
+        end
+      }.flatten
+      tk_send('copy', src, *args)
+    end
+    self
+  end
+
+  # Returns image data in the form of a string. The following options may be
+  # specified:
+  # * :background color
+  #   If the color is specified, the data will not contain any transparency
+  #   information. In all transparent pixels the color will be replaced by the
+  #   specified color.
+  # * :format format-name
+  #   Specifies the name of the image file format handler to be used.
+  #   Specifically, this subcommand searches for the first handler whose name
+  #   matches an initial substring of format-name and which has the capability
+  #   to read this image data. If this option is not given, this subcommand
+  #   uses the first handler that has the capability to read the image data.
+  # * :from [x1, y1, x2, y2]
+  #   Specifies a rectangular region of imageName to be returned. If only x1
+  #   and y1 are specified, the region extends from (x1,y1) to the bottom-right
+  #   corner of imageName. If all four coordinates are given, they specify
+  #   diagonally opposite corners of the rectangular region, including x1,y1
+  #   and excluding x2,y2. The default, if this option is not given, is the
+  #   whole image.
+  # * :grayscale
+  #   If this options is specified, the data will not contain color information.
+  #   All pixel data will be transformed into grayscale.
+  def data(keys={})
+    tk_split_list(tk_send('data', *_photo_hash_kv(keys)))
+  end
+
+  # Returns the color of the pixel at coordinates (x,y) in the image as a list
+  # of three integers between 0 and 255, representing the red, green and blue
+  # components respectively.
+  def get(x, y)
+    tk_send('get', x, y).split.collect{|n| n.to_i}
+  end
+
+  def put(data, *opts)
+    if opts.empty?
+      tk_send('put', data)
+    elsif opts.size == 1 && opts[0].kind_of?(Hash)
+      tk_send('put', data, *_photo_hash_kv(opts[0]))
+    else
+      # for backward compatibility
+      tk_send('put', data, '-to', *opts)
+    end
+    self
+  end
+
+  def read(file, *opts)
+    if opts.size == 0
+      tk_send('read', file)
+    elsif opts.size == 1 && opts[0].kind_of?(Hash)
+      tk_send('read', file, *_photo_hash_kv(opts[0]))
+    else
+      # for backward compatibility
+      args = opts.collect{|term|
+        if term.kind_of?(String) && term.include?(?\s)
+          term.split
+        else
+          term
+        end
+      }.flatten
+      tk_send('read', file, *args)
+    end
+    self
+  end
+
+  def redither
+    tk_send 'redither'
+    self
+  end
+
+  # Returns a boolean indicating if the pixel at (x,y) is transparent.
+  def get_transparency(x, y)
+    bool(tk_send('transparency', 'get', x, y))
+  end
+
+  # Makes the pixel at (x,y) transparent if <tt>state</tt> is true, and makes
+  # that pixel opaque otherwise.
+  def set_transparency(x, y, state)
+    tk_send('transparency', 'set', x, y, state)
+    self
+  end
+
+  def write(file, *opts)
+    if opts.size == 0
+      tk_send('write', file)
+    elsif opts.size == 1 && opts[0].kind_of?(Hash)
+      tk_send('write', file, *_photo_hash_kv(opts[0]))
+    else
+      # for backward compatibility
+      args = opts.collect{|term|
+        if term.kind_of?(String) && term.include?(?\s)
+          term.split
+        else
+          term
+        end
+      }.flatten
+      tk_send('write', file, *args)
+    end
+    self
+  end
+end

data/lib/tk/itemconfig.rb

@@ -0,0 +1,1222 @@
+# frozen_string_literal: false
+#
+# tk/itemconfig.rb : control item/tag configuration of widget
+#
+require 'tk'
+require 'tkutil'
+require 'tk/itemfont.rb'
+
+module TkItemConfigOptkeys
+  include TkUtil
+
+  def __item_optkey_aliases(id)
+    {}
+  end
+  private :__item_optkey_aliases
+
+  def __item_numval_optkeys(id)
+    []
+  end
+  private :__item_numval_optkeys
+
+  def __item_numstrval_optkeys(id)
+    []
+  end
+  private :__item_numstrval_optkeys
+
+  def __item_boolval_optkeys(id)
+    ['exportselection', 'jump', 'setgrid', 'takefocus']
+  end
+  private :__item_boolval_optkeys
+
+  def __item_strval_optkeys(id)
+    # maybe need to override
+    [
+      'text', 'label', 'show', 'data', 'file', 'maskdata', 'maskfile',
+      'activebackground', 'activeforeground', 'background',
+      'disabledforeground', 'disabledbackground', 'foreground',
+      'highlightbackground', 'highlightcolor', 'insertbackground',
+      'selectbackground', 'selectforeground', 'troughcolor'
+    ]
+  end
+  private :__item_strval_optkeys
+
+  def __item_listval_optkeys(id)
+    []
+  end
+  private :__item_listval_optkeys
+
+  def __item_numlistval_optkeys(id)
+    # maybe need to override
+    ['dash', 'activedash', 'disableddash']
+  end
+  private :__item_numlistval_optkeys
+
+  def __item_tkvariable_optkeys(id)
+    ['variable', 'textvariable']
+  end
+  private :__item_tkvariable_optkeys
+
+  def __item_val2ruby_optkeys(id)  # { key=>method, ... }
+    # The method is used to convert a opt-value to a ruby's object.
+    # When get the value of the option "key", "method.call(id, val)" is called.
+    {}
+  end
+  private :__item_val2ruby_optkeys
+
+  def __item_ruby2val_optkeys(id)  # { key=>method, ... }
+    # The method is used to convert a ruby's object to a opt-value.
+    # When set the value of the option "key", "method.call(id, val)" is called.
+    # That is, "-#{key} #{method.call(id, value)}".
+    {}
+  end
+  private :__item_ruby2val_optkeys
+
+  def __item_methodcall_optkeys(id)  # { key=>method, ... }
+    # Use the method for both of get and set.
+    # Usually, the 'key' will not be a widget option.
+    #
+    # maybe need to override
+    # {'coords'=>'coords'}
+    {}
+  end
+  private :__item_methodcall_optkeys
+
+  ################################################
+
+  def __item_keyonly_optkeys(id)  # { def_key=>(undef_key|nil), ... }
+    # maybe need to override
+    {}
+  end
+  private :__item_keyonly_optkeys
+
+
+  def __conv_item_keyonly_opts(id, keys)
+    return keys unless keys.kind_of?(Hash)
+    keyonly = __item_keyonly_optkeys(id)
+    keys2 = {}
+    keys.each{|k, v|
+      optkey = keyonly.find{|kk,vv| kk.to_s == k.to_s}
+      if optkey
+        defkey, undefkey = optkey
+        if v
+          keys2[defkey.to_s] = None
+        else
+          keys2[undefkey.to_s] = None
+        end
+      else
+        keys2[k.to_s] = v
+      end
+    }
+    keys2
+  end
+
+  def itemconfig_hash_kv(id, keys, enc_mode = nil, conf = nil)
+    hash_kv(__conv_item_keyonly_opts(id, keys), enc_mode, conf)
+  end
+end
+
+module TkItemConfigMethod
+  include TkUtil
+  include TkTreatItemFont
+  include TkItemConfigOptkeys
+
+  def TkItemConfigMethod.__IGNORE_UNKNOWN_CONFIGURE_OPTION__
+    @mode || false
+  end
+  def TkItemConfigMethod.__set_IGNORE_UNKNOWN_CONFIGURE_OPTION__!(mode)
+    @mode = (mode)? true: false
+  end
+
+  def __item_cget_cmd(id)
+    # maybe need to override
+    [self.path, 'itemcget', id]
+  end
+  private :__item_cget_cmd
+
+  def __item_config_cmd(id)
+    # maybe need to override
+    [self.path, 'itemconfigure', id]
+  end
+  private :__item_config_cmd
+
+  def __item_confinfo_cmd(id)
+    # maybe need to override
+    __item_config_cmd(id)
+  end
+  private :__item_confinfo_cmd
+
+  def __item_configinfo_struct(id)
+    # maybe need to override
+    {:key=>0, :alias=>1, :db_name=>1, :db_class=>2,
+      :default_value=>3, :current_value=>4}
+  end
+  private :__item_configinfo_struct
+
+  ################################################
+
+  def tagid(tagOrId)
+    # maybe need to override
+    tagOrId
+  end
+
+  ################################################
+
+
+  def itemcget_tkstring(tagOrId, option)
+    opt = option.to_s
+    fail ArgumentError, "Invalid option `#{option.inspect}'" if opt.length == 0
+    tk_call_without_enc(*(__item_cget_cmd(tagid(tagOrId)) << "-#{opt}"))
+  end
+
+  def __itemcget_core(tagOrId, option)
+    orig_opt = option
+    option = option.to_s
+
+    if option.length == 0
+      fail ArgumentError, "Invalid option `#{orig_opt.inspect}'"
+    end
+
+    alias_name, real_name = __item_optkey_aliases(tagid(tagOrId)).find{|k, v| k.to_s == option}
+    if real_name
+      option = real_name.to_s
+    end
+
+    if ( method = _symbolkey2str(__item_val2ruby_optkeys(tagid(tagOrId)))[option] )
+      optval = tk_call_without_enc(*(__item_cget_cmd(tagid(tagOrId)) << "-#{option}"))
+      begin
+        return method.call(tagOrId, optval)
+      rescue => e
+        warn("Warning:: #{e.message} (when #{method}.call(#{tagOrId.inspect}, #{optval.inspect})") if $DEBUG
+        return optval
+      end
+    end
+
+    if ( method = _symbolkey2str(__item_methodcall_optkeys(tagid(tagOrId)))[option] )
+      return self.__send__(method, tagOrId)
+    end
+
+    case option
+    when /^(#{__item_numval_optkeys(tagid(tagOrId)).join('|')})$/
+      begin
+        number(tk_call_without_enc(*(__item_cget_cmd(tagid(tagOrId)) << "-#{option}")))
+      rescue
+        nil
+      end
+
+    when /^(#{__item_numstrval_optkeys(tagid(tagOrId)).join('|')})$/
+      num_or_str(tk_call_without_enc(*(__item_cget_cmd(tagid(tagOrId)) << "-#{option}")))
+
+    when /^(#{__item_boolval_optkeys(tagid(tagOrId)).join('|')})$/
+      begin
+        bool(tk_call_without_enc(*(__item_cget_cmd(tagid(tagOrId)) << "-#{option}")))
+      rescue
+        nil
+      end
+
+    when /^(#{__item_listval_optkeys(tagid(tagOrId)).join('|')})$/
+      simplelist(tk_call_without_enc(*(__item_cget_cmd(tagid(tagOrId)) << "-#{option}")))
+
+    when /^(#{__item_numlistval_optkeys(tagid(tagOrId)).join('|')})$/
+      conf = tk_call_without_enc(*(__item_cget_cmd(tagid(tagOrId)) << "-#{option}"))
+      if conf =~ /^[0-9]/
+        list(conf)
+      else
+        conf
+      end
+
+    when /^(#{__item_tkvariable_optkeys(tagid(tagOrId)).join('|')})$/
+      v = tk_call_without_enc(*(__item_cget_cmd(tagid(tagOrId)) << "-#{option}"))
+      (v.empty?)? nil: TkVarAccess.new(v)
+
+    when /^(#{__item_strval_optkeys(tagid(tagOrId)).join('|')})$/
+      _fromUTF8(tk_call_without_enc(*(__item_cget_cmd(tagid(tagOrId)) << "-#{option}")))
+
+    when /^(|latin|ascii|kanji)(#{__item_font_optkeys(tagid(tagOrId)).join('|')})$/
+      fontcode = $1
+      fontkey  = $2
+      fnt = tk_tcl2ruby(tk_call_without_enc(*(__item_cget_cmd(tagid(tagOrId)) << "-#{fontkey}")), true)
+      unless fnt.kind_of?(TkFont)
+        fnt = tagfontobj(tagid(tagOrId), fontkey)
+      end
+      if fontcode == 'kanji' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
+        # obsolete; just for compatibility
+        fnt.kanji_font
+      else
+        fnt
+      end
+    else
+      tk_tcl2ruby(tk_call_without_enc(*(__item_cget_cmd(tagid(tagOrId)) << "-#{option}")), true)
+    end
+  end
+  private :__itemcget_core
+
+  def itemcget(tagOrId, option)
+    unless TkItemConfigMethod.__IGNORE_UNKNOWN_CONFIGURE_OPTION__
+      __itemcget_core(tagOrId, option)
+    else
+      begin
+        __itemcget_core(tagOrId, option)
+      rescue => e
+        begin
+          if __current_itemconfiginfo(tagOrId).has_key?(option.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 itemcget_strict(tagOrId, option)
+    # never use TkItemConfigMethod.__IGNORE_UNKNOWN_CONFIGURE_OPTION__
+    __itemcget_core(tagOrId, option)
+  end
+
+  def __itemconfigure_core(tagOrId, slot, value=None)
+    if slot.kind_of? Hash
+      slot = _symbolkey2str(slot)
+
+      __item_optkey_aliases(tagid(tagOrId)).each{|alias_name, real_name|
+        alias_name = alias_name.to_s
+        if slot.has_key?(alias_name)
+          slot[real_name.to_s] = slot.delete(alias_name)
+        end
+      }
+
+      __item_methodcall_optkeys(tagid(tagOrId)).each{|key, method|
+        value = slot.delete(key.to_s)
+        self.__send__(method, tagOrId, value) if value
+      }
+
+      __item_ruby2val_optkeys(tagid(tagOrId)).each{|key, method|
+        key = key.to_s
+        slot[key] = method.call(tagOrId, slot[key]) if slot.has_key?(key)
+      }
+
+      __item_keyonly_optkeys(tagid(tagOrId)).each{|defkey, undefkey|
+        conf = slot.find{|kk, vv| kk == defkey.to_s}
+        if conf
+          k, v = conf
+          if v
+            slot[k] = None
+          else
+            slot[undefkey.to_s] = None if undefkey
+            slot.delete(k)
+          end
+        end
+      }
+
+      if (slot.find{|k, v| k =~ /^(|latin|ascii|kanji)(#{__item_font_optkeys(tagid(tagOrId)).join('|')})$/})
+        tagfont_configure(tagid(tagOrId), slot)
+      elsif slot.size > 0
+        tk_call(*(__item_config_cmd(tagid(tagOrId)).concat(hash_kv(slot))))
+      end
+
+    else
+      orig_slot = slot
+      slot = slot.to_s
+      if slot.length == 0
+        fail ArgumentError, "Invalid option `#{orig_slot.inspect}'"
+      end
+
+      alias_name, real_name = __item_optkey_aliases(tagid(tagOrId)).find{|k, v| k.to_s == slot}
+      if real_name
+        slot = real_name.to_s
+      end
+
+      if ( conf = __item_keyonly_optkeys(tagid(tagOrId)).find{|k, v| k.to_s == slot } )
+        defkey, undefkey = conf
+        if value
+          tk_call(*(__item_config_cmd(tagid(tagOrId)) << "-#{defkey}"))
+        elsif undefkey
+          tk_call(*(__item_config_cmd(tagid(tagOrId)) << "-#{undefkey}"))
+        end
+      elsif ( method = _symbolkey2str(__item_ruby2val_optkeys(tagid(tagOrId)))[slot] )
+        tk_call(*(__item_config_cmd(tagid(tagOrId)) << "-#{slot}" << method.call(tagOrId, value)))
+      elsif ( method = _symbolkey2str(__item_methodcall_optkeys(tagid(tagOrId)))[slot] )
+        self.__send__(method, tagOrId, value)
+      elsif (slot =~ /^(|latin|ascii|kanji)(#{__item_font_optkeys(tagid(tagOrId)).join('|')})$/)
+        if value == None
+          tagfontobj(tagid(tagOrId), $2)
+        else
+          tagfont_configure(tagid(tagOrId), {slot=>value})
+        end
+      else
+        tk_call(*(__item_config_cmd(tagid(tagOrId)) << "-#{slot}" << value))
+      end
+    end
+    self
+  end
+  private :__itemconfigure_core
+
+  def __check_available_itemconfigure_options(tagOrId, keys)
+    id = tagid(tagOrId)
+
+    availables = self.__current_itemconfiginfo(id).keys
+
+    # add non-standard keys
+    availables |= __font_optkeys.map{|k|
+      [k.to_s, "latin#{k}", "ascii#{k}", "kanji#{k}"]
+    }.flatten
+    availables |= __item_methodcall_optkeys(id).keys.map{|k| k.to_s}
+    availables |= __item_keyonly_optkeys(id).keys.map{|k| k.to_s}
+
+    keys = _symbolkey2str(keys)
+
+    keys.delete_if{|k, v| !(availables.include?(k))}
+  end
+
+  def itemconfigure(tagOrId, slot, value=None)
+    unless TkItemConfigMethod.__IGNORE_UNKNOWN_CONFIGURE_OPTION__
+      __itemconfigure_core(tagOrId, slot, value)
+    else
+      if slot.kind_of?(Hash)
+        begin
+          __itemconfigure_core(tagOrId, slot)
+        rescue
+          slot = __check_available_itemconfigure_options(tagOrId, slot)
+          __itemconfigure_core(tagOrId, slot) unless slot.empty?
+        end
+      else
+        begin
+          __itemconfigure_core(tagOrId, slot, value)
+        rescue => e
+          begin
+            if __current_itemconfiginfo(tagOrId).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
+    self
+  end
+
+  def __itemconfiginfo_core(tagOrId, slot = nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if (slot && slot.to_s =~ /^(|latin|ascii|kanji)(#{__item_font_optkeys(tagid(tagOrId)).join('|')})$/)
+        fontkey  = $2
+        # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{fontkey}"))))
+        conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{fontkey}")), false, true)
+        conf[__item_configinfo_struct(tagid(tagOrId))[:key]] =
+          conf[__item_configinfo_struct(tagid(tagOrId))[:key]][1..-1]
+        if ( ! __item_configinfo_struct(tagid(tagOrId))[:alias] \
+            || conf.size > __item_configinfo_struct(tagid(tagOrId))[:alias] + 1 )
+          fnt = conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]]
+          if TkFont.is_system_font?(fnt)
+            conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = TkNamedFont.new(fnt)
+          end
+          conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = tagfontobj(tagid(tagOrId), fontkey)
+        elsif ( __item_configinfo_struct(tagid(tagOrId))[:alias] \
+               && conf.size == __item_configinfo_struct(tagid(tagOrId))[:alias] + 1 \
+               && conf[__item_configinfo_struct(tagid(tagOrId))[:alias]][0] == ?- )
+          conf[__item_configinfo_struct(tagid(tagOrId))[:alias]] =
+            conf[__item_configinfo_struct(tagid(tagOrId))[:alias]][1..-1]
+        end
+        conf
+      else
+        if slot
+          slot = slot.to_s
+
+          alias_name, real_name = __item_optkey_aliases(tagid(tagOrId)).find{|k, v| k.to_s == slot}
+          if real_name
+            slot = real_name.to_s
+          end
+
+          case slot
+          when /^(#{__item_val2ruby_optkeys(tagid(tagOrId)).keys.join('|')})$/
+            method = _symbolkey2str(__item_val2ruby_optkeys(tagid(tagOrId)))[slot]
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+              optval = conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]]
+              begin
+                val = method.call(tagOrId, optval)
+              rescue => e
+                warn("Warning:: #{e.message} (when #{method}.call(#{tagOrId.inspect}, #{optval.inspect})") if $DEBUG
+                val = optval
+              end
+              conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = val
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+              optval = conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]]
+              begin
+                val = method.call(tagOrId, optval)
+              rescue => e
+                warn("Warning:: #{e.message} (when #{method}lcall(#{tagOrId.inspect}, #{optval.inspect})") if $DEBUG
+                val = optval
+              end
+              conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = val
+            end
+
+          when /^(#{__item_methodcall_optkeys(tagid(tagOrId)).keys.join('|')})$/
+            method = _symbolkey2str(__item_methodcall_optkeys(tagid(tagOrId)))[slot]
+            return [slot, '', '', '', self.__send__(method, tagOrId)]
+
+          when /^(#{__item_numval_optkeys(tagid(tagOrId)).join('|')})$/
+            # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+              begin
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                  number(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+              rescue
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = nil
+              end
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+              begin
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                  number(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+              rescue
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = nil
+              end
+            end
+
+          when /^(#{__item_numstrval_optkeys(tagid(tagOrId)).join('|')})$/
+            # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                num_or_str(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                num_or_str(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+            end
+
+          when /^(#{__item_boolval_optkeys(tagid(tagOrId)).join('|')})$/
+            # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+              begin
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                  bool(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+              rescue
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = nil
+              end
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+              begin
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                  bool(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+              rescue
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = nil
+              end
+            end
+
+          when /^(#{__item_listval_optkeys(tagid(tagOrId)).join('|')})$/
+            # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                simplelist(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                simplelist(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+            end
+
+          when /^(#{__item_numlistval_optkeys(tagid(tagOrId)).join('|')})$/
+            # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =~ /^[0-9]/ )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                list(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =~ /^[0-9]/ )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                list(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+            end
+
+          when /^(#{__item_strval_optkeys(tagid(tagOrId)).join('|')})$/
+            # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+          when /^(#{__item_tkvariable_optkeys(tagid(tagOrId)).join('|')})$/
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+              v = conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]]
+              if v.empty?
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = nil
+              else
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = TkVarAccess.new(v)
+              end
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+              v = conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]]
+              if v.empty?
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = nil
+              else
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = TkVarAccess.new(v)
+              end
+            end
+
+          else
+            # conf = tk_split_list(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_list(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), 0, false, true)
+          end
+          conf[__item_configinfo_struct(tagid(tagOrId))[:key]] =
+            conf[__item_configinfo_struct(tagid(tagOrId))[:key]][1..-1]
+
+          if ( __item_configinfo_struct(tagid(tagOrId))[:alias] \
+              && conf.size == __item_configinfo_struct(tagid(tagOrId))[:alias] + 1 \
+              && conf[__item_configinfo_struct(tagid(tagOrId))[:alias]][0] == ?- )
+            conf[__item_configinfo_struct(tagid(tagOrId))[:alias]] =
+              conf[__item_configinfo_struct(tagid(tagOrId))[:alias]][1..-1]
+          end
+
+          conf
+
+        else
+          # ret = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)))))).collect{|conflist|
+          #   conf = tk_split_simplelist(conflist)
+          ret = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)))), false, false).collect{|conflist|
+            conf = tk_split_simplelist(conflist, false, true)
+            conf[__item_configinfo_struct(tagid(tagOrId))[:key]] =
+              conf[__item_configinfo_struct(tagid(tagOrId))[:key]][1..-1]
+
+            optkey = conf[__item_configinfo_struct(tagid(tagOrId))[:key]]
+            case optkey
+            when /^(#{__item_val2ruby_optkeys(tagid(tagOrId)).keys.join('|')})$/
+              method = _symbolkey2str(__item_val2ruby_optkeys(tagid(tagOrId)))[optkey]
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                optval = conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]]
+                begin
+                  val = method(tagOrId, optval)
+                rescue => e
+                  warn("Warning:: #{e.message} (when #{method}.call(#{tagOrId.inspect}, #{optval.inspect})") if $DEBUG
+                  val = optval
+                end
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = val
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+                optval = conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]]
+                begin
+                  val = method.call(tagOrId, optval)
+                rescue => e
+                  warn("Warning:: #{e.message} (when #{method}.call(#{tagOrId.inspect}, #{optval.inspect})") if $DEBUG
+                  val = optval
+                end
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = val
+              end
+
+            when /^(#{__item_strval_optkeys(tagid(tagOrId)).join('|')})$/
+              # do nothing
+
+            when /^(#{__item_numval_optkeys(tagid(tagOrId)).join('|')})$/
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                begin
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                    number(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+                rescue
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = nil
+                end
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+                begin
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                    number(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+                rescue
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = nil
+                end
+              end
+
+            when /^(#{__item_numstrval_optkeys(tagid(tagOrId)).join('|')})$/
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                  num_or_str(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                  num_or_str(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+              end
+
+            when /^(#{__item_boolval_optkeys(tagid(tagOrId)).join('|')})$/
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                begin
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                    bool(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+                rescue
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = nil
+                end
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+                begin
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                    bool(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+                rescue
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = nil
+                end
+              end
+
+            when /^(#{__item_listval_optkeys(tagid(tagOrId)).join('|')})$/
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                  simplelist(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                  simplelist(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+              end
+
+            when /^(#{__item_numlistval_optkeys(tagid(tagOrId)).join('|')})$/
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =~ /^[0-9]/ )
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                  list(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =~ /^[0-9]/ )
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                  list(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+              end
+
+            when /^(#{__item_tkvariable_optkeys(tagid(tagOrId)).join('|')})$/
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                v = conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]]
+                if v.empty?
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = nil
+                else
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = TkVarAccess.new(v)
+                end
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+                v = conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]]
+                if v.empty?
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = nil
+                else
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = TkVarAccess.new(v)
+                end
+              end
+
+            else
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                if conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]].index('{')
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                    tk_split_list(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+                else
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                    tk_tcl2ruby(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+                end
+              end
+              if conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]]
+                if conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]].index('{')
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                    tk_split_list(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+                else
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                    tk_tcl2ruby(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+                end
+              end
+            end
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:alias] \
+                && conf.size == __item_configinfo_struct(tagid(tagOrId))[:alias] + 1 \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:alias]][0] == ?- )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:alias]] =
+                conf[__item_configinfo_struct(tagid(tagOrId))[:alias]][1..-1]
+            end
+
+            conf
+          }
+
+          __item_font_optkeys(tagid(tagOrId)).each{|optkey|
+            optkey = optkey.to_s
+            fontconf = ret.assoc(optkey)
+            if fontconf && fontconf.size > 2
+              ret.delete_if{|inf| inf[0] =~ /^(|latin|ascii|kanji)#{optkey}$/}
+              fnt = fontconf[__item_configinfo_struct(tagid(tagOrId))[:default_value]]
+              if TkFont.is_system_font?(fnt)
+                fontconf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = TkNamedFont.new(fnt)
+              end
+              fontconf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = tagfontobj(tagid(tagOrId), optkey)
+              ret.push(fontconf)
+            end
+          }
+
+          __item_methodcall_optkeys(tagid(tagOrId)).each{|optkey, method|
+            ret << [optkey.to_s, '', '', '', self.__send__(method, tagOrId)]
+          }
+
+          ret
+        end
+      end
+
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      if (slot && slot.to_s =~ /^(|latin|ascii|kanji)(#{__item_font_optkeys(tagid(tagOrId)).join('|')})$/)
+        fontkey  = $2
+        # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{fontkey}"))))
+        conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{fontkey}")), false, true)
+        conf[__item_configinfo_struct(tagid(tagOrId))[:key]] =
+          conf[__item_configinfo_struct(tagid(tagOrId))[:key]][1..-1]
+
+        if ( ! __item_configinfo_struct(tagid(tagOrId))[:alias] \
+            || conf.size > __item_configinfo_struct(tagid(tagOrId))[:alias] + 1 )
+          fnt = conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]]
+          if TkFont.is_system_font?(fnt)
+            conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = TkNamedFont.new(fnt)
+          end
+          conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = tagfontobj(tagid(tagOrId), fontkey)
+          { conf.shift => conf }
+        elsif ( __item_configinfo_struct(tagid(tagOrId))[:alias] \
+               && conf.size == __item_configinfo_struct(tagid(tagOrId))[:alias] + 1 )
+          if conf[__item_configinfo_struct(tagid(tagOrId))[:alias]][0] == ?-
+            conf[__item_configinfo_struct(tagid(tagOrId))[:alias]] =
+              conf[__item_configinfo_struct(tagid(tagOrId))[:alias]][1..-1]
+          end
+          { conf[0] => conf[1] }
+        else
+          { conf.shift => conf }
+        end
+      else
+        if slot
+          slot = slot.to_s
+
+          alias_name, real_name = __item_optkey_aliases(tagid(tagOrId)).find{|k, v| k.to_s == slot}
+          if real_name
+            slot = real_name.to_s
+          end
+
+          case slot
+          when /^(#{__item_val2ruby_optkeys(tagid(tagOrId)).keys.join('|')})$/
+            method = _symbolkey2str(__item_val2ruby_optkeys(tagid(tagOrId)))[slot]
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+              optval = conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]]
+              begin
+                val = method.call(tagOrId, optval)
+              rescue => e
+                warn("Warning:: #{e.message} (when #{method}.call(#{tagOrId.inspect}, #{optval.inspect})") if $DEBUG
+                val = optval
+              end
+              conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = val
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+              optval = conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]]
+              begin
+                val = method.call(tagOrId, optval)
+              rescue => e
+                warn("Warning:: #{e.message} (when #{method}.call(#{tagOrId.inspect}, #{optval.inspect})") if $DEBUG
+                val = optval
+              end
+              conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = val
+            end
+
+          when /^(#{__item_methodcall_optkeys(tagid(tagOrId)).keys.join('|')})$/
+            method = _symbolkey2str(__item_methodcall_optkeys(tagid(tagOrId)))[slot]
+            return {slot => ['', '', '', self.__send__(method, tagOrId)]}
+
+          when /^(#{__item_numval_optkeys(tagid(tagOrId)).join('|')})$/
+            # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+              begin
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                  number(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+              rescue
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = nil
+              end
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+              begin
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                  number(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+              rescue
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = nil
+              end
+            end
+
+          when /^(#{__item_numstrval_optkeys(tagid(tagOrId)).join('|')})$/
+            # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                num_or_stre(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                num_or_str(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+            end
+
+          when /^(#{__item_boolval_optkeys(tagid(tagOrId)).join('|')})$/
+            # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+              begin
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                  bool(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+              rescue
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = nil
+              end
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+              begin
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                  bool(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+              rescue
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = nil
+              end
+            end
+
+          when /^(#{__item_listval_optkeys(tagid(tagOrId)).join('|')})$/
+            # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                simplelist(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                simplelist(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+            end
+
+          when /^(#{__item_numlistval_optkeys(tagid(tagOrId)).join('|')})$/
+            # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =~ /^[0-9]/ )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                list(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =~ /^[0-9]/ )
+              conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                list(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+            end
+
+          when /^(#{__item_strval_optkeys(tagid(tagOrId)).join('|')})$/
+            # conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+          when /^(#{__item_tkvariable_optkeys(tagid(tagOrId)).join('|')})$/
+            conf = tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), false, true)
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+              v = conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]]
+              if v.empty?
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = nil
+              else
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = TkVarAccess.new(v)
+              end
+            end
+            if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+              v = conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]]
+              if v.empty?
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = nil
+              else
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = TkVarAccess.new(v)
+              end
+            end
+
+          else
+            # conf = tk_split_list(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}"))))
+            conf = tk_split_list(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)) << "-#{slot}")), 0, false, true)
+          end
+          conf[__item_configinfo_struct(tagid(tagOrId))[:key]] =
+            conf[__item_configinfo_struct(tagid(tagOrId))[:key]][1..-1]
+
+          if ( __item_configinfo_struct(tagid(tagOrId))[:alias] \
+              && conf.size == __item_configinfo_struct(tagid(tagOrId))[:alias] + 1 )
+            if conf[__item_configinfo_struct(tagid(tagOrId))[:alias]][0] == ?-
+              conf[__item_configinfo_struct(tagid(tagOrId))[:alias]] =
+                conf[__item_configinfo_struct(tagid(tagOrId))[:alias]][1..-1]
+            end
+            { conf[0] => conf[1] }
+          else
+            { conf.shift => conf }
+          end
+
+        else
+          ret = {}
+          # tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)))))).each{|conflist|
+          #   conf = tk_split_simplelist(conflist)
+          tk_split_simplelist(tk_call_without_enc(*(__item_confinfo_cmd(tagid(tagOrId)))), false, false).each{|conflist|
+            conf = tk_split_simplelist(conflist, false, true)
+            conf[__item_configinfo_struct(tagid(tagOrId))[:key]] =
+              conf[__item_configinfo_struct(tagid(tagOrId))[:key]][1..-1]
+
+            optkey = conf[__item_configinfo_struct(tagid(tagOrId))[:key]]
+            case optkey
+            when /^(#{__item_val2ruby_optkeys(tagid(tagOrId)).keys.join('|')})$/
+              method = _symbolkey2str(__item_val2ruby_optkeys(tagid(tagOrId)))[optkey]
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                optval = conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]]
+                begin
+                  val = method.call(tagOrId, optval)
+                rescue => e
+                  warn("Warning:: #{e.message} (when #{method}.call(#{tagOrId.inspect}, #{optval.inspect})") if $DEBUG
+                  val = optval
+                end
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = val
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+                optval = conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]]
+                begin
+                  val = method.call(tagOrId, optval)
+                rescue => e
+                  warn("Warning:: #{e.message} (when #{method}.call(#{tagOrId.inspect}, #{optval.inspect})") if $DEBUG
+                  val = optval
+                end
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = val
+              end
+
+            when /^(#{__item_strval_optkeys(tagid(tagOrId)).join('|')})$/
+              # do nothing
+
+            when /^(#{__item_numval_optkeys(tagid(tagOrId)).join('|')})$/
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                begin
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                    number(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+                rescue
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = nil
+                end
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+                begin
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                    number(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+                rescue
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = nil
+                end
+              end
+
+            when /^(#{__item_numstrval_optkeys(tagid(tagOrId)).join('|')})$/
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                  num_or_str(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                  num_or_str(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+              end
+
+            when /^(#{__item_boolval_optkeys(tagid(tagOrId)).join('|')})$/
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                begin
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                    bool(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+                rescue
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = nil
+                end
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+                begin
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                    bool(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+                rescue
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = nil
+                end
+              end
+
+            when /^(#{__item_listval_optkeys(tagid(tagOrId)).join('|')})$/
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                  simplelist(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                  simplelist(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+              end
+
+            when /^(#{__item_numlistval_optkeys(tagid(tagOrId)).join('|')})$/
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =~ /^[0-9]/ )
+                conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                  list(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =~ /^[0-9]/ )
+                conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                  list(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+              end
+
+            when /^(#{__item_tkvariable_optkeys(tagid(tagOrId)).join('|')})$/
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                v = conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]]
+                if v.empty?
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = nil
+                else
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = TkVarAccess.new(v)
+                end
+              end
+              if ( conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] )
+                v = conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]]
+                if v.empty?
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = nil
+                else
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = TkVarAccess.new(v)
+                end
+              end
+
+            else
+              if ( __item_configinfo_struct(tagid(tagOrId))[:default_value] \
+                  && conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] )
+                if conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]].index('{')
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                    tk_split_list(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+                else
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] =
+                    tk_tcl2ruby(conf[__item_configinfo_struct(tagid(tagOrId))[:default_value]])
+                end
+              end
+              if conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]]
+                if conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]].index('{')
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                    tk_split_list(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+                else
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] =
+                    tk_tcl2ruby(conf[__item_configinfo_struct(tagid(tagOrId))[:current_value]])
+                end
+              end
+            end
+
+            if ( __item_configinfo_struct(tagid(tagOrId))[:alias] \
+                && conf.size == __item_configinfo_struct(tagid(tagOrId))[:alias] + 1 )
+              if conf[__item_configinfo_struct(tagid(tagOrId))[:alias]][0] == ?-
+                conf[__item_configinfo_struct(tagid(tagOrId))[:alias]] =
+                  conf[__item_configinfo_struct(tagid(tagOrId))[:alias]][1..-1]
+              end
+              ret[conf[0]] = conf[1]
+            else
+              ret[conf.shift] = conf
+            end
+          }
+
+          __item_font_optkeys(tagid(tagOrId)).each{|optkey|
+            optkey = optkey.to_s
+            fontconf = ret[optkey]
+            if fontconf.kind_of?(Array)
+              ret.delete(optkey)
+              ret.delete('latin' << optkey)
+              ret.delete('ascii' << optkey)
+              ret.delete('kanji' << optkey)
+              fnt = fontconf[__item_configinfo_struct(tagid(tagOrId))[:default_value]]
+              if TkFont.is_system_font?(fnt)
+                fontconf[__item_configinfo_struct(tagid(tagOrId))[:default_value]] = TkNamedFont.new(fnt)
+              end
+              fontconf[__item_configinfo_struct(tagid(tagOrId))[:current_value]] = tagfontobj(tagid(tagOrId), optkey)
+              ret[optkey] = fontconf
+            end
+          }
+
+          __item_methodcall_optkeys(tagid(tagOrId)).each{|optkey, method|
+            ret[optkey.to_s] = ['', '', '', self.__send__(method, tagOrId)]
+          }
+
+          ret
+        end
+      end
+    end
+  end
+  private :__itemconfiginfo_core
+
+  def itemconfiginfo(tagOrId, slot = nil)
+    if slot && TkItemConfigMethod.__IGNORE_UNKNOWN_CONFIGURE_OPTION__
+      begin
+        __itemconfiginfo_core(tagOrId, slot)
+      rescue => e
+        begin
+          __itemconfiginfo_core(tagOrId)
+          # not tag error -> option is unknown
+          Array.new(__item_configinfo_struct.values.max).unshift(slot.to_s)
+        rescue
+          fail e  # tag error
+        end
+      end
+    else
+      __itemconfiginfo_core(tagOrId, slot)
+    end
+  end
+
+  def __current_itemconfiginfo(tagOrId, slot = nil)
+    if TkComm::GET_CONFIGINFO_AS_ARRAY
+      if slot
+        org_slot = slot
+        begin
+          conf = __itemconfiginfo_core(tagOrId, slot)
+          if ( ! __item_configinfo_struct(tagid(tagOrId))[:alias] \
+              || conf.size > __item_configinfo_struct(tagid(tagOrId))[:alias] + 1 )
+            return {conf[0] => conf[-1]}
+          end
+          slot = conf[__item_configinfo_struct(tagid(tagOrId))[:alias]]
+        end while(org_slot != slot)
+        fail RuntimeError,
+          "there is a configure alias loop about '#{org_slot}'"
+      else
+        ret = {}
+        __itemconfiginfo_core(tagOrId).each{|conf|
+          if ( ! __item_configinfo_struct(tagid(tagOrId))[:alias] \
+              || conf.size > __item_configinfo_struct(tagid(tagOrId))[:alias] + 1 )
+            ret[conf[0]] = conf[-1]
+          end
+        }
+
+        ret
+      end
+    else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
+      ret = {}
+      __itemconfiginfo_core(tagOrId, slot).each{|key, conf|
+        ret[key] = conf[-1] if conf.kind_of?(Array)
+      }
+      ret
+    end
+  end
+
+  def current_itemconfiginfo(tagOrId, slot = nil)
+    __current_itemconfiginfo(tagOrId, slot)
+  end
+end