In Files

  • tk/lib/tk.rb
  • tk/lib/tk/composite.rb
  • tk/lib/tk/font.rb
  • tk/lib/tk/itemconfig.rb
  • tk/lib/tk/namespace.rb
  • tk/lib/tk/panedwindow.rb
  • tk/lib/tk/place.rb
  • tk/lib/tk/text.rb
  • tk/lib/tk/wm.rb
  • tk/lib/tk/xim.rb
  • tk/lib/tkextlib/blt.rb
  • tk/lib/tkextlib/blt/component.rb
  • tk/lib/tkextlib/blt/treeview.rb
  • tk/lib/tkextlib/blt/watch.rb
  • tk/lib/tkextlib/bwidget.rb
  • tk/lib/tkextlib/bwidget/dialog.rb
  • tk/lib/tkextlib/bwidget/messagedlg.rb
  • tk/lib/tkextlib/iwidgets.rb
  • tk/lib/tkextlib/iwidgets/scrolledtext.rb
  • tk/lib/tkextlib/tcllib.rb
  • tk/lib/tkextlib/tile.rb
  • tk/lib/tkextlib/tile/tpaned.rb
  • tk/lib/tkextlib/tile/treeview.rb
  • tk/lib/tkextlib/vu.rb

Class/Module Index [+]

Quicksearch

TkComm

define TkComm module (step 2: event binding)

Constants

GET_CONFIGINFO_AS_ARRAY

GET_CONFIGINFO_AS_ARRAY = false => returns a Hash { opt =>val, ... }

true  => returns an Array [[opt,val], ... ]

val is a list which includes resource info.

GET_CONFIGINFOwoRES_AS_ARRAY

for configinfo without resource info; list of [opt, value] pair

false => returns a Hash { opt=>val, ... }
true  => returns an Array [[opt,val], ... ]
TkExtlibAutoloadModule
Tk_CMDTBL

for backward compatibility

Tk_IDs

Tk_CMDTBL = {} Tk_WINDOWS = {}

Tk_WINDOWS
USE_TCLs_LIST_FUNCTIONS
WidgetClassNames

Public Class Methods

_at(x,y=nil) click to toggle source 
 
               # File tk/lib/tk.rb, line 201
def _at(x,y=nil)
  if y
    "@#{Integer(x)},#{Integer(y)}"
  else
    "@#{Integer(x)}"
  end
end
_callback_entry?(obj) click to toggle source 
 
               # File tk/lib/tk.rb, line 645
def _callback_entry?(obj)
  obj.kind_of?(Proc) || obj.kind_of?(Method) || obj.kind_of?(TkCallbackEntry)
end
_callback_entry_class?(cls) click to toggle source 
 
               # File tk/lib/tk.rb, line 639
def _callback_entry_class?(cls)
  cls <= Proc || cls <= Method || cls <= TkCallbackEntry
end
_curr_cmd_id() click to toggle source

### –> definition is moved to TkUtil module def _get_eval_string(str, enc_mode = nil)

return nil if str == None
if str.kind_of?(TkObject)
  str = str.path
elsif str.kind_of?(String)
  str = _toUTF8(str) if enc_mode
elsif str.kind_of?(Symbol)
  str = str.id2name
  str = _toUTF8(str) if enc_mode
elsif str.kind_of?(Hash)
  str = hash_kv(str, enc_mode).join(" ")
elsif str.kind_of?(Array)
  str = array2tk_list(str)
  str = _toUTF8(str) if enc_mode
elsif str.kind_of?(Proc)
  str = install_cmd(str)
elsif str == nil
  str = ""
elsif str == false
  str = "0"
elsif str == true
  str = "1"
elsif (str.respond_to?(:to_eval))
  str = str.to_eval()
  str = _toUTF8(str) if enc_mode
else
  str = str.to_s() || ''
  unless str.kind_of? String
    fail RuntimeError, "fail to convert the object to a string" 
  end
  str = _toUTF8(str) if enc_mode
end
return str

end

def _get_eval_string(obj, enc_mode = nil)

case obj
when Numeric
  obj.to_s
