class TkFont

# File lib/tk/font.rb, line 197
def TkFont.actual(fnt, option=nil)
  fnt = '{}' if fnt == ''
  if fnt.kind_of?(TkFont)
   fnt.actual(option)
  else
    actual_core(fnt, nil, option)
  end
end

# File lib/tk/font.rb, line 209
def TkFont.actual_displayof(fnt, win, option=nil)
  fnt = '{}' if fnt == ''
  if fnt.kind_of?(TkFont)
   fnt.actual_displayof(win, option)
  else
    win = '.' unless win
    actual_core(fnt, win, option)
  end
end

# File lib/tk/font.rb, line 205
def TkFont.actual_hash(fnt, option=nil)
  Hash[TkFont.actual(fnt, option)]
end

# File lib/tk/font.rb, line 218
def TkFont.actual_hash_displayof(fnt, option=nil)
  Hash[TkFont.actual_displayof(fnt, option)]
end

# File lib/tk/font.rb, line 231
def TkFont.configinfo(fnt, slot=nil)
  if fnt.kind_of?(TkFont)
    fnt.configinfo(fnt, slot)
  else
    configinfo_core(fnt, slot)
  end
end

# File lib/tk/font.rb, line 222
def TkFont.configure(fnt, slot, value=None)
  if fnt.kind_of?(TkFont)
    fnt.configure(fnt, slot, value)
  else
    configure_core(fnt, slot, value)
  end
  fnt
end

# File lib/tk/font.rb, line 351
def TkFont.create_copy(font)
  fail 'source-font must be a TkFont object' unless font.kind_of? TkFont
  if TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
    keys = {}
    font.configinfo.each{|key,value| keys[key] = value }
    TkFont.new(font.latin_font_id, font.kanji_font_id, keys)
  else # ! TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
    TkFont.new(font.latin_font_id, font.kanji_font_id, font.configinfo)
  end
end

# File lib/tk/font.rb, line 239
def TkFont.current_configinfo(fnt, slot=nil)
  if fnt.kind_of?(TkFont)
    fnt.current_configinfo(fnt, slot)
  else
    current_configinfo_core(fnt, slot)
  end
end

# File lib/tk/font.rb, line 474
def TkFont.failsafe(font)
  begin
    if JAPANIZED_TK
      tk_call('font', 'failsafe', font)
    end
  rescue
  end
end

# File lib/tk/font.rb, line 339
def TkFont.families(win=nil)
  if win
    tk_split_simplelist(tk_call('font', 'families', '-displayof', win))
  else
    tk_split_simplelist(tk_call('font', 'families'))
  end
end

# File lib/tk/font.rb, line 362
def TkFont.get_obj(name)
  name = name.to_s
  if name =~ /^(@font[0-9]+)(|c|l|k)$/
    Tk_FontNameTBL.mutex.synchronize{
      Tk_FontNameTBL[$1]
    }
  else
    Tk_FontNameTBL.mutex.synchronize{
      Tk_FontNameTBL[name]
    }
  end
end

# File lib/tk/font.rb, line 375
def TkFont.init_widget_font(pathname, *args)
  win, tag, key = pathname.split(';')
  key = 'font' if key == nil || key == ''
  path = [win, tag, key].join(';')

  case (Tk::TK_VERSION)
  when /^8\.[0-4]/
    regexp = /^-#{key} /

    conf_list = tk_split_simplelist(tk_call(*args)).
      find_all{|prop| prop =~ regexp}.
      collect{|prop| tk_split_simplelist(prop)}

    if conf_list.size == 0
      raise RuntimeError, "the widget may not support 'font' option"
    end

    args << {}

    optkey = "-#{key}"

    info = conf_list.find{|conf| conf[0] == optkey}
    fnt = info[-1]
    fnt = nil if fnt == [] || fnt == ""

    unless fnt
      # create dummy
      # TkFont.new(nil, nil).call_font_configure([path, key], *args)
      dummy_fnt = TkFont.allocate
      dummy_fnt.instance_eval{ init_dummy_fontobj() }
      dummy_fnt
    else
      begin
        compound = tk_split_simplelist(
            Hash[*tk_split_simplelist(tk_call('font', 'configure',
                                              fnt))].collect{|k,v|
              [k[1..-1], v]
            }.assoc('compound')[1])
      rescue
        compound = []
      end
      if compound == []
        if TkFont.is_system_font?(fnt)
          TkNamedFont.new(fnt).call_font_configure([path, key], *args)
        else
          TkFont.new(fnt).call_font_configure([path, key], *args)
        end
      else
        TkFont.new(compound[0],
                   compound[1]).call_font_configure([path, key], *args)
      end
    end

  else
    regexp = /^-#{key} /

    conf_list = tk_split_simplelist(tk_call(*args)).
      find_all{|prop| prop =~ regexp}.
      collect{|prop| tk_split_simplelist(prop)}

    if conf_list.size == 0
      raise RuntimeError, "the widget may not support 'font' option"
    end

    args << {}

    optkey = "-#{key}"

    info = conf_list.find{|conf| conf[0] == optkey}
    fnt = info[-1]
    fnt = nil if fnt == [] || fnt == ""

    unless fnt
      # create dummy
      # TkFont.new(nil, nil).call_font_configure([path, key], *args)
      dummy_fnt = TkFont.allocate
      dummy_fnt.instance_eval{ init_dummy_fontobj() }
      dummy_fnt
    else
      if TkFont.is_system_font?(fnt)
        TkNamedFont.new(fnt).call_font_configure([path, key], *args)
      else
        TkFont.new(fnt).call_font_configure([path, key], *args)
      end
    end
  end
