Class: TkFont (Ruby 2.3.4)

In Files

  • tk/lib/tk/font.rb
  • tk/lib/tk/fontchooser.rb
  • tk/lib/tkextlib/tile.rb

Parent

Object

Included Modules

Class/Module Index [+]

Quicksearch

TkFont

autoload

Constants

DEFAULT_KANJI_FONT_NAME
DEFAULT_LATIN_FONT_NAME
MetricType

metric_type : default => num_or_str

OptionType

option_type : default => string

SYSTEM_FONT_NAMES

system font names

TkCommandNames
Tk_FontID
Tk_FontNameTBL
Tk_FontUseTBL

Public Class Methods

actual(fnt, option=nil) 
 
               # File tk/lib/tk/font.rb, line 206
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
actual_displayof(fnt, win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 218
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
actual_hash(fnt, option=nil) 
 
               # File tk/lib/tk/font.rb, line 214
def TkFont.actual_hash(fnt, option=nil)
  Hash[TkFont.actual(fnt, option)]
end
actual_hash_displayof(fnt, option=nil) 
 
               # File tk/lib/tk/font.rb, line 227
def TkFont.actual_hash_displayof(fnt, option=nil)
  Hash[TkFont.actual_displayof(fnt, option)]
end
configinfo(fnt, slot=nil) 
 
               # File tk/lib/tk/font.rb, line 240
def TkFont.configinfo(fnt, slot=nil)
  if fnt.kind_of?(TkFont)
    fnt.configinfo(fnt, slot)
  else
    configinfo_core(fnt, slot)
  end
end
configure(fnt, slot, value=None) 
 
               # File tk/lib/tk/font.rb, line 231
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
create_copy(font) 
 
               # File tk/lib/tk/font.rb, line 379
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
current_configinfo(fnt, slot=nil) 
 
               # File tk/lib/tk/font.rb, line 248
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
failsafe(font) 
 
               # File tk/lib/tk/font.rb, line 528
def TkFont.failsafe(font)
  begin
    if /^8\..*/ === Tk::TK_VERSION  && JAPANIZED_TK
      tk_call('font', 'failsafe', font)
    end
  rescue
  end
end
families(win=nil) 
 
               # File tk/lib/tk/font.rb, line 348
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
get_obj(name) 
 
               # File tk/lib/tk/font.rb, line 390
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
init_widget_font(pathname, *args) 
 
               # File tk/lib/tk/font.rb, line 403
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
is_system_font?(fnt)

class methods

 
               # File tk/lib/tk/font.rb, line 198
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
measure(fnt, text) 
 
               # File tk/lib/tk/font.rb, line 256
def TkFont.measure(fnt, text)
  fnt = '{}' if fnt == ''
  if fnt.kind_of?(TkFont)
    fnt.measure(text)
  else
    measure_core(fnt, nil, text)
  end
end
measure_displayof(fnt, win, text) 
 
               # File tk/lib/tk/font.rb, line 265
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
metrics(fnt, option=nil) 
 
               # File tk/lib/tk/font.rb, line 275
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
metrics_displayof(fnt, win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 311
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
metrics_hash(fnt, option=nil) 
 
               # File tk/lib/tk/font.rb, line 283
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
metrics_hash_displayof(fnt, win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 320
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
names() 
 
               # File tk/lib/tk/font.rb, line 362
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
new(ltn=nil, knj=nil, keys=nil) 
 
               # File tk/lib/tk/font.rb, line 588
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
used_on(path=nil) 
 
               # File tk/lib/tk/font.rb, line 517
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

Public Instance Methods

[](slot) 
 
               # File tk/lib/tk/font.rb, line 1257
def [](slot)
  configinfo slot
end
[]=(slot, val) 
 
               # File tk/lib/tk/font.rb, line 1261
def []=(slot, val)
  configure slot, val
  val
end
actual(option=nil) 
 
               # File tk/lib/tk/font.rb, line 1190
def actual(option=nil)
  actual_core(@compoundfont, nil, option)
end
actual_displayof(win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 1197
def actual_displayof(win, option=nil)
  win = '.' unless win
  actual_core(@compoundfont, win, option)
end
actual_hash(option=nil) 
 
               # File tk/lib/tk/font.rb, line 1193
def actual_hash(option=nil)
  Hash[actual(option)]
end
actual_hash_displayof(win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 1201
def actual_hash_displayof(win, option=nil)
  Hash[actual_displayof(win, option)]
end
ascii_actual(option=nil)
Alias for: latin_actual
ascii_actual_displayof(win, option=nil)
Alias for: latin_actual_displayof
ascii_configinfo(slot=nil)
Alias for: latin_configinfo
ascii_configure(slot, value=None)
Alias for: latin_configure
ascii_font()

public alias

Alias for: latin_font
ascii_metrics(option=nil)
Alias for: latin_metrics
ascii_replace(ltn)
Alias for: latin_replace
asciifont()
Alias for: latinfont
call_font_configure(path, *args) 
 
               # File tk/lib/tk/font.rb, line 1041
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
configinfo(slot=nil) 
 
               # File tk/lib/tk/font.rb, line 1271
def configinfo(slot=nil)
  configinfo_core(@compoundfont, slot)
end
configure(slot, value=None) 
 
               # File tk/lib/tk/font.rb, line 1266
def configure(slot, value=None)
  configure_core(@compoundfont, slot, value)
  self
end
create_asciifont(font)
Alias for: create_latinfont
create_compoundfont(ltn, knj, keys)
Alias for: create_compoundfont_tk4x
create_kanjifont(font)
Alias for: create_kanjifont_tk4x
create_latinfont(font)
Also aliased as: create_asciifont
Alias for: create_latinfont_tk4x
current_configinfo(slot=nil) 
 
               # File tk/lib/tk/font.rb, line 1275
def current_configinfo(slot=nil)
  current_configinfo_core(@compoundfont, slot)
end
delete() 
 
               # File tk/lib/tk/font.rb, line 1279
def delete
  delete_core
end
font() 
 
               # File tk/lib/tk/font.rb, line 1141
def font
  @compoundfont
end
Also aliased as: font_id, name, to_s
font_id()
Alias for: font
id() 
 
               # File tk/lib/tk/font.rb, line 1133
def id
  @id
end
inspect() 
 
               # File tk/lib/tk/font.rb, line 1013
def inspect
  sprintf("#<%s:%0x:%s>", self.class.inspect, self.__id__, @compoundfont)
end
kanji_actual(option=nil) 
 
               # File tk/lib/tk/font.rb, line 1228
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
kanji_actual_displayof(win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 1242
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
kanji_actual_hash(option=nil) 
 
               # File tk/lib/tk/font.rb, line 1238
def kanji_actual_hash(option=nil)
  Hash[kanji_actual(option)]
end
kanji_actual_hash_displayof(win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 1253
def kanji_actual_hash_displayof(win, option=nil)
  Hash[kanji_actual_displayof(win, option)]
end
kanji_configinfo(slot=nil) 
 
               # File tk/lib/tk/font.rb, line 1317
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
kanji_configure(slot, value=None) 
 
               # File tk/lib/tk/font.rb, line 1303
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
kanji_current_configinfo(slot=nil) 
 
               # File tk/lib/tk/font.rb, line 1328
def kanji_current_configinfo(slot=nil)
  Hash[kanji_configinfo(slot)]
end
kanji_font() 
 
               # File tk/lib/tk/font.rb, line 1173
  def kanji_font
    # @kanjifont
    if @descendant[1] # [1] -> kanji
      @descendant[1]
    else
      @descendant[1] = DescendantFont.new(self, 'kanji')
    end
    if @kanji_descendant
      @kanji_descendant
    else
      @kanji_descendant = DescendantFont.new(self, 'kanji')
    end
  end
Also aliased as: kanjifont
kanji_font_id() 
 
               # File tk/lib/tk/font.rb, line 1169
def kanji_font_id
  @kanjifont
end
kanji_metrics(option=nil) 
 
               # File tk/lib/tk/font.rb, line 1512
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
kanji_metrics_displayof(win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 1549
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
kanji_metrics_hash(option=nil) 
 
               # File tk/lib/tk/font.rb, line 1521
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
kanji_metrics_hash_displayof(win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 1559
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
kanji_replace(knj) 
 
               # File tk/lib/tk/font.rb, line 1362
def kanji_replace(knj)
  return self unless @kanjifont  # ignore
  kanji_replace_core(knj)
  reset_pointadjust
  self
end
kanjifont()
Alias for: kanji_font
latin_actual(option=nil) 
 
               # File tk/lib/tk/font.rb, line 1205
def latin_actual(option=nil)
  if @latinfont == nil
    actual_core(@compoundfont, nil, option) # use @compoundfont
  else
    actual_core(@latinfont, nil, option)
  end
end
Also aliased as: ascii_actual
latin_actual_displayof(win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 1216
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
Also aliased as: ascii_actual_displayof
latin_actual_hash(option=nil) 
 
               # File tk/lib/tk/font.rb, line 1212
def latin_actual_hash(option=nil)
  Hash[latin_actual(option)]
end
latin_actual_hash_displayof(win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 1224
def latin_actual_hash_displayof(win, option=nil)
  Hash[latin_actual_displayof(win, option)]
end
latin_configinfo(slot=nil) 
 
               # File tk/lib/tk/font.rb, line 1292
def latin_configinfo(slot=nil)
  if JAPANIZED_TK
    configinfo_core(@latinfont, slot)
  else
    configinfo(slot)
  end
end
Also aliased as: ascii_configinfo
latin_configure(slot, value=None) 
 
               # File tk/lib/tk/font.rb, line 1283
def latin_configure(slot, value=None)
  if JAPANIZED_TK
    configure_core(@latinfont, slot, value)
  else
    configure(slot, value)
  end
  self
end
Also aliased as: ascii_configure
latin_current_configinfo(slot=nil) 
 
               # File tk/lib/tk/font.rb, line 1299
def latin_current_configinfo(slot=nil)
  Hash[latin_configinfo(slot)]
end
latin_font() 
 
               # File tk/lib/tk/font.rb, line 1152
  def latin_font
    # @latinfont
    if @descendant[0] # [0] -> latin
      @descendant[0]
    else
      @descendant[0] = DescendantFont.new(self, 'latin')
    end
    if @latin_descendant
      @latin_descendant
    else
      @latin_descendant = DescendantFont.new(self, 'latin')
    end
  end
Also aliased as: latinfont, ascii_font
latin_font_id() 
 
               # File tk/lib/tk/font.rb, line 1148
def latin_font_id
  @latinfont
end
latin_metrics(option=nil) 
 
               # File tk/lib/tk/font.rb, line 1441
def latin_metrics(option=nil)
  if @latinfont == nil
    metrics_core(@compoundfont, nil, option) # use @compoundfont
  else
    metrics_core(@latinfont, nil, option)
  end
end
Also aliased as: ascii_metrics
latin_metrics_displayof(win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 1476
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
latin_metrics_hash(option=nil) 
 
               # File tk/lib/tk/font.rb, line 1448
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
latin_metrics_hash_displayof(win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 1484
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
latin_replace(ltn) 
 
               # File tk/lib/tk/font.rb, line 1339
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
Also aliased as: ascii_replace
latinfont()
Also aliased as: asciifont
Alias for: latin_font
measure(text) 
 
               # File tk/lib/tk/font.rb, line 1369
def measure(text)
  measure_core(@compoundfont, nil, text)
end
measure_displayof(win, text) 
 
               # File tk/lib/tk/font.rb, line 1373
def measure_displayof(win, text)
  win = '.' unless win
  measure_core(@compoundfont, win, text)
end
method_missing(id, *args) 
 
               # File tk/lib/tk/font.rb, line 1017
  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
metrics(option=nil) 
 
               # File tk/lib/tk/font.rb, line 1378
def metrics(option=nil)
  metrics_core(@compoundfont, nil, option)
end
metrics_displayof(win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 1409
def metrics_displayof(win, option=nil)
  win = '.' unless win
  metrics_core(@compoundfont, win, option)
end
metrics_hash(option=nil) 
 
               # File tk/lib/tk/font.rb, line 1381
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
metrics_hash_displayof(win, option=nil) 
 
               # File tk/lib/tk/font.rb, line 1413
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
mutex() 
 
               # File tk/lib/tk/font.rb, line 17
def mutex; @mutex; end
name()
Alias for: font
replace(ltn, knj=None) 
 
               # File tk/lib/tk/font.rb, line 1332
def replace(ltn, knj=None)
  knj = ltn if knj == None
  latin_replace(ltn)
  kanji_replace(knj)
  self
end
reset_pointadjust() 
 
               # File tk/lib/tk/font.rb, line 1587
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
to_eval() 
 
               # File tk/lib/tk/font.rb, line 1137
def to_eval
  font
end
to_s()
Alias for: font
used() 
 
               # File tk/lib/tk/font.rb, line 1073
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