tk 0.1.0

data/lib/tk/font.rb

@@ -0,0 +1,2352 @@
+# frozen_string_literal: false
+#
+#  tk/font.rb - the class to treat fonts on Ruby/Tk
+#
+#                               by  Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+require 'tk'
+
+class TkFont
+  include Tk
+  extend TkCore
+
+  TkCommandNames = ['font'.freeze].freeze
+
+  (Tk_FontID = ["@font".freeze, TkUtil.untrust("00000")]).instance_eval{
+    @mutex = Mutex.new
+    def mutex; @mutex; end
+    freeze
+  }
+
+  Tk_FontNameTBL = TkCore::INTERP.create_table
+  Tk_FontUseTBL  = TkCore::INTERP.create_table
+
+  TkCore::INTERP.init_ip_env{
+    Tk_FontNameTBL.mutex.synchronize{ Tk_FontNameTBL.clear }
+    Tk_FontUseTBL.mutex.synchronize{ Tk_FontUseTBL.clear }
+  }
+
+  # option_type : default => string
+  OptionType = Hash.new(?s)
+  OptionType['size'] = ?n
+  OptionType['pointadjust'] = ?n
+  OptionType['underline'] = ?b
+  OptionType['overstrike'] = ?b
+
+  # metric_type : default => num_or_str
+  MetricType = Hash.new(?n)
+  MetricType['fixed'] = ?b
+
+  # system font names
+  SYSTEM_FONT_NAMES = []
+  def SYSTEM_FONT_NAMES.add(font_names)
+    (@mutex ||= Mutex.new).synchronize{
+      self.replace(self | font_names.map{|name| name.to_s})
+    }
+  end
+  def SYSTEM_FONT_NAMES.include?(name)
+    (@mutex ||= Mutex.new).synchronize{
+      super(name.to_s)
+    }
+  end
+
+  # set default font
+  case Tk::TK_VERSION
+  when /^4\..*/
+    DEFAULT_LATIN_FONT_NAME = 'a14'.freeze
+    DEFAULT_KANJI_FONT_NAME = 'k14'.freeze
+
+  when /^8\.[0-4]/
+    if JAPANIZED_TK
+      begin
+        fontnames = tk_call('font', 'names')
+        case fontnames
+        when /defaultgui/
+          # Tcl/Tk-JP for Windows
+          ltn = 'defaultgui'
+          knj = 'defaultgui'
+        when /Mincho:Helvetica-Bold-12/
+          # Tcl/Tk-JP for UNIX/X
+          ltn, knj = tk_split_simplelist(tk_call('font', 'configure',
+                                                 'Mincho:Helvetica-Bold-12',
+                                                 '-compound'))
+        else
+          # unknown Tcl/Tk-JP
+          #platform = tk_call('set', 'tcl_platform(platform)')
+          platform = Tk::PLATFORM['platform']
+          case platform
+          when 'unix'
+            ltn = {'family'=>'Helvetica'.freeze,
+                   'size'=>-12, 'weight'=>'bold'.freeze}
+            #knj = 'k14'
+            #knj = '-misc-fixed-medium-r-normal--14-*-*-*-c-*-jisx0208.1983-0'
+            knj = '-*-fixed-bold-r-normal--12-*-*-*-c-*-jisx0208.1983-0'
+          when 'windows'
+            ltn = {'family'=>'MS Sans Serif'.freeze, 'size'=>8}
+            knj = 'mincho'
+          when 'macintosh'
+            ltn = 'system'
+            knj = 'mincho'
+          else # unknown
+            ltn = 'Helvetica'
+            knj = 'mincho'
+          end
+        end
+      rescue
+        ltn = 'Helvetica'
+        knj = 'mincho'
+      end
+
+    else # not JAPANIZED_TK
+      begin
+        #platform = tk_call('set', 'tcl_platform(platform)')
+        platform = Tk::PLATFORM['platform']
+        case platform
+        when 'unix'
+          ltn = {'family'=>'Helvetica'.freeze,
+                 'size'=>-12, 'weight'=>'bold'.freeze}
+        when 'windows'
+          ltn = {'family'=>'MS Sans Serif'.freeze, 'size'=>8}
+        when 'macintosh'
+          ltn = 'system'
+        else # unknown
+          ltn = 'Helvetica'
+        end
+      rescue
+        ltn = 'Helvetica'
+      end
+
+      knj = ltn.dup
+    end
+
+    DEFAULT_LATIN_FONT_NAME = ltn.freeze
+    DEFAULT_KANJI_FONT_NAME = knj.freeze
+
+  when /^8\.[5-9]/, /^9\..*/
+    if tk_call('font', 'names') =~ /\bTkDefaultFont\b/
+      DEFAULT_LATIN_FONT_NAME = 'TkDefaultFont'.freeze
+      DEFAULT_KANJI_FONT_NAME = 'TkDefaultFont'.freeze
+    else
+      DEFAULT_LATIN_FONT_NAME = 'Helvetica'.freeze
+      DEFAULT_KANJI_FONT_NAME = 'mincho'.freeze
+    end
+
+  else # unknown version
+    DEFAULT_LATIN_FONT_NAME = 'Helvetica'.freeze
+    DEFAULT_KANJI_FONT_NAME = 'mincho'.freeze
+
+  end
+
+  if $DEBUG
+    print "default latin font = "; p DEFAULT_LATIN_FONT_NAME
+    print "default kanji font = "; p DEFAULT_KANJI_FONT_NAME
+  end
+
+
+  ###################################
+  class DescendantFont
+    def initialize(compound, type)
+      unless compound.kind_of?(TkFont)
+        fail ArgumentError, "a TkFont object is expected for the 1st argument"
+      end
+
+      @compound = compound
+      case type
+      when 'kanji', 'latin', 'ascii'
+        @type = type
+      when :kanji, :latin, :ascii
+        @type = type.to_s
+      else
+        fail ArgumentError, "unknown type '#{type}'"
+      end
+    end
+
+    def dup
+      fail RuntimeError, "cannot duplicate a descendant font"
+    end
+    def clone
+      fail RuntimeError, "cannot clone a descendant font"
+    end
+
+    def to_eval
+      @compound.__send__(@type + '_font_id')
+    end
+    def font
+      @compound.__send__(@type + '_font_id')
+    end
+    alias font_id font
+    alias name font
+    alias to_s font
+
+    def [](slot)
+      @compound.__send__(@type + '_configinfo', slot)
+    end
+    def []=(slot, value)
+      @compound.__send__(@type + '_configure', slot, value)
+      value
+    end
+
+    def method_missing(id, *args)
+      @compound.__send__(@type + '_' + id.id2name, *args)
+    end
+  end
+
+
+  ###################################
+  # class methods
+  ###################################
+  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
+
+  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
+  def TkFont.actual_hash(fnt, option=nil)
+    Hash[TkFont.actual(fnt, option)]
+  end
+
+  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
+  def TkFont.actual_hash_displayof(fnt, option=nil)
+    Hash[TkFont.actual_displayof(fnt, option)]
+  end
+
+  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
+
+  def TkFont.configinfo(fnt, slot=nil)
+    if fnt.kind_of?(TkFont)
+      fnt.configinfo(fnt, slot)
+    else
+      configinfo_core(fnt, slot)
+    end
+  end
+
+  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
+
+  def TkFont.measure(fnt, text)
+    fnt = '{}' if fnt == ''
+    if fnt.kind_of?(TkFont)
+      fnt.measure(text)
+    else
+      measure_core(fnt, nil, text)
+    end
+  end
+
+  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
+
+  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
+  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
+
+  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
+  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
+
+  def TkFont.families(win=nil)
+    case (Tk::TK_VERSION)
+    when /^4\..*/
+      ['fixed']
+
+    when /^8\..*/
+      if win
+        tk_split_simplelist(tk_call('font', 'families', '-displayof', win))
+      else
+        tk_split_simplelist(tk_call('font', 'families'))
+      end
+    end
+  end
+
+  def TkFont.names
+    case (Tk::TK_VERSION)
+    when /^4\..*/
+      r = ['fixed']
+      r += ['a14', 'k14'] if JAPANIZED_TK
+      Tk_FontNameTBL.mutex.synchronize{
+        Tk_FontNameTBL.each_value{|obj| r.push(obj)}
+      }
+      #r | []
+      r.uniq
+
+    when /^8\..*/
+      tk_split_simplelist(tk_call('font', 'names'))
+
+    end
+  end
+
+  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
+
+  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
+
+  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 /^4\..*/
+      regexp = /^-(|kanji)#{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 << {}
+
+      ltn_key = "-#{key}"
+      knj_key = "-kanji#{key}"
+
+      ltn_info = conf_list.find{|conf| conf[0] == ltn_key}
+      ltn = ltn_info[-1]
+      ltn = nil if ltn == [] || ltn == ""
+
+      knj_info = conf_list.find{|conf| conf[0] == knj_key}
+      knj = knj_info[-1]
+      knj = nil if knj == [] || knj == ""
+
+      TkFont.new(ltn, knj).call_font_configure([path, key], *args)
+
+    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
+
+    when /^8\.[5-9]/, /^9\..*/
+      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
+
+  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
+
+  def TkFont.failsafe(font)
+    begin
+      if /^8\..*/ === Tk::TK_VERSION  && JAPANIZED_TK
+        tk_call('font', 'failsafe', font)
+      end
+    rescue
+    end
+  end
+
+  ###################################
+  # instance methods
+  ###################################
+  private
+  ###################################
+  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]
+
+    case (Tk::TK_VERSION)
+    when /^4\..*/
+      @latinfont = ""
+      @kanjifont = ""
+      if JAPANIZED_TK
+        @compoundfont = [[@latinfont], [@kanjifont]]
+        @fontslot = {'font'=>@latinfont, 'kanjifont'=>@kanjifont}
+      else
+        @compoundfont = @latinfont
+        @fontslot = {'font'=>@latinfont}
+      end
+    else
+      @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}
+    end
+
+    self
+  end
+
+  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
+        if Tk::TK_VERSION =~ /^4..*/
+          knj = DEFAULT_KANJI_FONT_NAME
+        else
+          knj = ltn
+        end
+      end
+    else
+      ltn = DEFAULT_LATIN_FONT_NAME
+      knj = DEFAULT_KANJI_FONT_NAME if JAPANIZED_TK && !knj
+    end
+
+    create_compoundfont(ltn, knj, keys)
+  end
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  ###################################
+  public
+  ###################################
+  def inspect
+    sprintf("#<%s:%0x:%s>", self.class.inspect, self.__id__, @compoundfont)
+  end
+
+  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
+
+  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
+
+  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
+
+  def id
+    @id
+  end
+
+  def to_eval
+    font
+  end
+
+  def font
+    @compoundfont
+  end
+  alias font_id font
+  alias name font
+  alias to_s font
+
+  def latin_font_id
+    @latinfont
+  end
+
+  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
+  alias latinfont latin_font
+
+  def kanji_font_id
+    @kanjifont
+  end
+
+  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
+  alias kanjifont kanji_font
+
+  def actual(option=nil)
+    actual_core(@compoundfont, nil, option)
+  end
+  def actual_hash(option=nil)
+    Hash[actual(option)]
+  end
+
+  def actual_displayof(win, option=nil)
+    win = '.' unless win
+    actual_core(@compoundfont, win, option)
+  end
+  def actual_hash_displayof(win, option=nil)
+    Hash[actual_displayof(win, option)]
+  end
+
+  def latin_actual(option=nil)
+    if @latinfont == nil
+      actual_core(@compoundfont, nil, option) # use @compoundfont
+    else
+      actual_core(@latinfont, nil, option)
+    end
+  end
+  def latin_actual_hash(option=nil)
+    Hash[latin_actual(option)]
+  end
+
+  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
+  def latin_actual_hash_displayof(win, option=nil)
+    Hash[latin_actual_displayof(win, option)]
+  end
+
+  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
+  def kanji_actual_hash(option=nil)
+    Hash[kanji_actual(option)]
+  end
+
+  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
+  def kanji_actual_hash_displayof(win, option=nil)
+    Hash[kanji_actual_displayof(win, option)]
+  end
+
+  def [](slot)
+    configinfo slot
+  end
+
+  def []=(slot, val)
+    configure slot, val
+    val
+  end
+
+  def configure(slot, value=None)
+    configure_core(@compoundfont, slot, value)
+    self
+  end
+
+  def configinfo(slot=nil)
+    configinfo_core(@compoundfont, slot)
+  end
+
+  def current_configinfo(slot=nil)
+    current_configinfo_core(@compoundfont, slot)
+  end
+
+  def delete
+    delete_core
+  end
+
+  def latin_configure(slot, value=None)
+    if JAPANIZED_TK
+      configure_core(@latinfont, slot, value)
+    else
+      configure(slot, value)
+    end
+    self
+  end
+
+  def latin_configinfo(slot=nil)
+    if JAPANIZED_TK
+      configinfo_core(@latinfont, slot)
+    else
+      configinfo(slot)
+    end
+  end
+  def latin_current_configinfo(slot=nil)
+    Hash[latin_configinfo(slot)]
+  end
+
+  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
+
+  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
+  def kanji_current_configinfo(slot=nil)
+    Hash[kanji_configinfo(slot)]
+  end
+
+  def replace(ltn, knj=None)
+    knj = ltn if knj == None
+    latin_replace(ltn)
+    kanji_replace(knj)
+    self
+  end
+
+  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
+
+  def kanji_replace(knj)
+    return self unless @kanjifont  # ignore
+    kanji_replace_core(knj)
+    reset_pointadjust
+    self
+  end
+
+  def measure(text)
+    measure_core(@compoundfont, nil, text)
+  end
+
+  def measure_displayof(win, text)
+    win = '.' unless win
+    measure_core(@compoundfont, win, text)
+  end
+
+  def metrics(option=nil)
+    metrics_core(@compoundfont, nil, option)
+  end
+  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
+
+  def metrics_displayof(win, option=nil)
+    win = '.' unless win
+    metrics_core(@compoundfont, win, option)
+  end
+  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
+
+  def latin_metrics(option=nil)
+    if @latinfont == nil
+      metrics_core(@compoundfont, nil, option) # use @compoundfont
+    else
+      metrics_core(@latinfont, nil, option)
+    end
+  end
+  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
+
+  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
+  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
+
+  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
+  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
+
+  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
+  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
+
+  def reset_pointadjust
+    begin
+      if /^8\..*/ === Tk::TK_VERSION  && JAPANIZED_TK
+        configure('pointadjust' => latin_actual.assoc('size')[1].to_f /
+                                      kanji_actual.assoc('size')[1].to_f )
+      end
+    rescue
+    end
+    self
+  end
+
+  ###################################
+  # private alias
+  ###################################
+  case (Tk::TK_VERSION)
+  when /^4\..*/
+    alias create_latinfont        create_latinfont_tk4x
+    alias create_kanjifont        create_kanjifont_tk4x
+    alias create_compoundfont     create_compoundfont_tk4x
+
+  when /^8\.[0-5]/
+    alias create_latinfont        create_latinfont_tk8x
+    alias create_kanjifont        create_kanjifont_tk8x
+    alias create_compoundfont     create_compoundfont_tk8x
+
+  else
+    alias create_latinfont        create_latinfont_tk8x
+    alias create_kanjifont        create_kanjifont_tk8x
+    alias create_compoundfont     create_compoundfont_tk8x
+
+  end
+
+  ###################################
+  # public alias
+  ###################################
+  alias ascii_font             latin_font
+  alias asciifont              latinfont
+  alias create_asciifont       create_latinfont
+  alias ascii_actual           latin_actual
+  alias ascii_actual_displayof latin_actual_displayof
+  alias ascii_configure        latin_configure
+  alias ascii_configinfo       latin_configinfo
+  alias ascii_replace          latin_replace
+  alias ascii_metrics          latin_metrics
+
+  ###################################
+=begin
+  def dup
+    TkFont.new(self)
+  end
+  def clone
+    TkFont.new(self)
+  end
+=end
+end
+
+module TkFont::CoreMethods
+  include Tk
+  extend TkCore
+
+  private
+
+  def actual_core_tk4x(font, win=nil, option=nil)
+    # dummy
+    if option == 'pointadjust' || option == :pointadjust
+        1.0
+    elsif option
+      case TkFont::OptionType[option.to_s]
+      when ?n
+        0
+      when ?b
+        false
+      else
+        ''
+      end
+    else
+      [['family',''], ['size',0], ['weight',''], ['slant',''],
+        ['underline',false], ['overstrike',false], ['charset',''],
+        ['pointadjust',0]]
+    end
+  end
+
+  def actual_core_tk8x(font, win=nil, option=nil)
+    font = '{}' if font == ''
+
+    if option == 'compound' || option == :compound
+      ""
+    elsif option
+      if win
+        val = tk_call('font', 'actual', font,
+                      "-displayof", win, "-#{option}")
+      else
+        val = tk_call('font', 'actual', font, "-#{option}")
+      end
+      case TkFont::OptionType[option.to_s]
+      when ?n
+        num_or_str(val)
+      when ?b
+        bool(val)
+      else
+        val
+      end
+    else
+      l = tk_split_simplelist(if win
+                                 tk_call('font', 'actual', font,
+                                                     "-displayof", win)
+                              else
+                                 tk_call('font', 'actual', font)
+                              end)
+      r = []
+      while key=l.shift
+        if key == '-compound'
+          l.shift
+        else
+          key = key[1..-1]
+          val = l.shift
+          case TkFont::OptionType[key]
+          when ?n
+            r.push [key, num_or_str(val)]
+          when ?b
+            r.push [key, bool(val)]
+          else
+            r.push [key, val]
+          end
+        end
+      end
+      r
+    end
+  end
+
+  def configure_core_tk4x(font, slot, value=None)
+    #""
+    self
+  end
+
+  def configinfo_core_tk4x(font, option=nil)
+    # dummy
+    if TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
+      if option == 'pointadjust' || option == :pointadjust
+        1.0
+      elsif option
+        case TkFont::OptionType[option.to_s]
+        when ?n
+          0
+        when ?b
+          false
+        else
+          ''
+        end
+      else
+        [['family',''], ['size',0], ['weight',''], ['slant',''],
+          ['underline',false], ['overstrike',false], ['charset',''],
+          ['pointadjust',1.0]]
+      end
+    else # ! TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
+      current_configinfo_core_tk4x(font, option)
+    end
+  end
+
+  def current_configinfo_core_tk4x(font, option=nil)
+    if option
+      case TkFont::OptionType[option.to_s]
+      when ?n
+        0
+      when ?b
+        false
+      else
+        ''
+      end
+    else
+      {'family'=>'', 'size'=>0, 'weight'=>'', 'slant'=>'',
+        'underline'=>false, 'overstrike'=>false,
+        'charset'=>false, 'pointadjust'=>1.0}
+    end
+  end
+
+  def configure_core_tk8x(font, slot, value=None)
+    if JAPANIZED_TK
+      begin
+        padjust = tk_call('font', 'configure', font, '-pointadjust')
+      rescue
+        padjust = nil
+      end
+    else
+      padjust = nil
+    end
+    if slot.kind_of? Hash
+      if JAPANIZED_TK && (slot.key?('family') || slot.key?(:family))
+        slot = _symbolkey2str(slot)
+        configure_core_tk8x(font, 'family', slot.delete('family'))
+      end
+
+      if ((slot.key?('size') || slot.key?(:size)) &&
+          padjust && !slot.key?('pointadjust') && !slot.key?(:pointadjust))
+        tk_call('font', 'configure', font,
+                '-pointadjust', padjust, *hash_kv(slot))
+      else
+        tk_call('font', 'configure', font, *hash_kv(slot))
+      end
+    elsif (slot == 'size' || slot == :size) && padjust != nil
+      tk_call('font', 'configure', font,
+              "-#{slot}", value, '-pointadjust', padjust)
+    elsif JAPANIZED_TK && (slot == 'family' || slot == :family)
+      # compound font?
+      begin
+        compound = tk_split_simplelist(tk_call('font', 'configure',
+                                               font, '-compound'))
+      rescue
+        tk_call('font', 'configure', font, '-family', value)
+        return self
+      end
+      if compound == []
+        tk_call('font', 'configure', font, '-family', value)
+        return self
+      end
+      ltn, knj = compound
+
+      lfnt = tk_call('font', 'create', '-copy', ltn)
+      begin
+        tk_call('font', 'configure', lfnt, '-family', value)
+        latin_replace_core_tk8x(lfnt)
+      rescue RuntimeError => e
+        fail e if $DEBUG
+      ensure
+        tk_call('font', 'delete', lfnt) if lfnt != ''
+      end
+
+      kfnt = tk_call('font', 'create', '-copy', knj)
+      begin
+        tk_call('font', 'configure', kfnt, '-family', value)
+        kanji_replace_core_tk8x(lfnt)
+      rescue RuntimeError => e
+        fail e if $DEBUG
+      ensure
+        tk_call('font', 'delete', kfnt) if kfnt != ''
+      end
+
+    else
+      tk_call('font', 'configure', font, "-#{slot}", value)
+    end
+    self
+  end
+
+  def configinfo_core_tk8x(font, option=nil)
+    if TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
+      if option == 'compound' || option == :compound
+        ""
+      elsif option
+        val = tk_call('font', 'configure', font, "-#{option}")
+        case TkFont::OptionType[option.to_s]
+        when ?n
+          num_or_str(val)
+        when ?b
+          bool(val)
+        else
+          val
+        end
+      else
+        l = tk_split_simplelist(tk_call('font', 'configure', font))
+        r = []
+        while key=l.shift
+          if key == '-compound'
+            l.shift
+          else
+            key = key[1..-1]
+            val = l.shift
+            case TkFont::OptionType[key]
+            when ?n
+              r.push [key, num_or_str(val)]
+            when ?b
+              r.push [key, bool(val)]
+            else
+              r.push [key, val]
+            end
+          end
+        end
+        r
+      end
+    else # ! TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
+      current_configinfo_core_tk8x(font, option)
+    end
+  end
+
+  def current_configinfo_core_tk8x(font, option=nil)
+    if option == 'compound'
+      ""
+    elsif option
+      val = tk_call('font', 'configure', font, "-#{option}")
+      case TkFont::OptionType[option.to_s]
+      when ?n
+        num_or_str(val)
+      when ?b
+        bool(val)
+      else
+        val
+      end
+    else
+      l = tk_split_simplelist(tk_call('font', 'configure', font))
+      h = {}
+      while key=l.shift
+        if key == '-compound'
+          l.shift
+        else
+          key = key[1..-1]
+          val = l.shift
+          case TkFont::OptionType[key]
+          when ?n
+            h[key] = num_or_str(val)
+          when ?b
+            h[key] = bool(val)
+          else
+            h[key] = val
+          end
+        end
+      end
+      h
+    end
+  end
+
+  def delete_core_tk4x
+    TkFont::Tk_FontNameTBL.mutex.synchronize{
+      TkFont::Tk_FontNameTBL.delete(@id)
+    }
+    TkFont::Tk_FontUseTBL.mutex.synchronize{
+      TkFont::Tk_FontUseTBL.delete_if{|key,value| value == self}
+    }
+  end
+
+  def delete_core_tk8x
+    begin
+      tk_call('font', 'delete', @latinfont) if @latinfont
+    rescue
+    end
+    begin
+      tk_call('font', 'delete', @kanjifont) if @kanjifont
+    rescue
+    end
+    begin
+      tk_call('font', 'delete', @compoundfont) if @compoundfont
+    rescue
+    end
+    TkFont::Tk_FontNameTBL.mutex.synchronize{
+      TkFont::Tk_FontNameTBL.delete(@id)
+    }
+    TkFont::Tk_FontUseTBL.mutex.synchronize{
+      TkFont::Tk_FontUseTBL.delete_if{|key,value| value == self}
+    }
+  end
+
+  def latin_replace_core_tk4x(ltn)
+    create_latinfont_tk4x(ltn)
+    @compoundfont[0] = [@latinfont] if JAPANIZED_TK
+    @fontslot['font'] = @latinfont
+    table = nil
+    TkFont::Tk_FontUseTBL.mutex.synchronize{
+      table = TkFont::Tk_FontUseTBL.clone
+    }
+    table.each{|w, fobj|
+      if self == fobj
+        begin
+          if w.include?(';')
+            win, tag, optkey = w.split(';')
+            optkey = 'font' if optkey == nil || optkey == ''
+            winobj = tk_tcl2ruby(win)
+#           winobj.tagfont_configure(tag, {'font'=>@latinfont})
+            #if winobj.kind_of? TkText
+            if winobj.kind_of?(TkText) || winobj.kind_of?(Tk::Text)
+              tk_call(win, 'tag', 'configure', tag, "-#{optkey}", @latinfont)
+            #elsif winobj.kind_of? TkCanvas
+            elsif winobj.kind_of?(TkCanvas) || winobj.kind_of?(Tk::Canvas)
+              tk_call(win, 'itemconfigure', tag, "-#{optkey}", @latinfont)
+            #elsif winobj.kind_of? TkMenu
+            elsif winobj.kind_of?(TkMenu) || winobj.kind_of?(Tk::Menu)
+              tk_call(win, 'entryconfigure', tag, "-#{optkey}", @latinfont)
+            else
+              raise RuntimeError, "unknown widget type"
+            end
+          else
+#           tk_tcl2ruby(w).font_configure('font'=>@latinfont)
+            tk_call(w, 'configure', '-font', @latinfont)
+          end
+        rescue
+          TkFont::Tk_FontUseTBL.mutex.synchronize{
+            TkFont::Tk_FontUseTBL.delete(w)
+          }
+        end
+      end
+    }
+    self
+  end
+
+  def kanji_replace_core_tk4x(knj)
+    return self unless JAPANIZED_TK
+
+    create_kanjifont_tk4x(knj)
+    @compoundfont[1] = [@kanjifont]
+    @fontslot['kanjifont'] = @kanjifont
+    table = nil
+    TkFont::Tk_FontUseTBL.mutex.synchronize{
+      table = TkFont::Tk_FontUseTBL.clone
+    }
+    table.dup.each{|w, fobj|
+      if self == fobj
+        begin
+          if w.include?(';')
+            win, tag, optkey = w.split(';')
+            optkey = 'kanjifont' unless optkey
+            winobj = tk_tcl2ruby(win)
+#           winobj.tagfont_configure(tag, {'kanjifont'=>@kanjifont})
+            #if winobj.kind_of? TkText
+            if winobj.kind_of?(TkText) || winobj.kind_of?(Tk::Text)
+              tk_call(win, 'tag', 'configure', tag, "-#{optkey}", @kanjifont)
+            #elsif winobj.kind_of? TkCanvas
+            elsif winobj.kind_of?(TkCanvas) || winobj.kind_of?(Tk::Canvas)
+              tk_call(win, 'itemconfigure', tag, "-#{optkey}", @kanjifont)
+            #elsif winobj.kind_of? TkMenu
+            elsif winobj.kind_of?(TkMenu) || winobj.kind_of?(Tk::Menu)
+              tk_call(win, 'entryconfigure', tag, "-#{optkey}", @latinfont)
+            else
+              raise RuntimeError, "unknown widget type"
+            end
+          else
+#           tk_tcl2ruby(w).font_configure('kanjifont'=>@kanjifont)
+            tk_call(w, 'configure', '-kanjifont', @kanjifont)
+          end
+        rescue
+          Tk_FontUseTBL.mutex.synchronize{
+            TkFont::Tk_FontUseTBL.delete(w)
+          }
+        end
+      end
+    }
+    self
+  end
+
+  def latin_replace_core_tk8x(ltn)
+    ltn = '{}' if ltn == ''
+
+    if JAPANIZED_TK
+      begin
+        tk_call('font', 'delete', '@font_tmp')
+      rescue
+      end
+      begin
+        fnt_bup = tk_call('font', 'create', '@font_tmp', '-copy', @latinfont)
+      rescue
+        #fnt_bup = ''
+        fnt_bup = TkFont::DEFAULT_LATIN_FONT_NAME
+      end
+    end
+
+    begin
+      tk_call('font', 'delete', @latinfont)
+    rescue
+    end
+    create_latinfont(ltn)
+
+    if JAPANIZED_TK
+      keys = self.configinfo
+      tk_call('font', 'delete', @compoundfont)
+      begin
+        tk_call('font', 'create', @compoundfont,
+                '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
+=begin
+        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
+=end
+      rescue RuntimeError => e
+        tk_call('font', 'delete', @latinfont)
+        if fnt_bup && fnt_bup != ''
+          tk_call('font', 'create', @latinfont, '-copy', fnt_bup)
+          tk_call('font', 'create', @compoundfont,
+                  '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
+          tk_call('font', 'delete', fnt_bup)
+        else
+          fail e
+        end
+      end
+
+    else
+      latinkeys = {}
+      begin
+        actual_core(@latinfont).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
+
+  def kanji_replace_core_tk8x(knj)
+    knj = '{}' if knj == ''
+
+    if JAPANIZED_TK
+      begin
+        tk_call('font', 'delete', '@font_tmp')
+      rescue
+      end
+      begin
+        fnt_bup = tk_call('font', 'create', '@font_tmp', '-copy', @kanjifont)
+      rescue
+        #fnt_bup = ''
+        fnt_bup = TkFont::DEFAULT_KANJI_FONT_NAME
+      end
+    end
+
+    begin
+      tk_call('font', 'delete', @kanjifont)
+    rescue
+    end
+    create_kanjifont(knj)
+
+    if JAPANIZED_TK
+      keys = self.configinfo
+      tk_call('font', 'delete', @compoundfont)
+      begin
+        tk_call('font', 'create', @compoundfont,
+                '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
+      rescue RuntimeError => e
+        tk_call('font', 'delete', @kanjifont)
+        if fnt_bup && fnt_bup != ''
+          tk_call('font', 'create', @kanjifont, '-copy', fnt_bup)
+          tk_call('font', 'create', @compoundfont,
+                  '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
+          tk_call('font', 'delete', fnt_bup)
+        else
+          fail e
+        end
+      end
+    end
+    self
+  end
+
+  def measure_core_tk4x(font, win, text)
+    0
+  end
+
+  def measure_core_tk8x(font, win, text)
+    font = '{}' if font == ''
+
+    if win
+      number(tk_call('font', 'measure', font,
+                     '-displayof', win, text))
+    else
+      number(tk_call('font', 'measure', font, text))
+    end
+  end
+
+  def metrics_core_tk4x(font, win, option=nil)
+    # dummy
+    if option
+      ""
+    else
+      [['ascent',[]], ['descent',[]], ['linespace',[]], ['fixed',[]]]
+    end
+  end
+
+  def metrics_core_tk8x(font, win, option=nil)
+    font = '{}' if font == ''
+
+    if option
+      if win
+        number(tk_call('font', 'metrics', font,
+                       "-displayof", win, "-#{option}"))
+      else
+        number(tk_call('font', 'metrics', font, "-#{option}"))
+      end
+    else
+      l = tk_split_list(if win
+                          tk_call('font','metrics',font,"-displayof",win)
+                        else
+                          tk_call('font','metrics',font)
+                        end)
+      r = []
+      while key=l.shift
+        r.push [key[1..-1], l.shift.to_i]
+=begin
+        if key == '-fixed'  # boolean value
+          r.push [key[1..-1], bool(l.shift)]
+        else
+          r.push [key[1..-1], l.shift.to_i]
+        end
+=end
+      end
+      r
+    end
+  end
+
+  ###################################
+  # private alias
+  ###################################
+  case (Tk::TK_VERSION)
+  when /^4\..*/
+    alias actual_core             actual_core_tk4x
+    alias configure_core          configure_core_tk4x
+    alias configinfo_core         configinfo_core_tk4x
+    alias current_configinfo_core current_configinfo_core_tk4x
+    alias delete_core             delete_core_tk4x
+    alias latin_replace_core      latin_replace_core_tk4x
+    alias kanji_replace_core      kanji_replace_core_tk4x
+    alias measure_core            measure_core_tk4x
+    alias metrics_core            metrics_core_tk4x
+
+  when /^8\.[0-9]/
+    alias actual_core             actual_core_tk8x
+    alias configure_core          configure_core_tk8x
+    alias configinfo_core         configinfo_core_tk8x
+    alias current_configinfo_core current_configinfo_core_tk8x
+    alias delete_core             delete_core_tk8x
+    alias latin_replace_core      latin_replace_core_tk8x
+    alias kanji_replace_core      kanji_replace_core_tk8x
+    alias measure_core            measure_core_tk8x
+    alias metrics_core            metrics_core_tk8x
+
+  else
+    alias actual_core             actual_core_tk8x
+    alias configure_core          configure_core_tk8x
+    alias configinfo_core         configinfo_core_tk8x
+    alias current_configinfo_core current_configinfo_core_tk8x
+    alias delete_core             delete_core_tk8x
+    alias latin_replace_core      latin_replace_core_tk8x
+    alias kanji_replace_core      kanji_replace_core_tk8x
+    alias measure_core            measure_core_tk8x
+    alias metrics_core            metrics_core_tk8x
+
+  end
+end
+
+class TkFont
+  include TkFont::CoreMethods
+  extend  TkFont::CoreMethods
+end
+
+class TkNamedFont < TkFont
+  # for built-in named fonts
+  def TkNamedFont.find(name)
+    name = name.to_s
+    unless (obj = Tk_FontNameTBL[name])
+      obj = self.new(name) if TkFont.is_system_font?(name)
+    end
+    obj
+  end
+
+  def TkNamedFont.new(name, keys=nil)
+    name = name.to_s
+    obj = nil
+    Tk_FontNameTBL.mutex.synchronize{
+      unless (obj = Tk_FontNameTBL[name])
+        (obj = self.allocate).instance_eval{
+          @id = @compoundfont = name.to_s
+          @latinfont = nil
+          @kanjifont = nil
+          @descendant = [self, self] # [latin, kanji] : dummy
+          Tk_FontNameTBL[@id] = self
+        }
+      end
+    }
+    obj.instance_eval{ initialize(name, keys) }
+    obj
+  end
+
+  ###########################
+  private
+  ###########################
+  def initialize(name, keys=nil)
+    @id = @compoundfont = name.to_s
+
+    # if not exist named font, create it.
+    begin
+      if keys
+        tk_call('font', 'configure', @compoundfont, keys)
+      else
+        tk_call('font', 'configure', @compoundfont)
+      end
+    rescue
+      # the named font doesn't exist -> create
+      if keys
+        tk_call('font', 'create', @compoundfont, keys)
+      else
+        tk_call('font', 'create', @compoundfont)
+      end
+    end
+  end
+
+  def create_latinfont(fnt)
+    # ignore
+  end
+  def create_kanjifont(fnt)
+    # ignore
+  end
+  def create_compoundfont(ltn, knj, keys)
+    # ignore
+  end
+
+  ###########################
+  public
+  ###########################
+  def latin_font_id
+    @compoundfont
+  end
+  def kanji_font_id
+    @compoundfont
+  end
+end
+
+#######################################
+# define system font names
+#######################################
+if Tk::TCL_MAJOR_VERSION > 8 ||
+    (Tk::TCL_MAJOR_VERSION == 8 && Tk::TCL_MINOR_VERSION >= 5)
+  # add standard fonts of Tcl/Tk 8.5+
+  TkFont::SYSTEM_FONT_NAMES.add [
+    'TkDefaultFont', 'TkTextFont', 'TkFixedFont', 'TkMenuFont',
+    'TkHeadingFont', 'TkCaptionFont', 'TkSmallCaptionFont',
+    'TkIconFont', 'TkTooltipFont'
+  ]
+end
+
+# platform-specific fonts
+#  -- windows
+TkFont::SYSTEM_FONT_NAMES.add [
+  'ansifixed', 'ansi', 'device', 'oemfixed', 'systemfixed', 'system'
+]
+
+#  --  macintosh, macosx
+TkFont::SYSTEM_FONT_NAMES.add ['system', 'application']
+
+if Tk::TCL_MAJOR_VERSION > 8 ||
+    (Tk::TCL_MAJOR_VERSION == 8 && Tk::TCL_MINOR_VERSION >= 5)
+  TkFont::SYSTEM_FONT_NAMES.add ['menu']
+end
+
+#  --  macosx (Aqua theme)
+if Tk::TCL_MAJOR_VERSION > 8 ||
+    (Tk::TCL_MAJOR_VERSION == 8 && Tk::TCL_MINOR_VERSION >= 5)
+  TkFont::SYSTEM_FONT_NAMES.add [
+    'systemSystemFont', 'systemEmphasizedSystemFont',
+    'systemSmallSystemFont', 'systemSmallEmphasizedSystemFont',
+    'systemApplicationFont', 'systemLabelFont', 'systemViewsFont',
+    'systemMenuTitleFont', 'systemMenuItemFont', 'systemMenuItemMarkFont',
+    'systemMenuItemCmdKeyFont', 'systemWindowTitleFont',
+    'systemPushButtonFont', 'systemUtilityWindowTitleFont',
+    'systemAlertHeaderFont', 'systemToolbarFont', 'systemMiniSystemFont',
+    'systemDetailSystemFont', 'systemDetailEmphasizedSystemFont'
+  ]
+end
+
+#######################################
+# autoload
+#######################################
+class TkFont
+  autoload :Chooser, 'tk/fontchooser'
+end