end

# File lib/tk/font.rb, line 189
def TkFont.is_system_font?(fnt)
  # true  --> system font which is available on the current system
  # false --> not system font (or unknown system font)
  # nil   --> system font name, but not available on the current system
  fnt = fnt.to_s
  SYSTEM_FONT_NAMES.include?(fnt) && self.names.index(fnt) && true
end

# File lib/tk/font.rb, line 247
def TkFont.measure(fnt, text)
  fnt = '{}' if fnt == ''
  if fnt.kind_of?(TkFont)
    fnt.measure(text)
  else
    measure_core(fnt, nil, text)
  end
end

# File lib/tk/font.rb, line 256
def TkFont.measure_displayof(fnt, win, text)
  fnt = '{}' if fnt == ''
  if fnt.kind_of?(TkFont)
    fnt.measure_displayof(win, text)
  else
    win = '.' unless win
    measure_core(fnt, win, text)
  end
end

# File lib/tk/font.rb, line 266
def TkFont.metrics(fnt, option=nil)
  fnt = '{}' if fnt == ''
  if fnt.kind_of?(TkFont)
    fnt.metrics(option)
  else
    metrics_core(fnt, nil, option)
  end
end

# File lib/tk/font.rb, line 302
def TkFont.metrics_displayof(fnt, win, option=nil)
  fnt = '{}' if fnt == ''
  if fnt.kind_of?(TkFont)
    font.metrics_displayof(win, option=nil)
  else
    win = '.' unless win
    metrics_core(fnt, win, option)
  end
end

# File lib/tk/font.rb, line 274
def TkFont.metrics_hash(fnt, option=nil)
  if option
    val = TkFont.metrics(fnt, option)
    case TkFont::MetricsType[option.to_s]
    when ?n
      val = TkComm::num_or_str(val)
    when ?b
      val = TkComm::bool(val)
    else
      # do nothing
    end
    return val
  end

  h = Hash[TkFont.metrics(fnt)]
  h.keys.each{|k|
    case TkFont::MetricsType[k.to_s]
    when ?n
      h[k] = TkComm::num_or_str(h[k])
    when ?b
      h[k] = TkComm::bool(h[k])
    else
      # do nothing
    end
  }
  h
end

# File lib/tk/font.rb, line 311
def TkFont.metrics_hash_displayof(fnt, win, option=nil)
  if option
    val = TkFont.metrics_displayof(fnt, win, option)
    case TkFont::MetricsType[option.to_s]
    when ?n
      val = TkComm::num_or_str(val)
    when ?b
      val = TkComm::bool(val)
    else
      # do nothing
    end
    return val
  end

  h = Hash[TkFont.metrics_displayof(fnt, win, option)]
  h.keys.each{|k|
    case TkFont::MetricsType[k.to_s]
    when ?n
      h[k] = TkComm::num_or_str(h[k])
    when ?b
      h[k] = TkComm::bool(h[k])
    else
      # do nothing
    end
  }
  h
end

# File lib/tk/font.rb, line 347
def TkFont.names
  tk_split_simplelist(tk_call('font', 'names'))
end

# File lib/tk/font.rb, line 521
def initialize(ltn=nil, knj=nil, keys=nil)
  ltn = '{}' if ltn == ''
  knj = '{}' if knj == ''

  Tk_FontID.mutex.synchronize{
    # @id = Tk_FontID.join('')
    @id = Tk_FontID.join(TkCore::INTERP._ip_id_)
    Tk_FontID[1].succ!
  }
  Tk_FontNameTBL.mutex.synchronize{
    Tk_FontNameTBL[@id] = self
  }

  # @latin_desscendant = nil
  # @kanji_desscendant = nil
  @descendant = [nil, nil] # [latin, kanji]

  # @latinfont = @id + 'l'
  # @kanjifont = @id + 'k'
  # @compoundfont = @id + 'c'
  # @fontslot = {}

  if knj.kind_of?(Hash) && !keys
    keys = knj
    knj = nil
  end

  # compound font check
  if Tk::TK_VERSION == '8.0' && JAPANIZED_TK
    begin
      compound = tk_split_simplelist(tk_call('font', 'configure',
                                             ltn, '-compound'))
      if knj == nil
        if compound != []
          ltn, knj = compound
        end
      else
        if compound != []
          ltn = compound[0]
        end
        compound = tk_split_simplelist(tk_call('font', 'configure',
                                               knj, '-compound'))
        if compound != []
          knj = compound[1]
        end
      end
    rescue
    end
  end

  if ltn
    if JAPANIZED_TK && !knj
      knj = ltn
    end
  else
    ltn = DEFAULT_LATIN_FONT_NAME
    knj = DEFAULT_KANJI_FONT_NAME if JAPANIZED_TK && !knj
  end

  create_compoundfont(ltn, knj, keys)