when String
  (enc_mode)? _toUTF8(obj): obj
when Symbol
  (enc_mode)? _toUTF8(obj.id2name): obj.id2name
when TkObject
  obj.path
when Hash
  hash_kv(obj, enc_mode).join(' ')
when Array
  (enc_mode)? _toUTF8(array2tk_list(obj)): array2tk_list(obj)
when Proc, Method, TkCallbackEntry
  install_cmd(obj)
when false
  '0'
when true
  '1'
when nil
  ''
when None
  nil
else
  if (obj.respond_to?(:to_eval))
    (enc_mode)? _toUTF8(obj.to_eval): obj.to_eval
  else
    begin
      obj = obj.to_s || ''
    rescue
      fail RuntimeError, "fail to convert object '#{obj}' to string" 
    end
    (enc_mode)? _toUTF8(obj): obj
  end
end

end private :_get_eval_string module_function :_get_eval_string

### –> definition is moved to TkUtil module def _get_eval_enc_str(obj)

return obj if obj == None
_get_eval_string(obj, true)

end private :_get_eval_enc_str module_function :_get_eval_enc_str

### –> obsolete def ruby2tcl(v, enc_mode = nil)

if v.kind_of?(Hash)
  v = hash_kv(v)
  v.flatten!
  v.collect{|e|ruby2tcl(e, enc_mode)}
else
  _get_eval_string(v, enc_mode)
end

end private :ruby2tcl

### –> definition is moved to TkUtil module def _conv_args(args, enc_mode, *src_args)

conv_args = []
src_args.each{|arg|
  conv_args << _get_eval_string(arg, enc_mode) unless arg == None
  # if arg.kind_of?(Hash)
  # arg.each{|k, v|
  #   args << '-' + k.to_s
  #   args << _get_eval_string(v, enc_mode)
  # }
  # elsif arg != None
  #   args << _get_eval_string(arg, enc_mode)
  # end
}
args + conv_args

end private :_conv_args

 
               # File tk/lib/tk.rb, line 774
def _curr_cmd_id
  #id = format("c%.4d", Tk_IDs[0])
  id = "c" + TkCore::INTERP._ip_id_ + TkComm::Tk_IDs[0]
end
_fromUTF8(str, encoding = nil) click to toggle source 
 
               # File tk/lib/tk.rb, line 633
def _fromUTF8(str, encoding = nil)
  TkCore::INTERP._fromUTF8(str, encoding)
end
_genobj_for_tkwidget(path) click to toggle source 
 
               # File tk/lib/tk.rb, line 100
  def _genobj_for_tkwidget(path)
    return TkRoot.new if path == '.'

    begin
      #tk_class = TkCore::INTERP._invoke('winfo', 'class', path)
      tk_class = Tk.ip_invoke_without_enc('winfo', 'class', path)
    rescue
      return path
    end

    if ruby_class = WidgetClassNames[tk_class]
      ruby_class_name = ruby_class.name
      # gen_class_name = ruby_class_name + 'GeneratedOnTk'
      gen_class_name = ruby_class_name
      classname_def = ''
    else # ruby_class == nil
      mods = TkExtlibAutoloadModule.find_all{|m| m.const_defined?(tk_class)}
      mods.each{|mod|
        begin
          mod.const_get(tk_class)  # auto_load
          break if (ruby_class = WidgetClassNames[tk_class])
        rescue LoadError
          # ignore load error
        end
      }

      unless ruby_class
        std_class = 'Tk' << tk_class
        if Object.const_defined?(std_class)
          Object.const_get(std_class)  # auto_load
          ruby_class = WidgetClassNames[tk_class]
        end
      end

      if ruby_class
        # found
        ruby_class_name = ruby_class.name
        gen_class_name = ruby_class_name
        classname_def = ''
      else
        # unknown
        ruby_class_name = 'TkWindow'
        gen_class_name = 'TkWidget_' + tk_class
        classname_def = "WidgetClassName = '#{tk_class}'.freeze"
      end
    end

