In Files

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

Parent

Included Modules

Class/Module Index [+]

Quicksearch

Font

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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 205
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 217
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 213
def TkFont.actual_hash(fnt, option=nil)
  Hash[TkFont.actual(fnt, option)]
end
            
actual_hash_displayof(fnt, option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 226
def TkFont.actual_hash_displayof(fnt, option=nil)
  Hash[TkFont.actual_displayof(fnt, option)]
end
            
configinfo(fnt, slot=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 239
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 230
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 378
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 247
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 527
def TkFont.failsafe(font)
  begin
    if /^8\..*/ === Tk::TK_VERSION  && JAPANIZED_TK
      tk_call('font', 'failsafe', font)
    end
  rescue
  end
end
            
families(win=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 347
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 389
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 402
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) click to toggle source

class methods

 
               # File tk/lib/tk/font.rb, line 197
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 255
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 264
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 274
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 310
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 282
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 319
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() click to toggle source
 
               # File tk/lib/tk/font.rb, line 361
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 587
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 516
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1256
def [](slot)
  configinfo slot
end
            
[]=(slot, val) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1260
def []=(slot, val)
  configure slot, val
  val
end
            
actual(option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1189
def actual(option=nil)
  actual_core(@compoundfont, nil, option)
end
            
actual_displayof(win, option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1196
def actual_displayof(win, option=nil)
  win = '.' unless win
  actual_core(@compoundfont, win, option)
end
            
actual_hash(option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1192
def actual_hash(option=nil)
  Hash[actual(option)]
end
            
actual_hash_displayof(win, option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1200
def actual_hash_displayof(win, option=nil)
  Hash[actual_displayof(win, option)]
end
            
ascii_actual(option=nil) click to toggle source
Alias for: latin_actual
ascii_actual_displayof(win, option=nil) click to toggle source
ascii_configinfo(slot=nil) click to toggle source
Alias for: latin_configinfo
ascii_configure(slot, value=None) click to toggle source
Alias for: latin_configure
ascii_font() click to toggle source

public alias

Alias for: latin_font
ascii_metrics(option=nil) click to toggle source
Alias for: latin_metrics
ascii_replace(ltn) click to toggle source
Alias for: latin_replace
asciifont() click to toggle source
Alias for: latinfont
call_font_configure(path, *args) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1040
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1270
def configinfo(slot=nil)
  configinfo_core(@compoundfont, slot)
end
            
configure(slot, value=None) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1265
def configure(slot, value=None)
  configure_core(@compoundfont, slot, value)
  self
end
            
create_asciifont(font) click to toggle source
Alias for: create_latinfont
create_compoundfont(ltn, knj, keys) click to toggle source
create_kanjifont(font) click to toggle source
create_latinfont(font) click to toggle source
Also aliased as: create_asciifont
current_configinfo(slot=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1274
def current_configinfo(slot=nil)
  current_configinfo_core(@compoundfont, slot)
end
            
delete() click to toggle source
 
               # File tk/lib/tk/font.rb, line 1278
def delete
  delete_core
end
            
font() click to toggle source
 
               # File tk/lib/tk/font.rb, line 1140
def font
  @compoundfont
end
            
Also aliased as: font_id, name, to_s
font_id() click to toggle source
Alias for: font
id() click to toggle source
 
               # File tk/lib/tk/font.rb, line 1132
def id
  @id
end
            
inspect() click to toggle source
 
               # File tk/lib/tk/font.rb, line 1012
def inspect
  sprintf("#<%s:%0x:%s>", self.class.inspect, self.__id__, @compoundfont)
end
            
kanji_actual(option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1227
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1241
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1237
def kanji_actual_hash(option=nil)
  Hash[kanji_actual(option)]
end
            
kanji_actual_hash_displayof(win, option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1252
def kanji_actual_hash_displayof(win, option=nil)
  Hash[kanji_actual_displayof(win, option)]
end
            
kanji_configinfo(slot=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1316
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1302
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1327
def kanji_current_configinfo(slot=nil)
  Hash[kanji_configinfo(slot)]
end
            
kanji_font() click to toggle source
 
               # File tk/lib/tk/font.rb, line 1172
  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
            
Also aliased as: kanjifont
kanji_font_id() click to toggle source
 
               # File tk/lib/tk/font.rb, line 1168
def kanji_font_id
  @kanjifont
end
            
kanji_metrics(option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1511
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1548
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1520
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1558
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1361
def kanji_replace(knj)
  return self unless @kanjifont  # ignore
  kanji_replace_core(knj)
  reset_pointadjust
  self
end
            
kanjifont() click to toggle source
Alias for: kanji_font
latin_actual(option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1204
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1215
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1211
def latin_actual_hash(option=nil)
  Hash[latin_actual(option)]
end
            
latin_actual_hash_displayof(win, option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1223
def latin_actual_hash_displayof(win, option=nil)
  Hash[latin_actual_displayof(win, option)]
end
            
latin_configinfo(slot=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1291
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1282
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1298
def latin_current_configinfo(slot=nil)
  Hash[latin_configinfo(slot)]
end
            
latin_font() click to toggle source
 
               # File tk/lib/tk/font.rb, line 1151
  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
            
Also aliased as: latinfont, ascii_font
latin_font_id() click to toggle source
 
               # File tk/lib/tk/font.rb, line 1147
def latin_font_id
  @latinfont
end
            
latin_metrics(option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1440
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1475
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1447
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1483
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1338
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() click to toggle source
Also aliased as: asciifont
Alias for: latin_font
measure(text) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1368
def measure(text)
  measure_core(@compoundfont, nil, text)
end
            
measure_displayof(win, text) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1372
def measure_displayof(win, text)
  win = '.' unless win
  measure_core(@compoundfont, win, text)
end
            
method_missing(id, *args) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1016
  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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1377
def metrics(option=nil)
  metrics_core(@compoundfont, nil, option)
end
            
metrics_displayof(win, option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1408
def metrics_displayof(win, option=nil)
  win = '.' unless win
  metrics_core(@compoundfont, win, option)
end
            
metrics_hash(option=nil) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1380
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) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1412
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() click to toggle source
 
               # File tk/lib/tk/font.rb, line 16
def mutex; @mutex; end
            
name() click to toggle source
Alias for: font
replace(ltn, knj=None) click to toggle source
 
               # File tk/lib/tk/font.rb, line 1331
def replace(ltn, knj=None)
  knj = ltn if knj == None
  latin_replace(ltn)
  kanji_replace(knj)
  self
end
            
reset_pointadjust() click to toggle source
 
               # File tk/lib/tk/font.rb, line 1586
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() click to toggle source
 
               # File tk/lib/tk/font.rb, line 1136
def to_eval
  font
end
            
to_s() click to toggle source
Alias for: font
used() click to toggle source
 
               # File tk/lib/tk/font.rb, line 1072
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