end

# File lib/tk/font.rb, line 463
def TkFont.used_on(path=nil)
  Tk_FontUseTBL.mutex.synchronize{
    if path
      Tk_FontUseTBL[path]
    else
      # Tk_FontUseTBL.values | []
      Tk_FontUseTBL.values.uniq
    end
  }
end

# File lib/tk/font.rb, line 1186
def [](slot)
  configinfo slot
end

# File lib/tk/font.rb, line 1190
def []=(slot, val)
  configure slot, val
  val
end

# File lib/tk/font.rb, line 1119
def actual(option=nil)
  actual_core(@compoundfont, nil, option)
end

# File lib/tk/font.rb, line 1126
def actual_displayof(win, option=nil)
  win = '.' unless win
  actual_core(@compoundfont, win, option)
end

# File lib/tk/font.rb, line 1122
def actual_hash(option=nil)
  Hash[actual(option)]
end

# File lib/tk/font.rb, line 1130
def actual_hash_displayof(win, option=nil)
  Hash[actual_displayof(win, option)]
end

# File lib/tk/font.rb, line 970
def call_font_configure(path, *args)
  if path.kind_of?(Array)
    # [path, optkey]
    win, tag = path[0].split(';')
    optkey = path[1].to_s
  else
    win, tag, optkey = path.split(';')
  end

  fontslot = _symbolkey2str(@fontslot)
  if optkey && optkey != ""
    ltn = fontslot.delete('font')
    knj = fontslot.delete('kanjifont')
    fontslot[optkey] = ltn if ltn
    fontslot["kanji#{optkey}"] = knj if knj
  end

  keys = _symbolkey2str(args.pop).update(fontslot)
  args.concat(hash_kv(keys))
  begin
    tk_call(*args)
  rescue => e
    unless TkConfigMethod.__IGNORE_UNKNOWN_CONFIGURE_OPTION__
      fail e
    end
  end
  Tk_FontUseTBL.mutex.synchronize{
    Tk_FontUseTBL[[win, tag, optkey].join(';')] = self
  }
  self
end

# File lib/tk/font.rb, line 1200
def configinfo(slot=nil)
  configinfo_core(@compoundfont, slot)
end

# File lib/tk/font.rb, line 1195
def configure(slot, value=None)
  configure_core(@compoundfont, slot, value)
  self
end

# File lib/tk/font.rb, line 1204
def current_configinfo(slot=nil)
  current_configinfo_core(@compoundfont, slot)
end

# File lib/tk/font.rb, line 1208
def delete
  delete_core
end

# File lib/tk/font.rb, line 1070
def font
  @compoundfont
end

# File lib/tk/font.rb, line 1062
def id
  @id
end

# File lib/tk/font.rb, line 942
def inspect
  sprintf("#<%s:%0x:%s>", self.class.inspect, self.__id__, @compoundfont)
end

# File lib/tk/font.rb, line 1157
def kanji_actual(option=nil)
  #if JAPANIZED_TK
  if @kanjifont == nil
    actual_core(@compoundfont, nil, option) # use @compoundfont
  elsif @kanjifont != ""
    actual_core(@kanjifont, nil, option)
  else
    actual_core_tk4x(nil, nil, option)
  end
end

# File lib/tk/font.rb, line 1171
def kanji_actual_displayof(win, option=nil)
  #if JAPANIZED_TK
  if @kanjifont == nil
    actual_core(@compoundfont, nil, option) # use @compoundfont
  elsif @kanjifont != ""
    win = '.' unless win
    actual_core(@kanjifont, win, option)
  else
    actual_core_tk4x(nil, win, option)
  end
end

# File lib/tk/font.rb, line 1167
def kanji_actual_hash(option=nil)
  Hash[kanji_actual(option)]
end

# File lib/tk/font.rb, line 1182
def kanji_actual_hash_displayof(win, option=nil)
  Hash[kanji_actual_displayof(win, option)]
end

# File lib/tk/font.rb, line 1246
def kanji_configinfo(slot=nil)
  #if JAPANIZED_TK
  if @kanjifont == nil
    configure_core(@compoundfont, slot) # use @compoundfont
  elsif @kanjifont != ""
    configinfo_core(@kanjifont, slot)
  else
    #[]
    configinfo(slot)
  end
end

# File lib/tk/font.rb, line 1232
def kanji_configure(slot, value=None)
  #if JAPANIZED_TK
  if @kanjifont == nil
    configure_core(@compoundfont, slot, value) # use @compoundfont
  elsif @kanjifont != ""
    configure_core(@kanjifont, slot, value)
    configure('size'=>configinfo('size')) # to reflect new configuration
  else
    #""
    configure(slot, value)
  end
  self