###################################
    if ruby_class = WidgetClassNames[tk_class]
      ruby_class_name = ruby_class.name
      # gen_class_name = ruby_class_name + 'GeneratedOnTk'
      gen_class_name = ruby_class_name
      classname_def = ''
    else
      mod = TkExtlibAutoloadModule.find{|m| m.const_defined?(tk_class)}
      if mod
        ruby_class_name = mod.name + '::' + tk_class
        gen_class_name = ruby_class_name
        classname_def = ''
      elsif Object.const_defined?('Tk' + tk_class)
        ruby_class_name = 'Tk' + tk_class
        # gen_class_name = ruby_class_name + 'GeneratedOnTk'
        gen_class_name = ruby_class_name
        classname_def = ''
      else
        ruby_class_name = 'TkWindow'
        # gen_class_name = ruby_class_name + tk_class + 'GeneratedOnTk'
        gen_class_name = 'TkWidget_' + tk_class
        classname_def = "WidgetClassName = '#{tk_class}'.freeze"
      end
    end

    unless Object.const_defined? gen_class_name
      Object.class_eval "class #{gen_class_name}<#{ruby_class_name}
                           #{classname_def}
                         end"
    end
    Object.class_eval "#{gen_class_name}.new('widgetname'=>'#{path}', 
                                             'without_creating'=>true)"
    base = Object
    gen_class_name.split('::').each{|klass|
      next if klass == ''
      if base.const_defined?(klass)
        base = base.class_eval klass
      else
        base = base.class_eval "class #{klass}<#{ruby_class_name}
                                  #{classname_def}
                                end
                                #{klass}"
      end
    }
    base.class_eval "#{gen_class_name}.new('widgetname'=>'#{path}', 
                                           'without_creating'=>true)"
  end
_next_cmd_id() click to toggle source 
 
               # File tk/lib/tk.rb, line 778
def _next_cmd_id
  TkComm::Tk_IDs.mutex.synchronize{
    id = _curr_cmd_id
    #Tk_IDs[0] += 1
    TkComm::Tk_IDs[0].succ!
    id
  }
end
_toUTF8(str, encoding = nil) click to toggle source 
 
               # File tk/lib/tk.rb, line 630
def _toUTF8(str, encoding = nil)
  TkCore::INTERP._toUTF8(str, encoding)
end
array2tk_list(ary, enc=nil) click to toggle source 
 
               # File tk/lib/tk.rb, line 335
def array2tk_list(ary, enc=nil)
  return "" if ary.size == 0

  sys_enc = TkCore::INTERP.encoding
  sys_enc = TclTkLib.encoding_system unless sys_enc

  dst_enc = (enc == nil)? sys_enc: enc

  dst = ary.collect{|e|
    if e.kind_of? Array
      s = array2tk_list(e, enc)
    elsif e.kind_of? Hash
      tmp_ary = []
      #e.each{|k,v| tmp_ary << k << v }
      e.each{|k,v| tmp_ary << "-#{_get_eval_string(k)}" << v }
      s = array2tk_list(tmp_ary, enc)
    else
      s = _get_eval_string(e, enc)
    end

    if dst_enc != true && dst_enc != false
      if (s_enc = s.instance_variable_get(:@encoding))
        s_enc = s_enc.to_s
      elsif TkCore::WITH_ENCODING
        s_enc = s.encoding.name
      else
        s_enc = sys_enc
      end
      dst_enc = true if s_enc != dst_enc
    end

    s
  }

  if sys_enc && dst_enc
    dst.map!{|s| _toUTF8(s)}
    ret = TkCore::INTERP._merge_tklist(*dst)
    if TkCore::WITH_ENCODING
      if dst_enc.kind_of?(String)
        ret = _fromUTF8(ret, dst_enc)
        ret.force_encoding(dst_enc)
      else
        ret.force_encoding('utf-8')
      end
    else # without encoding
      if dst_enc.kind_of?(String)
        ret = _fromUTF8(ret, dst_enc)
        ret.instance_variable_set(:@encoding, dst_enc)
      else
        ret.instance_variable_set(:@encoding, 'utf-8')
      end
    end
    ret
  else
    TkCore::INTERP._merge_tklist(*dst)
  end