end

# File lib/tk/font.rb, line 1257
def kanji_current_configinfo(slot=nil)
  Hash[kanji_configinfo(slot)]
end

# File lib/tk/font.rb, line 1102
  def kanji_font
    # @kanjifont
    if @descendant[1] # [1] -> kanji
      @descendant[1]
    else
      @descendant[1] = DescendantFont.new(self, 'kanji')
    end
=begin
    if @kanji_descendant
      @kanji_descendant
    else
      @kanji_descendant = DescendantFont.new(self, 'kanji')
    end
=end
  end

# File lib/tk/font.rb, line 1098
def kanji_font_id
  @kanjifont
end

# File lib/tk/font.rb, line 1441
def kanji_metrics(option=nil)
  if @latinfont == nil
    metrics_core(@compoundfont, nil, option) # use @compoundfont
  elsif JAPANIZED_TK
    metrics_core(@kanjifont, nil, option)
  else
    metrics_core_tk4x(nil, nil, option)
  end
end

# File lib/tk/font.rb, line 1478
def kanji_metrics_displayof(win, option=nil)
  win = '.' unless win
  if @latinfont == nil
    metrics_core(@compoundfont, win, option) # use @compoundfont
  elsif JAPANIZED_TK
    metrics_core(@kanjifont, win, option)
  else
    metrics_core_tk4x(nil, win, option)
  end
end

# File lib/tk/font.rb, line 1450
def kanji_metrics_hash(option=nil)
  if option
    val = kanji_metrics(option)
    case TkFont::MetricsType[option.to_s]
    when ?n
      val = TkComm::num_or_str(val)
    when ?b
      val = TkComm::bool(val)
    else
      # do nothing
    end
    return val
  end

  h = Hash[kanji_metrics(option)]
  h.keys.each{|k|
    case TkFont::MetricsType[k.to_s]
    when ?n
      h[k] = TkComm::num_or_str(h[k])
    when ?b
      h[k] = TkComm::bool(h[k])
    else
      # do nothing
    end
  }
  h
end

# File lib/tk/font.rb, line 1488
def kanji_metrics_hash_displayof(win, option=nil)
  if option
    val = kanji_metrics_displayof(win, option)
    case TkFont::MetricsType[option.to_s]
    when ?n
      val = TkComm::num_or_str(val)
    when ?b
      val = TkComm::bool(val)
    else
      # do nothing
    end
    return val
  end

  h = Hash[kanji_metrics_displayof(win, option)]
  h.keys.each{|k|
    case TkFont::MetricsType[k.to_s]
    when ?n
      h[k] = TkComm::num_or_str(h[k])
    when ?b
      h[k] = TkComm::bool(h[k])
    else
      # do nothing
    end
  }
  h
end

# File lib/tk/font.rb, line 1291
def kanji_replace(knj)
  return self unless @kanjifont  # ignore
  kanji_replace_core(knj)
  reset_pointadjust
  self
end

# File lib/tk/font.rb, line 1134
def latin_actual(option=nil)
  if @latinfont == nil
    actual_core(@compoundfont, nil, option) # use @compoundfont
  else
    actual_core(@latinfont, nil, option)
  end
end

# File lib/tk/font.rb, line 1145
def latin_actual_displayof(win, option=nil)
  win = '.' unless win
  if @latinfont == nil
    actual_core(@compoundfont, win, option) # use @compoundfont
  else
    actual_core(@latinfont, win, option)
  end
end

# File lib/tk/font.rb, line 1141
def latin_actual_hash(option=nil)
  Hash[latin_actual(option)]
end

# File lib/tk/font.rb, line 1153
def latin_actual_hash_displayof(win, option=nil)
  Hash[latin_actual_displayof(win, option)]
end

# File lib/tk/font.rb, line 1221
def latin_configinfo(slot=nil)
  if JAPANIZED_TK
    configinfo_core(@latinfont, slot)
  else
    configinfo(slot)
  end
end

# File lib/tk/font.rb, line 1212
def latin_configure(slot, value=None)
  if JAPANIZED_TK
    configure_core(@latinfont, slot, value)
  else
    configure(slot, value)
  end
  self
end

# File lib/tk/font.rb, line 1228
def latin_current_configinfo(slot=nil)
  Hash[latin_configinfo(slot)]
end

# File lib/tk/font.rb, line 1081
  def latin_font
    # @latinfont
    if @descendant[0] # [0] -> latin
      @descendant[0]
    else
      @descendant[0] = DescendantFont.new(self, 'latin')
    end
=begin
    if @latin_descendant
      @latin_descendant
    else
      @latin_descendant = DescendantFont.new(self, 'latin')
    end
=end
  end

# File lib/tk/font.rb, line 1077
def latin_font_id
  @latinfont
end

# File lib/tk/font.rb, line 1370
def latin_metrics(option=nil)
  if @latinfont == nil
    metrics_core(@compoundfont, nil, option) # use @compoundfont
  else
    metrics_core(@latinfont, nil, option)
  end
end

# File lib/tk/font.rb, line 1405
def latin_metrics_displayof(win, option=nil)
  win = '.' unless win
  if @latinfont == nil
    metrics_core(@compoundfont, win, option) # use @compoundfont
  else
    metrics_core(@latinfont, win, option)
  end
end

# File lib/tk/font.rb, line 1377
def latin_metrics_hash(option=nil)
  if option
    val = latin_metrics(option)
    case TkFont::MetricsType[option.to_s]
    when ?n
      val = TkComm::num_or_str(val)
    when ?b
      val = TkComm::bool(val)
    else
      # do nothing
    end
    return val
  end

  h = Hash[latin_metrics(option)]
  h.keys.each{|k|
    case TkFont::MetricsType[k.to_s]
    when ?n
      h[k] = TkComm::num_or_str(h[k])
    when ?b
      h[k] = TkComm::bool(h[k])
    else
      # do nothing
    end
  }
  h
end

# File lib/tk/font.rb, line 1413
def latin_metrics_hash_displayof(win, option=nil)
  if option
    val = latin_metrics_displayof(win, option)
    case TkFont::MetricsType[option.to_s]
    when ?n
      val = TkComm::num_or_str(val)
    when ?b
      val = TkComm::bool(val)
    else
      # do nothing
    end
    return val
  end

  h = Hash[latin_metrics_displayof(win, option)]
  h.keys.each{|k|
    case TkFont::MetricsType[k.to_s]
    when ?n
      h[k] = TkComm::num_or_str(h[k])
    when ?b
      h[k] = TkComm::bool(h[k])
    else
      # do nothing
    end
  }
  h
end

# File lib/tk/font.rb, line 1268
def latin_replace(ltn)
  if @latinfont
    latin_replace_core(ltn)
    reset_pointadjust
  else
    # not compound font -> copy properties of ltn
    latinkeys = {}
    begin
      actual_core(ltn).each{|key,val| latinkeys[key] = val}
    rescue
      latinkeys = {}
    end
    begin
      tk_call('font', 'configure', @compoundfont, *hash_kv(latinkeys))
    rescue
      # not exist? (deleted?) -> create font
      tk_call('font', 'create', @compoundfont, *hash_kv(latinkeys))
    end
  end

  self
end

# File lib/tk/font.rb, line 1298
def measure(text)
  measure_core(@compoundfont, nil, text)
end

# File lib/tk/font.rb, line 1302
def measure_displayof(win, text)
  win = '.' unless win
  measure_core(@compoundfont, win, text)
end

# File lib/tk/font.rb, line 946
  def method_missing(id, *args)
    name = id.id2name
    case args.length
    when 1
      if name[-1] == ?=
        configure name[0..-2], args[0]
        args[0]
      else
        configure name, args[0]
        self
      end
    when 0
      begin
        configinfo name
      rescue
        super(id, *args)
#        fail NameError, "undefined local variable or method `#{name}' for #{self.to_s}", error_at
      end
    else
      super(id, *args)
#      fail NameError, "undefined method `#{name}' for #{self.to_s}", error_at
    end
  end

# File lib/tk/font.rb, line 1307
def metrics(option=nil)
  metrics_core(@compoundfont, nil, option)
end

# File lib/tk/font.rb, line 1338
def metrics_displayof(win, option=nil)
  win = '.' unless win
  metrics_core(@compoundfont, win, option)
end

# File lib/tk/font.rb, line 1310
def metrics_hash(option=nil)
  if option
    val = metrics(option)
    case TkFont::MetricsType[option.to_s]
    when ?n
      val = TkComm::num_or_str(val)
    when ?b
      val = TkComm::bool(val)
    else
      # do nothing
    end
    return val
  end

  h = Hash[metrics(option)]
  h.keys.each{|k|
    case TkFont::MetricsType[k.to_s]
    when ?n
      h[k] = TkComm::num_or_str(h[k])
    when ?b
      h[k] = TkComm::bool(h[k])
    else
      # do nothing
    end
  }
  h
end

# File lib/tk/font.rb, line 1342
def metrics_hash_displayof(win, option=nil)
  if option
    val = metrics_displayof(win, option)
    case TkFont::MetricsType[option.to_s]
    when ?n
      val = TkComm::num_or_str(val)
    when ?b
      val = TkComm::bool(val)
    else
      # do nothing
    end
    return val
  end

  h = Hash[metrics_displayof(win, option)]
  h.keys.each{|k|
    case TkFont::MetricsType[k.to_s]
    when ?n
      h[k] = TkComm::num_or_str(h[k])
    when ?b
      h[k] = TkComm::bool(h[k])
    else
      # do nothing
    end
  }
  h
end

# File lib/tk/font.rb, line 17
def mutex; @mutex; end

# File lib/tk/font.rb, line 1261
def replace(ltn, knj=None)
  knj = ltn if knj == None
  latin_replace(ltn)
  kanji_replace(knj)
  self
end

# File lib/tk/font.rb, line 1516
def reset_pointadjust
  begin
    if JAPANIZED_TK
      configure('pointadjust' => latin_actual.assoc('size')[1].to_f /
                                    kanji_actual.assoc('size')[1].to_f )
    end
  rescue
  end
  self