end
image_obj(val) click to toggle source 
 
               # File tk/lib/tk.rb, line 593
def image_obj(val)
  if val =~ /^i(_\d+_)?\d+$/
    TkImage::Tk_IMGTBL.mutex.synchronize{
      TkImage::Tk_IMGTBL[val]? TkImage::Tk_IMGTBL[val] : val
    }
  else
    val
  end
end
install_cmd(cmd, local_cmdtbl=nil) click to toggle source 
 
               # File tk/lib/tk.rb, line 789
def TkComm.install_cmd(cmd, local_cmdtbl=nil)
  return '' if cmd == ''
  begin
    ns = TkCore::INTERP._invoke_without_enc('namespace', 'current')
    ns = nil if ns == '::' # for backward compatibility
  rescue
    # probably, Tcl7.6
    ns = nil
  end
  id = _next_cmd_id
  #Tk_CMDTBL[id] = cmd
  if cmd.kind_of?(TkCallbackEntry)
    TkCore::INTERP.tk_cmd_tbl[id] = cmd
  else
    TkCore::INTERP.tk_cmd_tbl[id] = TkCore::INTERP.get_cb_entry(cmd)
  end
  @cmdtbl = [] unless defined? @cmdtbl
  @cmdtbl.taint unless @cmdtbl.tainted?
  @cmdtbl.push id

  if local_cmdtbl && local_cmdtbl.kind_of?(Array)
    begin
      local_cmdtbl << id
    rescue Exception
      # ignore
    end
  end

  #return Kernel.format("rb_out %s", id);
  if ns
    'rb_out' << TkCore::INTERP._ip_id_ << ' ' << ns << ' ' << id
  else
    'rb_out' << TkCore::INTERP._ip_id_ << ' ' << id
  end
end
list(val, depth=0, enc=true) click to toggle source

### –> definition is moved to TkUtil module def _symbolkey2str(keys)

h = {}
keys.each{|key,value| h[key.to_s] = value}
h

end private :_symbolkey2str module_function :_symbolkey2str

### –> definition is moved to TkUtil module # def hash_kv(keys, enc_mode = nil, conf = [], flat = false) def hash_kv(keys, enc_mode = nil, conf = nil)

# Hash {key=>val, key=>val, ... } or Array [ [key, val], [key, val], ... ]
#     ==> Array ['-key', val, '-key', val, ... ]
dst = []
if keys and keys != None
  keys.each{|k, v|
    #dst.push("-#{k}")
    dst.push('-' + k.to_s)
    if v != None
      # v = _get_eval_string(v, enc_mode) if (enc_mode || flat)
      v = _get_eval_string(v, enc_mode) if enc_mode
      dst.push(v)
    end
  }
end
if conf
  conf + dst
else
  dst
end

end private :hash_kv module_function :hash_kv

### –> definition is moved to TkUtil module def bool(val)

case val
when "1", 1, 'yes', 'true'
  true
else
  false
end

end

def number(val)

case val
when /^-?\d+$/
  val.to_i
when /^-?\d+\.?\d*(e[-+]?\d+)?$/
  val.to_f
else
  fail(ArgumentError, "invalid value for Number:'#{val}'")
end

end def string(val)

if val == "{}"
  ''
elsif val[0] == ?{ && val[-1] == ?}
  val[1..-2]
else
  val
end

end def num_or_str(val)

begin
  number(val)
rescue ArgumentError
  string(val)
end

end

 
               # File tk/lib/tk.rb, line 578
def list(val, depth=0, enc=true)
  tk_split_list(val, depth, enc, enc)
end
procedure(val) click to toggle source 
 
               # File tk/lib/tk.rb, line 602
  def procedure(val)
    if val =~ /^rb_out\S* (c(_\d+_)?\d+)/
      #Tk_CMDTBL[$1]
      #TkCore::INTERP.tk_cmd_tbl[$1]
      TkCore::INTERP.tk_cmd_tbl[$1].cmd
    if val =~ /rb_out\S*(?:\s+(::\S*|[{](::.*)[}]|["](::.*)["]))? (c(_\d+_)?(\d+))/
      return TkCore::INTERP.tk_cmd_tbl[$4].cmd
    else
      #nil
      val
    end
  end