end

# File lib/tk/font.rb, line 1066
def to_eval
  font
end

# File lib/tk/font.rb, line 1002
def used
  ret = []
  table = nil
  Tk_FontUseTBL.mutex.synchronize{
    table = Tk_FontUseTBL.clone # to avoid deadlock
  }
  table.each{|key,value|
    next unless self == value
    if key.include?(';')
      win, tag, optkey = key.split(';')
      winobj = tk_tcl2ruby(win)
      #if winobj.kind_of? TkText
      if winobj.kind_of?(TkText) || winobj.kind_of?(Tk::Text)
        if optkey
          ret.push([winobj, winobj.tagid2obj(tag), optkey])
        else
          ret.push([winobj, winobj.tagid2obj(tag)])
        end
      #elsif winobj.kind_of? TkCanvas
      elsif winobj.kind_of?(TkCanvas) || winobj.kind_of?(Tk::Canvas)
        if (tagobj = TkcTag.id2obj(winobj, tag)).kind_of? TkcTag
          if optkey
            ret.push([winobj, tagobj, optkey])
          else
            ret.push([winobj, tagobj])
          end
        elsif (tagobj = TkcItem.id2obj(winobj, tag)).kind_of? TkcItem
          if optkey
            ret.push([winobj, tagobj, optkey])
          else
            ret.push([winobj, tagobj])
          end
        else
          if optkey
            ret.push([winobj, tag, optkey])
          else
            ret.push([winobj, tag])
          end
        end
      #elsif winobj.kind_of? TkMenu
      elsif winobj.kind_of?(TkMenu) || winobj.kind_of?(Tk::Menu)
        if optkey
          ret.push([winobj, tag, optkey])
        else
          ret.push([winobj, tag])
        end
      else
        if optkey
          ret.push([win, tag, optkey])
        else
          ret.push([win, tag])
        end
      end
    else
      ret.push(tk_tcl2ruby(key))
    end
  }
  ret
end

# File lib/tk/font.rb, line 596
def _get_font_info_from_hash(font)
  font = _symbolkey2str(font)
  foundry  = (info = font['foundry'] .to_s)?  info: '*'
  family   = (info = font['family']  .to_s)?  info: '*'
  weight   = (info = font['weight']  .to_s)?  info: '*'
  slant    = (info = font['slant']   .to_s)?  info: '*'
  swidth   = (info = font['swidth']  .to_s)?  info: '*'
  adstyle  = (info = font['adstyle'] .to_s)?  info: '*'
  pixels   = (info = font['pixels']  .to_s)?  info: '*'
  points   = (info = font['points']  .to_s)?  info: '*'
  resx     = (info = font['resx']    .to_s)?  info: '*'
  resy     = (info = font['resy']    .to_s)?  info: '*'
  space    = (info = font['space']   .to_s)?  info: '*'
  avgWidth = (info = font['avgWidth'].to_s)?  info: '*'
  charset  = (info = font['charset'] .to_s)?  info: '*'
  encoding = (info = font['encoding'].to_s)?  info: '*'

  [foundry, family, weight, slant, swidth, adstyle,
    pixels, points, resx, resy, space, avgWidth, charset, encoding]
end

# File lib/tk/font.rb, line 713
def create_compoundfont_tk4x(ltn, knj, keys)
  create_latinfont(ltn)
  create_kanjifont(knj)

  if JAPANIZED_TK
    @compoundfont = [[@latinfont], [@kanjifont]]
    @fontslot = {'font'=>@latinfont, 'kanjifont'=>@kanjifont}
    # @fontslot.clear
    # @fontslot['font'] = @latinfont
    # @fontslot['kanjifont'] = @kanjifont
  else
    @compoundfont = @latinfont
    @fontslot = {'font'=>@latinfont}
    # @fontslot.clear
    # @fontslot['font'] = @latinfont
  end
end

# File lib/tk/font.rb, line 823
def create_compoundfont_tk8x(ltn, knj, keys)
  if knj
    create_latinfont(ltn)
    create_kanjifont(knj)
  else
    cfnt = ltn
    create_kanjifont(cfnt)
    create_latinfont(cfnt)
  end

  @compoundfont = @id + 'c'

  if JAPANIZED_TK
    unless keys
      keys = {}
    else
      keys = keys.dup
    end
    if (tk_call('font', 'configure', @latinfont, '-underline') == '1' &&
        tk_call('font', 'configure', @kanjifont, '-underline') == '1' &&
        !keys.key?('underline'))
      keys['underline'] = true
    end
    if (tk_call('font', 'configure', @latinfont, '-overstrike') == '1' &&
        tk_call('font', 'configure', @kanjifont, '-overstrike') == '1' &&
        !keys.key?('overstrike'))
      keys['overstrike'] = true
    end

    @fontslot = {'font'=>@compoundfont}
    # @fontslot['font'] = @compoundfont
    begin
      tk_call('font', 'create', @compoundfont,
              '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
    rescue RuntimeError => e
      if ltn == knj
        if e.message =~ /kanji font .* specified/
          tk_call('font', 'delete', @latinfont)
          create_latinfont(DEFAULT_LATIN_FONT_NAME)
          opts = []
          Hash[*(tk_split_simplelist(tk_call('font', 'configure',
                                             @kanjifont)))].each{|k,v|
            case k
            when '-size', '-weight', '-slant', '-underline', '-overstrike'
              opts << k << v
            end
          }
          tk_call('font', 'configure', @latinfont, *opts)
          tk_call('font', 'create', @compoundfont,
                  '-compound', [@latinfont, @kanjifont], *hash_kv(keys))

        elsif e.message =~ /ascii font .* specified/
          tk_call('font', 'delete', @kanjifont)
          create_kanjifont(DEFAULT_KANJI_FONT_NAME)
          opts = []
          Hash[*(tk_split_simplelist(tk_call('font', 'configure',
                                             @latinfont)))].each{|k,v|
            case k
            when '-size', '-weight', '-slant', '-underline', '-overstrike'
              opts << k << v
            end
          }
          tk_call('font', 'configure', @kanjifont, *opts)
          tk_call('font', 'create', @compoundfont,
                  '-compound', [@latinfont, @kanjifont], *hash_kv(keys))

        else
          raise e
        end
      else
        raise e
      end
    end
  else
    tk_call('font', 'create', @compoundfont)

    latinkeys = {}
    begin
      actual_core(@latinfont).each{|key,val| latinkeys[key] = val}
    rescue
      latinkeys = {}
    end
    if latinkeys != {}
      tk_call('font', 'configure', @compoundfont, *hash_kv(latinkeys))
    end

    if knj
      compoundkeys = nil
      kanjikeys = {}
      begin
        actual_core(@kanjifont).each{|key,val| kanjikeys[key] = val}
      rescue
        kanjikeys = {}
      end
      if kanjikeys != {}
        tk_call('font', 'configure', @compoundfont, *hash_kv(kanjikeys))
      end
    end

    if cfnt
      if cfnt.kind_of?(Hash)
        compoundkeys = cfnt.dup
      else
        compoundkeys = {}
        actual_core(cfnt).each{|key,val| compoundkeys[key] = val}
      end
      compoundkeys.update(_symbolkey2str(keys))
      keys = compoundkeys
    end

    @fontslot = {'font'=>@compoundfont}
    # @fontslot['font'] = @compoundfont
    tk_call('font', 'configure', @compoundfont, *hash_kv(keys))
  end
end

# File lib/tk/font.rb, line 664
def create_kanjifont_tk4x(font)
  unless JAPANIZED_TK
    @kanjifont = ""
    return
  end

  if font.kind_of? Hash
    @kanjifont = '-' + _get_font_info_from_hash(font).join('-') + '-'

  elsif font.kind_of? Array
    finfo = {}
    finfo['family'] = font[0].to_s
    if font[1]
      fsize = font[1].to_s
      if fsize != '0' && fsize =~ /^(|\+|-)([0-9]+)$/
        if $1 == '-'
          finfo['pixels'] = $2
        else
          finfo['points'] = $2
        end
      else
        finfo['points'] = '13'
      end
    end
    font[2..-1].each{|style|
      case (style)
      when 'normal'
        finfo['weight'] = style
      when 'bold'
        finfo['weight'] = style
      when 'roman'
        finfo['slant'] = 'r'
      when 'italic'
        finfo['slant'] = 'i'
      end
    }

    @kanjifont = '-' + _get_font_info_from_hash(finfo).join('-') + '-'
  elsif font.kind_of? TkFont
    @kanjifont = font.kanji_font_id
  else
    if font
      @kanjifont = font
    else
      @kanjifont = DEFAULT_KANJI_FONT_NAME
    end
  end
end

# File lib/tk/font.rb, line 776
def create_kanjifont_tk8x(font)
  @kanjifont = @id + 'k'

  if JAPANIZED_TK
    if font.kind_of? Hash
      if font[:charset] || font['charset']
        tk_call('font', 'create', @kanjifont, *hash_kv(font))
      else
        tk_call('font', 'create', @kanjifont,
                '-charset', 'jisx0208.1983', *hash_kv(font))
      end
    elsif font.kind_of? Array
      tk_call('font', 'create', @kanjifont, '-copy', array2tk_list(font))
      tk_call('font', 'configure', @kanjifont, '-charset', 'jisx0208.1983')
    elsif font.kind_of? TkFont
      tk_call('font', 'create', @kanjifont, '-copy', font.kanji_font_id)
    elsif font
      tk_call('font', 'create', @kanjifont, '-copy', font,
              '-charset', 'jisx0208.1983')
    else
      tk_call('font', 'create', @kanjifont, '-charset', 'jisx0208.1983')
    end
    # end of JAPANIZED_TK

  else
    if font.kind_of? Hash
      tk_call('font', 'create', @kanjifont, *hash_kv(font))
    else
      keys = {}
      if font.kind_of? Array
        actual_core(array2tk_list(font)).each{|key,val| keys[key] = val}
      elsif font.kind_of? TkFont
        actual_core(font.kanji_font_id).each{|key,val| keys[key] = val}
      elsif font
        actual_core(font).each{|key,val| keys[key] = val}
      end
      tk_call('font', 'create', @kanjifont, *hash_kv(keys))
    end

    if font && @compoundfont
      keys = {}
      actual_core(@kanjifont).each{|key,val| keys[key] = val}
      tk_call('font', 'configure', @compoundfont, *hash_kv(keys))
    end
  end
end

# File lib/tk/font.rb, line 617
def create_latinfont_tk4x(font)
  if font.kind_of? Hash
    @latinfont = '-' + _get_font_info_from_hash(font).join('-') + '-'

  elsif font.kind_of? Array
    finfo = {}
    finfo['family'] = font[0].to_s
    if font[1]
      fsize = font[1].to_s
      if fsize != '0' && fsize =~ /^(|\+|-)([0-9]+)$/
        if $1 == '-'
          finfo['pixels'] = $2
        else
          finfo['points'] = $2
        end
      else
        finfo['points'] = '13'
      end
    end
    font[2..-1].each{|style|
      case (style)
      when 'normal'
        finfo['weight'] = style
      when 'bold'
        finfo['weight'] = style
      when 'roman'
        finfo['slant'] = 'r'
      when 'italic'
        finfo['slant'] = 'i'
      end
    }

    @latinfont = '-' + _get_font_info_from_hash(finfo).join('-') + '-'

  elsif font.kind_of? TkFont
    @latinfont = font.latin_font

  else
    if font
      @latinfont = font
    else
      @latinfont = DEFAULT_LATIN_FONT_NAME
    end

  end
end

# File lib/tk/font.rb, line 731
def create_latinfont_tk8x(font)
  @latinfont = @id + 'l'

  if JAPANIZED_TK
    if font.kind_of? Hash
      if font[:charset] || font['charset']
        tk_call('font', 'create', @latinfont, *hash_kv(font))
      else
        tk_call('font', 'create', @latinfont,
                '-charset', 'iso8859', *hash_kv(font))
      end
    elsif font.kind_of? Array
      tk_call('font', 'create', @latinfont, '-copy', array2tk_list(font))
      tk_call('font', 'configure', @latinfont, '-charset', 'iso8859')
    elsif font.kind_of? TkFont
      tk_call('font', 'create', @latinfont, '-copy', font.latin_font)
    elsif font
      tk_call('font', 'create', @latinfont, '-copy', font,
              '-charset', 'iso8859')
    else
      tk_call('font', 'create', @latinfont, '-charset', 'iso8859')
    end
  else
    if font.kind_of? Hash
      tk_call('font', 'create', @latinfont, *hash_kv(font))
    else
      keys = {}
      if font.kind_of? Array
        actual_core(array2tk_list(font)).each{|key,val| keys[key] = val}
      elsif font.kind_of? TkFont
        actual_core(font.latin_font).each{|key,val| keys[key] = val}
      elsif font
        actual_core(font).each{|key,val| keys[key] = val}
      end
      tk_call('font', 'create', @latinfont, *hash_kv(keys))
    end

    if font && @compoundfont
      keys = {}
      actual_core(@latinfont).each{|key,val| keys[key] = val}
      tk_call('font', 'configure', @compoundfont, *hash_kv(keys))
    end
  end
end

# File lib/tk/font.rb, line 488
def init_dummy_fontobj
  Tk_FontID.mutex.synchronize{
    @id = Tk_FontID.join(TkCore::INTERP._ip_id_)
    Tk_FontID[1].succ!
  }
  Tk_FontNameTBL.mutex.synchronize{
    Tk_FontNameTBL[@id] = self
  }

  # @latin_desscendant = nil
  # @kanji_desscendant = nil
  @descendant = [nil, nil] # [latin, kanji]

  @latinfont = @id + 'l'
  @kanjifont = @id + 'k'
  @compoundfont = @id + 'c'

  if JAPANIZED_TK
    tk_call('font', 'create', @latinfont, '-charset', 'iso8859')
    tk_call('font', 'create', @kanjifont, '-charset', 'jisx0208.1983')
    tk_call('font', 'create', @compoundfont,
            '-compound', [@latinfont, @kanjifont])
  else
    tk_call('font', 'create', @latinfont)
    tk_call('font', 'create', @kanjifont)
    tk_call('font', 'create', @compoundfont)
  end

  @fontslot = {'font'=>@compoundfont}

  self
end

# File lib/tk/font.rb, line 583
def initialize_copy(font)
  unless font.kind_of?(TkFont)
    fail TypeError, '"initialize_copy should take same class object'
  end
  if TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
    keys = {}
    font.configinfo.each{|key,value| keys[key] = value }
    initialize(font.latin_font_id, font.kanji_font_id, keys)
  else # ! TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
    initialize(font.latin_font_id, font.kanji_font_id, font.configinfo)
  end
end