simplelist(val, src_enc=true, dst_enc=true) click to toggle source 
 
               # File tk/lib/tk.rb, line 581
def simplelist(val, src_enc=true, dst_enc=true)
  tk_split_simplelist(val, src_enc, dst_enc)
end
tk_tcl2ruby(val, enc_mode = false, listobj = true) click to toggle source 
 
               # File tk/lib/tk.rb, line 210
  def tk_tcl2ruby(val, enc_mode = false, listobj = true)
    if val =~ /^rb_out\S* (c(_\d+_)?\d+)/
      #return Tk_CMDTBL[$1]
      return TkCore::INTERP.tk_cmd_tbl[$1]
      #cmd_obj = TkCore::INTERP.tk_cmd_tbl[$1]
      #if cmd_obj.kind_of?(Proc) || cmd_obj.kind_of?(Method)
      #  cmd_obj
      #else
      #  cmd_obj.cmd
      #end
    end
    if val =~ /rb_out\S*(?:\s+(::\S*|[{](::.*)[}]|["](::.*)["]))? (c(_\d+_)?(\d+))/
      return TkCore::INTERP.tk_cmd_tbl[$4]
    end
    #if val.include? ?\s
    #  return val.split.collect{|v| tk_tcl2ruby(v)}
    #end
    case val
    when /\A@font\S+\z/
      TkFont.get_obj(val)
    when /\A-?\d+\z/
      val.to_i
    when /\A\.\S*\z/
      #Tk_WINDOWS[val] ? Tk_WINDOWS[val] : _genobj_for_tkwidget(val)
      TkCore::INTERP.tk_windows[val]? 
           TkCore::INTERP.tk_windows[val] : _genobj_for_tkwidget(val)
    when /\Ai(_\d+_)?\d+\z/
      TkImage::Tk_IMGTBL.mutex.synchronize{
        TkImage::Tk_IMGTBL[val]? TkImage::Tk_IMGTBL[val] : val
      }
    when /\A-?\d+\.?\d*(e[-+]?\d+)?\z/
      val.to_f
    when /\ /
      val.gsub(/\ /, ' ')
    when /[^\] /
      if listobj
        #tk_split_escstr(val).collect{|elt|
        #  tk_tcl2ruby(elt, enc_mode, listobj)
        #}
        val = _toUTF8(val) unless enc_mode
        tk_split_escstr(val, false, false).collect{|elt|
          tk_tcl2ruby(elt, true, listobj)
        }
      elsif enc_mode
        _fromUTF8(val)
      else
        val
      end
    else
      if enc_mode
        _fromUTF8(val)
      else
        val
      end
    end
  end
uninstall_cmd(id, local_cmdtbl=nil) click to toggle source 
 
               # File tk/lib/tk.rb, line 824
def TkComm.uninstall_cmd(id, local_cmdtbl=nil)
  #id = $1 if /rb_out\S* (c(_\d+_)?\d+)/ =~ id
  id = $4 if id =~ /rb_out\S*(?:\s+(::\S*|[{](::.*)[}]|["](::.*)["]))? (c(_\d+_)?(\d+))/

  if local_cmdtbl && local_cmdtbl.kind_of?(Array)
    begin
      local_cmdtbl.delete(id)
    rescue Exception
      # ignore
    end
  end
  @cmdtbl.delete(id)

  #Tk_CMDTBL.delete(id)
  TkCore::INTERP.tk_cmd_tbl.delete(id)
end
window(val) click to toggle source 
 
               # File tk/lib/tk.rb, line 584
def window(val)
  if val =~ /^\./
    #Tk_WINDOWS[val]? Tk_WINDOWS[val] : _genobj_for_tkwidget(val)
    TkCore::INTERP.tk_windows[val]? 
         TkCore::INTERP.tk_windows[val] : _genobj_for_tkwidget(val)
  else
    nil
  end
end

Public Instance Methods

bind(tagOrClass, context, *args) click to toggle source

def bind(tagOrClass, context, cmd=Proc.new, *args)

_bind(["bind", tagOrClass], context, cmd, *args)
tagOrClass

end

 
               # File tk/lib/tk.rb, line 1032
def bind(tagOrClass, context, *args)
  # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
  if TkComm._callback_entry?(args[0]) || !block_given?
    cmd = args.shift
  else
    cmd = Proc.new
  end
  _bind(["bind", tagOrClass], context, cmd, *args)
  tagOrClass
end
bind_all(context, *args) click to toggle source

def #bind_all(context, cmd=Proc.new, *args)

_bind(['bind', 'all'], context, cmd, *args)
TkBindTag::ALL

end

 
               # File tk/lib/tk.rb, line 1071
def bind_all(context, *args)
  # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
  if TkComm._callback_entry?(args[0]) || !block_given?
    cmd = args.shift
  else
    cmd = Proc.new
  end
  _bind(['bind', 'all'], context, cmd, *args)
  TkBindTag::ALL
end
bind_append(tagOrClass, context, *args) click to toggle source

def #bind_append(tagOrClass, context, cmd=Proc.new, *args)

_bind_append(["bind", tagOrClass], context, cmd, *args)
tagOrClass

end

 
               # File tk/lib/tk.rb, line 1047
def bind_append(tagOrClass, context, *args)
  # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
  if TkComm._callback_entry?(args[0]) || !block_given?
    cmd = args.shift
  else
    cmd = Proc.new
  end
  _bind_append(["bind", tagOrClass], context, cmd, *args)
  tagOrClass
end
bind_append_all(context, *args) click to toggle source

def #bind_append_all(context, cmd=Proc.new, *args)

_bind_append(['bind', 'all'], context, cmd, *args)
TkBindTag::ALL

end

 
               # File tk/lib/tk.rb, line 1086
def bind_append_all(context, *args)
  # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
  if TkComm._callback_entry?(args[0]) || !block_given?
    cmd = args.shift
  else
    cmd = Proc.new
  end
  _bind_append(['bind', 'all'], context, cmd, *args)
  TkBindTag::ALL
end
bind_remove(tagOrClass, context) click to toggle source 
 
               # File tk/lib/tk.rb, line 1058
def bind_remove(tagOrClass, context)
  _bind_remove(['bind', tagOrClass], context)
  tagOrClass
end
bind_remove_all(context) click to toggle source 
 
               # File tk/lib/tk.rb, line 1097
def bind_remove_all(context)
  _bind_remove(['bind', 'all'], context)
  TkBindTag::ALL
end
bindinfo(tagOrClass, context=nil) click to toggle source 
 
               # File tk/lib/tk.rb, line 1063
def bindinfo(tagOrClass, context=nil)
  _bindinfo(['bind', tagOrClass], context)
end
bindinfo_all(context=nil) click to toggle source 
 
               # File tk/lib/tk.rb, line 1102
def bindinfo_all(context=nil)
  _bindinfo(['bind', 'all'], context)
end
install_cmd(cmd) click to toggle source

private :install_cmd, :uninstall_cmd module_function :install_cmd, :uninstall_cmd

 
               # File tk/lib/tk.rb, line 842
def install_cmd(cmd)
  TkComm.install_cmd(cmd, @cmdtbl)
end
mutex() click to toggle source 
 
               # File tk/lib/tk.rb, line 56
def mutex; @mutex; end
subst(str, *opts) click to toggle source 
 
               # File tk/lib/tk.rb, line 621
def subst(str, *opts)
  # opts := :nobackslashes | :nocommands | novariables
  tk_call('subst', 
          *(opts.collect{|opt|
              opt = opt.to_s
              (opt[0] == ?-)? opt: '-' << opt
            } << str))
end
uninstall_cmd(id) click to toggle source 
 
               # File tk/lib/tk.rb, line 845
def uninstall_cmd(id)
  TkComm.uninstall_cmd(id, @cmdtbl)
end

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus