Class MultiTkIp < Object

# File ext/tk/lib/remote-tk.rb, line 19
def self._DEFAULT_MASTER
  # work only once
  if @flag
    @flag = nil
    @@DEFAULT_MASTER
  else
    nil
  end
end

# File ext/tk/lib/remote-tk.rb, line 15
def self._IP_TABLE; @@IP_TABLE; end

# File ext/tk/lib/remote-tk.rb, line 16
def self._TK_TABLE_LIST; @@TK_TABLE_LIST; end

# File ext/tk/lib/multi-tk.rb, line 1534
def self.__getip
  current = Thread.current
  if current.kind_of?(@@CALLBACK_SUBTHREAD)
    return current[:callback_ip]
  end
  if TclTkLib.mainloop_thread? != false && current[:callback_ip]
    return current[:callback_ip]
  end
  if current.group == ThreadGroup::Default
    @@DEFAULT_MASTER
  else
    ip = @@IP_TABLE[current.group]
    unless ip
      fail SecurityError,
        "cannot call Tk methods on #{Thread.current.inspect}"
    end
    ip
  end
end

# File ext/tk/lib/multi-tk.rb, line 956
def self.__init_ip_env__(table, script)
  ret = []
  mtx  = (Thread.current[:MultiTk_ip_Mutex] ||= Mutex.new)
  cond = (Thread.current[:MultiTk_ip_CondVar] ||= ConditionVariable.new)
  mtx.synchronize{
    @init_ip_env_queue.enq([mtx, cond, ret, table, script])
    cond.wait(mtx)
  }
  if ret[0].kind_of?(Exception)
    raise ret[0]
  else
    ret[0]
  end
end

# File ext/tk/lib/multi-tk.rb, line 845
def self.__pseudo_toplevel
  Thread.current.group == ThreadGroup::Default &&
    MultiTkIp.__getip == @@DEFAULT_MASTER &&
    self.__pseudo_toplevel_evaluable? && @pseudo_toplevel[1]
end

# File ext/tk/lib/multi-tk.rb, line 851
def self.__pseudo_toplevel=(m)
  unless (Thread.current.group == ThreadGroup::Default &&
            MultiTkIp.__getip == @@DEFAULT_MASTER)
    fail SecurityError, "no permission to manipulate"
  end

  # if m.kind_of?(Module) && m.respond_to?(:pseudo_toplevel_evaluable?)
  if m.respond_to?(:pseudo_toplevel_evaluable?)
    @pseudo_toplevel[0] = true
    @pseudo_toplevel[1] = m
  else
    fail ArgumentError, 'fail to set pseudo-toplevel'
  end
  self
end

# File ext/tk/lib/multi-tk.rb, line 875
def self.__pseudo_toplevel_evaluable=(mode)
  unless (Thread.current.group == ThreadGroup::Default &&
            MultiTkIp.__getip == @@DEFAULT_MASTER)
    fail SecurityError, "no permission to manipulate"
  end

  @pseudo_toplevel[0] = (mode)? true: false
end

# File ext/tk/lib/multi-tk.rb, line 867
def self.__pseudo_toplevel_evaluable?
  begin
    @pseudo_toplevel[0] && @pseudo_toplevel[1].pseudo_toplevel_evaluable?
  rescue Exception
    false
  end
end

# File ext/tk/lib/multi-tk.rb, line 1526
def self._ip_id_
  __getip._ip_id_
end

# File ext/tk/lib/multi-tk.rb, line 2142
def MultiTkIp._proc_on_current_safelevel(cmd=nil, &blk)
  MultiTkIp.__getip._proc_on_current_safelevel(cmd, &blk)
end

# File ext/tk/lib/multi-tk.rb, line 2133
def MultiTkIp._proc_on_safelevel(cmd=nil, &blk)
  MultiTkIp.__getip._proc_on_safelevel(cmd, &blk)
end

# File ext/tk/lib/multi-tk.rb, line 1883
def self.add_tk_procs(name, args=nil, body=nil)
  if name.kind_of?(Array) # => an array of [name, args, body]
    name.each{|param| self.add_tk_procs(*param)}
  else
    name = name.to_s
    @@ADD_TK_PROCS << [name, args, body]
    @@IP_TABLE.each{|tg, ip|
      ip._add_tk_procs(name, args, body)
    }
  end
end

# File ext/tk/lib/multi-tk.rb, line 3202
def self.alias_delete(slave, cmd_name)
  __getip.alias_delete(slave, cmd_name)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3193
def self.alias_info(slave, cmd_name)
  __getip.alias_info(slave, cmd_name)
end

# File ext/tk/lib/multi-tk.rb, line 3433
def self.alias_target(aliascmd, slave = '')
  __getip.alias_target(aliascmd, slave)
end

# File ext/tk/lib/multi-tk.rb, line 3222
def self.aliases(slave = '')
  __getip.aliases(slave)
end

# File ext/tk/lib/multi-tk.rb, line 1696
def self.alive?
  __getip.alive?
end

# File ext/tk/lib/multi-tk.rb, line 923
def self.assign_receiver_and_watchdog(target)
  ret = [nil]
  @assign_thread.raise(@assign_request.new(target, ret))
  while ret[0] == nil
    unless @assign_thread.alive?
      raise RuntimeError, 'lost the thread to assign a receiver and a watchdog thread'
    end
  end
  if ret[0].kind_of?(Exception)
    raise ret[0]
  else
    ret[0]
  end
end

# File ext/tk/lib/multi-tk.rb, line 3375
def self.bgerror(cmd = Proc.new, slave = nil, &b)
  __getip.bgerror(cmd, slave, &b)
end

# File ext/tk/lib/multi-tk.rb, line 1914
def self.cb_entry_class
  @@CB_ENTRY_CLASS
end

# File ext/tk/lib/multi-tk.rb, line 1826
def self.create_table
  if __getip.slave?
    begin
      raise SecurityError, "slave-IP has no permission creating a new table"
    rescue SecurityError => e
      #p e.backtrace
      # Is called on a Ruby/Tk library?
      caller_info = e.backtrace[1]
      if caller_info =~ %r{^#{MultiTkIp::BASE_DIR}/(tk|tkextlib)/[^:]+\.rb:}
        # Probably, caller is a Ruby/Tk library  -->  allow creating
      else
        raise e
      end
    end
  end

  id = @@TK_TABLE_LIST.size
  obj = Object.new
  @@TK_TABLE_LIST << obj
  obj.instance_variable_set(:@id, id)
  obj.instance_variable_set(:@mutex, Mutex.new)
  obj.instance_eval{
    def self.mutex
      @mutex
    end
    def self.method_missing(m, *args)
      MultiTkIp.tk_object_table(@id).__send__(m, *args)
    end
  }
  obj.freeze
  @@IP_TABLE.each{|tg, ip| ip._add_new_tables }
  return obj
end

# File ext/tk/lib/multi-tk.rb, line 3213
def self.def_alias(slave, new_cmd, org_cmd, *args)
  ret = __getip.def_alias(slave, new_cmd, org_cmd, *args)
  (ret == new_cmd)? self: nil
end

# File ext/tk/lib/multi-tk.rb, line 2480
def self.default_master?
  __getip == @@DEFAULT_MASTER
end

# File ext/tk/lib/multi-tk.rb, line 3252
def self.delete_cmd(slave, cmd)
  __getip.delete_cmd(slave, cmd)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3232
def self.delete_slaves(*args)
  __getip.delete_slaves(*args)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3242
def self.exist?(slave = '')
  __getip.exist?(slave)
end

# File ext/tk/lib/multi-tk.rb, line 3266
def self.expose_cmd(slave, cmd, aliasname = nil)
  __getip.expose_cmd(slave, cmd, aliasname)
  self
end

# File ext/tk/lib/multi-tk.rb, line 1917
def self.get_cb_entry(cmd)
  @@CB_ENTRY_CLASS.new(__getip, cmd).freeze
end

# File ext/tk/lib/multi-tk.rb, line 3416
def self.get_limit(limit_type, slave = '', slot = nil)
  __getip.get_limit(limit_type, slave, slot)
end

# File ext/tk/lib/multi-tk.rb, line 3289
def self.hidden_cmds(slave = '')
  __getip.hidden_cmds(slave)
end

# File ext/tk/lib/multi-tk.rb, line 3280
def self.hide_cmd(slave, cmd, aliasname = nil)
  __getip.hide_cmd(slave, cmd, aliasname)
  self
end

# File ext/tk/lib/multi-tk.rb, line 982
def self.inherited(subclass)
  # trust if on ThreadGroup::Default or @@DEFAULT_MASTER's ThreadGroup
  if @@IP_TABLE[Thread.current.group] == @@DEFAULT_MASTER
    begin
      class << subclass
        self.methods.each{|m|
          name = m.to_s
          begin
            unless name == '__id__' || name == '__send__' || name == 'freeze'
              undef_method(m)
            end
          rescue Exception
            # ignore all exceptions
          end
        }
      end
    ensure
      subclass.freeze
      fail SecurityError,
        "cannot create subclass of MultiTkIp on a untrusted ThreadGroup"
    end
  end
end

# File ext/tk/lib/multi-tk.rb, line 1860
def self.init_ip_env(script = Proc.new)
  @@INIT_IP_ENV << script
  if __getip.slave?
    begin
      raise SecurityError, "slave-IP has no permission initializing IP env"
    rescue SecurityError => e
      #p e.backtrace
      # Is called on a Ruby/Tk library?
      caller_info = e.backtrace[1]
      if caller_info =~ %r{^#{MultiTkIp::BASE_DIR}/(tk|tkextlib)/[^:]+\.rb:}
        # Probably, caller is a Ruby/Tk library  -->  allow creating
      else
        raise e
      end
    end
  end

  # @@IP_TABLE.each{|tg, ip|
  #   ip._init_ip_env(script)
  # }
  @@DEFAULT_MASTER.__init_ip_env__(@@IP_TABLE, script)
end

# File ext/tk/lib/multi-tk.rb, line 1907
def self.init_ip_internal
  __getip._init_ip_internal(@@INIT_IP_ENV, @@ADD_TK_PROCS)
end

# File ext/tk/lib/multi-tk.rb, line 3309
def self.invoke_hidden(slave, cmd, *args)
  __getip.invoke_hidden(slave, cmd, *args)
end

# File ext/tk/lib/multi-tk.rb, line 3330
def self.invoke_hidden_on_global(slave, cmd, *args)
  __getip.invoke_hidden_on_global(slave, cmd, *args)
end

# File ext/tk/lib/multi-tk.rb, line 3348
def self.invoke_hidden_on_namespace(slave, ns, cmd, *args)
  __getip.invoke_hidden_on_namespace(slave, ns, cmd, *args)
end

# File ext/tk/lib/multi-tk.rb, line 1709
def self.ip_name
  __getip.ip_name
end

# File ext/tk/lib/multi-tk.rb, line 799
def self.mainloop(check_root = true)
  begin
    TclTkLib.set_eventloop_window_mode(true)
    @interp_thread.value
  ensure
    TclTkLib.set_eventloop_window_mode(false)
  end
end

# File ext/tk/lib/multi-tk.rb, line 1740
def self.manipulable?
  true
end

# File ext/tk/lib/multi-tk.rb, line 3357
def self.mark_trusted(slave = '')
  __getip.mark_trusted(slave)
  self
end

# File ext/tk/lib/multi-tk.rb, line 1674
def self.master?
  __getip.master?
end

# File ext/tk/lib/multi-tk.rb, line 1851
def self.method_missing(m, *args)
  MultiTkIp.tk_object_table(@id).__send__(m, *args)
end

# File ext/tk/lib/multi-tk.rb, line 1848
def self.mutex
  @mutex
end

# File ext/tk/lib/multi-tk.rb, line 187
def initialize(ip, cmd)
  @ip = ip
  @safe = safe = $SAFE
  # @cmd = cmd
  cmd = MultiTkIp._proc_on_safelevel(&cmd)
  @cmd = proc{|*args| cmd.call(safe, *args)}
  self.freeze
end

# File ext/tk/lib/multi-tk.rb, line 887
def self.new(target, ret)
  obj = super()
  obj.target = target
  obj.ret = ret
  obj
end

# File ext/tk/lib/multi-tk.rb, line 1703
def self.path
  __getip.path
end

# File ext/tk/lib/multi-tk.rb, line 3425
def self.recursion_limit(slave = '', limit = None)
  __getip.recursion_limit(slave)
end

# File ext/tk/lib/multi-tk.rb, line 1895
def self.remove_tk_procs(*names)
  names.each{|name|
    name = name.to_s
    @@ADD_TK_PROCS.delete_if{|elem|
      elem.kind_of?(Array) && elem[0].to_s == name
    }
  }
  @@IP_TABLE.each{|tg, ip|
    ip._remove_tk_procs(*names)
  }
end

# File ext/tk/lib/multi-tk.rb, line 335
def self.safe_level
  __getip.safe_level
end

# File ext/tk/lib/multi-tk.rb, line 329
def self.safe_level=(safe)
  self.set_safe_level(safe)
end

# File ext/tk/lib/multi-tk.rb, line 3391
def self.set_limit(limit_type, slave = '', opts = {})
  __getip.set_limit(limit_type, slave, opts)
end

# File ext/tk/lib/multi-tk.rb, line 326
def self.set_safe_level(safe)
  __getip.set_safe_level(safe)
end

# File ext/tk/lib/multi-tk.rb, line 3462
def self.share_stderr(dist, src = '')
  __getip.share_stderr(dist, src)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3442
def self.share_stdin(dist, src = '')
  __getip.share_stdin(dist, src)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3504
def self.share_stdio(dist, src = '')
  __getip.share_stdio(dist, src)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3452
def self.share_stdout(dist, src = '')
  __getip.share_stdout(dist, src)
  self
end

# File ext/tk/lib/multi-tk.rb, line 1681
def self.slave?
  not self.master?
end

# File ext/tk/lib/multi-tk.rb, line 1731
def self.slaves(all = false)
  __getip.slaves(all)
end

# File ext/tk/lib/multi-tk.rb, line 1521
def self.table
  @table
end

# File ext/tk/lib/multi-tk.rb, line 1817
def self.tk_cmd_tbl
  @@TK_CMD_TBL
end

# File ext/tk/lib/multi-tk.rb, line 1823
def self.tk_object_table(id)
  __getip._tk_table_list[id]
end

# File ext/tk/lib/multi-tk.rb, line 1820
def self.tk_windows
  __getip._tk_windows
end

# File ext/tk/lib/multi-tk.rb, line 1715
def self.to_eval
  __getip.to_eval
end

# File ext/tk/lib/multi-tk.rb, line 3492
def self.transfer_stderr(dist, src = '')
  __getip.transfer_stderr(dist, src)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3472
def self.transfer_stdin(dist, src = '')
  __getip.transfer_stdin(dist, src)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3516
def self.transfer_stdio(dist, src = '')
  __getip.transfer_stdio(dist, src)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3482
def self.transfer_stdout(dist, src = '')
  __getip.transfer_stdout(dist, src)
  self
end

# File ext/tk/lib/multi-tk.rb, line 1189
def __create_safe_slave_obj(safe_opts, app_name, tk_opts)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?

  # safe interpreter
  ip_name = _create_slave_ip_name
  slave_ip = @interp.create_slave(ip_name, true)
  slave_ip.instance_eval{
    @force_default_encoding ||= TkUtil.untrust([false])
    @encoding ||= TkUtil.untrust([nil])
    def @encoding.to_s; self.join(nil); end
  }
  @slave_ip_tbl[ip_name] = slave_ip
  def slave_ip.safe_base?
    true
  end

  @interp._eval("::safe::interpInit #{ip_name}")

  slave_ip._invoke('set', 'argv0', app_name) if app_name.kind_of?(String)

  if tk_opts
    tk_opts = __check_safetk_optkeys(tk_opts)
    if tk_opts.key?('use')
      @slave_ip_top[ip_name] = ''
    else
      tk_opts, top_path = __create_safetk_frame(slave_ip, ip_name, app_name,
                                                tk_opts)
      @slave_ip_top[ip_name] = top_path
    end
    @interp._eval("::safe::loadTk #{ip_name} #{_keys2opts(tk_opts)}")
    @interp._invoke('__replace_slave_tk_commands__', ip_name)
  else
    @slave_ip_top[ip_name] = nil
  end

  if safe_opts.key?('deleteHook') || safe_opts.key?(:deleteHook)
    @interp._eval("::safe::interpConfigure #{ip_name} " +
                  _keys2opts(safe_opts))
  else
    @interp._eval("::safe::interpConfigure #{ip_name} " +
                  _keys2opts(safe_opts) + '-deleteHook {' +
                  TkComm._get_eval_string(proc{|slave|
                                            self._default_delete_hook(slave)
                                          }) + '}')
  end

  [slave_ip, ip_name]
end

# File ext/tk/lib/multi-tk.rb, line 1238
def __create_trusted_slave_obj(name, keys)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?

  ip_name = _create_slave_ip_name
  slave_ip = @interp.create_slave(ip_name, false)
  slave_ip.instance_eval{
    @force_default_encoding ||= TkUtil.untrust([false])
    @encoding ||= TkUtil.untrust([nil])
    def @encoding.to_s; self.join(nil); end
  }
  slave_ip._invoke('set', 'argv0', name) if name.kind_of?(String)
  slave_ip._invoke('set', 'argv', _keys2opts(keys))
  @interp._invoke('load', '', 'Tk', ip_name)
  @interp._invoke('__replace_slave_tk_commands__', ip_name)
  @slave_ip_tbl[ip_name] = slave_ip
  [slave_ip, ip_name]
end

# File ext/tk/lib/multi-tk.rb, line 3009
def __eval(str)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.__eval(str)
end

# File ext/tk/lib/multi-tk.rb, line 3014
def __invoke(*args)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.__invoke(*args)
end

# File ext/tk/lib/multi-tk.rb, line 2002
def __pseudo_toplevel
  ip = MultiTkIp.__getip
  (ip == @@DEFAULT_MASTER || ip == self) &&
    self.__pseudo_toplevel_evaluable? && @pseudo_toplevel[1]
end

# File ext/tk/lib/multi-tk.rb, line 2008
def __pseudo_toplevel=(m)
  unless (Thread.current.group == ThreadGroup::Default &&
            MultiTkIp.__getip == @@DEFAULT_MASTER)
    fail SecurityError, "no permission to manipulate"
  end

  # if m.kind_of?(Module) && m.respond_to?(:pseudo_toplevel_evaluable?)
  if m.respond_to?(:pseudo_toplevel_evaluable?)
    @pseudo_toplevel[0] = true
    @pseudo_toplevel[1] = m
  else
    fail ArgumentError, 'fail to set pseudo-toplevel'
  end
  self
end

# File ext/tk/lib/multi-tk.rb, line 2032
def __pseudo_toplevel_evaluable=(mode)
  unless (Thread.current.group == ThreadGroup::Default &&
            MultiTkIp.__getip == @@DEFAULT_MASTER)
    fail SecurityError, "no permission to manipulate"
  end

  @pseudo_toplevel[0] = (mode)? true: false
end

# File ext/tk/lib/multi-tk.rb, line 2024
def __pseudo_toplevel_evaluable?
  begin
    @pseudo_toplevel[0] && @pseudo_toplevel[1].pseudo_toplevel_evaluable?
  rescue Exception
    false
  end
end

# File ext/tk/lib/multi-tk.rb, line 1767
def _add_new_tables
  (@@TK_TABLE_LIST.size - @tk_table_list.size).times{
    @tk_table_list << TkUtil.untrust({})
  }
end

# File ext/tk/lib/multi-tk.rb, line 1777
def _add_tk_procs(name, args, body)
  return if slave?
  @interp._invoke('proc', name, args, body) if args && body
  @interp._invoke('interp', 'slaves').split.each{|slave|
    @interp._invoke('interp', 'alias', slave, name, '', name)
  }
end

# File ext/tk/lib/multi-tk.rb, line 2683
def _conv_listelement(arg)
  __getip._conv_listelement(arg)
end

# File ext/tk/lib/multi-tk.rb, line 2687
def _create_console
  __getip._create_console
end

# File ext/tk/lib/multi-tk.rb, line 1258
def _create_slave_object(keys={})
  raise SecurityError, "no permission to manipulate" unless self.manipulable?

  ip = MultiTkIp.new_slave(self, keys={})
  @slave_ip_tbl[ip.name] = ip
end

# File ext/tk/lib/multi-tk.rb, line 1483
def _default_delete_hook(slave)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @slave_ip_tbl.delete(slave)
  top = @slave_ip_top.delete(slave)
  if top.kind_of?(String)
    # call default hook of safetk.tcl (ignore exceptions)
    if top == ''
      begin
        @interp._eval("::safe::disallowTk #{slave}")
      rescue
        warn("Waring: fail to call '::safe::disallowTk'") if $DEBUG
      end
    else # toplevel path
      begin
        @interp._eval("::safe::tkDelete {} #{top} #{slave}")
      rescue
        warn("Waring: fail to call '::safe::tkDelete'") if $DEBUG
        begin
          @interp._eval("destroy #{top}")
        rescue
          warn("Waring: fail to destroy toplevel") if $DEBUG
        end
      end
    end
  end
end

# File ext/tk/lib/multi-tk.rb, line 350
  def _destroy_slaves_of_slaveIP(ip)
    unless ip.deleted?
      # ip._split_tklist(ip._invoke('interp', 'slaves')).each{|name|
      ip._split_tklist(ip._invoke_without_enc('interp', 'slaves')).each{|name|
        name = _fromUTF8(name)
        begin
          # ip._eval_without_enc("#{name} eval {foreach i [after info] {after cancel $i}}")
          after_ids = ip._eval_without_enc("#{name} eval {after info}")
          ip._eval_without_enc("#{name} eval {foreach i {#{after_ids}} {after cancel $i}}")
        rescue Exception
        end
        begin
          # ip._invoke('interp', 'eval', name, 'destroy', '.')
          ip._invoke(name, 'eval', 'destroy', '.')
        rescue Exception
        end

        # safe_base?
        if ip._eval_without_enc("catch {::safe::interpConfigure #{name}}") == '0'
          begin
            ip._eval_without_enc("::safe::interpDelete #{name}")
          rescue Exception
          end
        end
        if ip._invoke('interp', 'exists', name) == '1'
          begin
            ip._invoke(name, 'eval', 'exit')
          rescue Exception
          end
        end
        unless ip.deleted?
          if ip._invoke('interp', 'exists', name) == '1'
            begin
              ip._invoke('interp', 'delete', name)
            rescue Exception
            end
          end
        end
      }
    end
  end

# File ext/tk/lib/multi-tk.rb, line 2591
def _eval(str)
  __getip._eval(str)
end

# File ext/tk/lib/multi-tk.rb, line 2607
def _eval_with_enc(str)
  __getip._eval_with_enc(str)
end

# File ext/tk/lib/multi-tk.rb, line 2599
def _eval_without_enc(str)
  __getip._eval_without_enc(str)
end

# File ext/tk/lib/multi-tk.rb, line 2619
def _fromUTF8(str, encoding=nil)
  __getip._fromUTF8(str, encoding)
end

# File ext/tk/lib/multi-tk.rb, line 2654
def _get_global_var(var)
  __getip._get_global_var(var)
end

# File ext/tk/lib/multi-tk.rb, line 2657
def _get_global_var2(var, idx)
  __getip._get_global_var2(var, idx)
end

# File ext/tk/lib/multi-tk.rb, line 2635
def _get_variable(var, flag)
  __getip._get_variable(var, flag)
end

# File ext/tk/lib/multi-tk.rb, line 2638
def _get_variable2(var, idx, flag)
  __getip._get_variable2(var, idx, flag)
end

# File ext/tk/lib/multi-tk.rb, line 1773
def _init_ip_env(script)
  self.eval_proc{script.call(self)}
end

# File ext/tk/lib/multi-tk.rb, line 1801
def _init_ip_internal(init_ip_env, add_tk_procs)
  #init_ip_env.each{|script| self.eval_proc{script.call(self)}}
  init_ip_env.each{|script| self._init_ip_env(script)}
  add_tk_procs.each{|name, args, body|
    if master?
      @interp._invoke('proc', name, args, body) if args && body
    else
      @set_alias_proc.call(name)
    end
  }
end

# File ext/tk/lib/multi-tk.rb, line 2595
def _invoke(*args)
  __getip._invoke(*args)
end

# File ext/tk/lib/multi-tk.rb, line 2611
def _invoke_with_enc(*args)
  __getip._invoke_with_enc(*args)
end

# File ext/tk/lib/multi-tk.rb, line 2603
def _invoke_without_enc(*args)
  __getip._invoke_without_enc(*args)
end

# File ext/tk/lib/multi-tk.rb, line 1529
def _ip_id_
  # for RemoteTkIp
  ''
end

# File ext/tk/lib/multi-tk.rb, line 2673
def _make_menu_embeddable(menu_path)
  __getip._make_menu_embeddable(menu_path)
end

# File ext/tk/lib/multi-tk.rb, line 2680
def _merge_tklist(*args)
  __getip._merge_tklist(*args)
end

# File ext/tk/lib/multi-tk.rb, line 2137
def _proc_on_current_safelevel(cmd=nil, &blk) # require a block for eval
  safe = $SAFE
  cmd = _proc_on_safelevel(cmd, &blk)
  Proc.new{|*args| cmd.call(safe, *args)}
end

# File ext/tk/lib/multi-tk.rb, line 2106
def _proc_on_safelevel(cmd=nil) # require a block for eval
  if cmd
    if cmd.kind_of?(Method)
      _proc_on_safelevel{|*args| cmd.call(*args)}
    else
      _proc_on_safelevel(&cmd)
    end
  else
    #Proc.new{|safe, *args| $SAFE=safe if $SAFE < safe; yield(*args)}
    Proc.new{|safe, *args|
      # avoid security error on Exception objects
      untrust_proc = proc{|err|
        begin
          err.untrust if err.respond_to?(:untrust)
        rescue SecurityError
        end
        err
      }
      $SAFE=safe if $SAFE < safe;
      begin
        yield(*args)
      rescue Exception => e
        fail untrust_proc.call(e)
      end
    }
  end
end

# File ext/tk/lib/multi-tk.rb, line 600
def _receiver_mainloop(check_root)
  if @evloop_thread[0] && @evloop_thread[0].alive?
    @evloop_thread[0]
  else
    @evloop_thread[0] = Thread.new{
      while !@interp.deleted?
        #if check_root
        #  inf = @interp._invoke_without_enc('info', 'command', '.')
        #  break if !inf.kind_of?(String) || inf != '.'
        #end
        break if check_root && !@interp.has_mainwindow?
        sleep 0.5
      end
    }
    @evloop_thread[0]
  end
end

# File ext/tk/lib/multi-tk.rb, line 1785
def _remove_tk_procs(*names)
  return if slave?
  names.each{|name|
    name = name.to_s

    return if @interp.deleted?
    @interp._invoke('rename', name, '')

    return if @interp.deleted?
    @interp._invoke('interp', 'slaves').split.each{|slave|
      return if @interp.deleted?
      @interp._invoke('interp', 'alias', slave, name, '') rescue nil
    }
  }
end

# File ext/tk/lib/multi-tk.rb, line 2631
def _return_value
  __getip._return_value
end

# File ext/tk/lib/multi-tk.rb, line 2660
def _set_global_var(var, value)
  __getip._set_global_var(var, value)
end

# File ext/tk/lib/multi-tk.rb, line 2663
def _set_global_var2(var, idx, value)
  __getip._set_global_var2(var, idx, value)
end

# File ext/tk/lib/multi-tk.rb, line 2641
def _set_variable(var, value, flag)
  __getip._set_variable(var, value, flag)
end

# File ext/tk/lib/multi-tk.rb, line 2644
def _set_variable2(var, idx, value, flag)
  __getip._set_variable2(var, idx, value, flag)
end

# File ext/tk/lib/multi-tk.rb, line 2677
def _split_tklist(str)
  __getip._split_tklist(str)
end

# File ext/tk/lib/multi-tk.rb, line 2627
def _thread_tkwait(mode, target)
  __getip._thread_tkwait(mode, target)
end

# File ext/tk/lib/multi-tk.rb, line 2623
def _thread_vwait(var)
  __getip._thread_vwait(var)
end

# File ext/tk/lib/multi-tk.rb, line 1753
def _tk_cmd_tbl
  tbl = {}
  MultiTkIp.tk_cmd_tbl.each{|id, ent| tbl[id] = ent if ent.ip == self }
  tbl
end

# File ext/tk/lib/multi-tk.rb, line 1763
def _tk_table_list
  @tk_table_list
end

# File ext/tk/lib/multi-tk.rb, line 1759
def _tk_windows
  @tk_windows
end

# File ext/tk/lib/multi-tk.rb, line 2615
def _toUTF8(str, encoding=nil)
  __getip._toUTF8(str, encoding)
end

# File ext/tk/lib/multi-tk.rb, line 2666
def _unset_global_var(var)
  __getip._unset_global_var(var)
end

# File ext/tk/lib/multi-tk.rb, line 2669
def _unset_global_var2(var, idx)
  __getip._unset_global_var2(var, idx)
end

# File ext/tk/lib/multi-tk.rb, line 2647
def _unset_variable(var, flag)
  __getip._unset_variable(var, flag)
end

# File ext/tk/lib/multi-tk.rb, line 2650
def _unset_variable2(var, idx, flag)
  __getip._unset_variable2(var, idx, flag)
end

# File ext/tk/lib/multi-tk.rb, line 2568
def abort(msg = nil)
  __getip.abort(msg)
end

# File ext/tk/lib/multi-tk.rb, line 3197
def alias_delete(slave, cmd_name)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'alias', _slavearg(slave), cmd_name, '')
  self
end

# File ext/tk/lib/multi-tk.rb, line 3189
def alias_info(slave, cmd_name)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  _lst2ary(@interp._invoke('interp', 'alias', _slavearg(slave), cmd_name))
end

# File ext/tk/lib/multi-tk.rb, line 3429
def alias_target(aliascmd, slave = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'target', _slavearg(slave), aliascmd)
end

# File ext/tk/lib/multi-tk.rb, line 3218
def aliases(slave = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  _lst2ary(@interp._invoke('interp', 'aliases', _slavearg(slave)))
end

# File ext/tk/lib/multi-tk.rb, line 1685
def alive?
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  begin
    return false unless @cmd_receiver.alive?
    return false if @interp.deleted?
    return false if @interp._invoke('interp', 'exists', '') == '0'
  rescue Exception
    return false
  end
  true
end

# File ext/tk/lib/multi-tk.rb, line 2548
def allow_ruby_exit= (mode)
  __getip.allow_ruby_exit = mode
end

# File ext/tk/lib/multi-tk.rb, line 2544
def allow_ruby_exit?
  __getip.allow_ruby_exit?
end

# File ext/tk/lib/multi-tk.rb, line 2418
def bg_eval(*args, &blk)
  if block_given?
    bg_eval_proc(*args, &blk)
  elsif args[0]
    if args[0].respond_to?(:call)
      bg_eval_proc(*args)
    else
      bg_eval_string(*args)
    end
  else
    fail ArgumentError, "no argument to eval"
  end
end

# File ext/tk/lib/multi-tk.rb, line 2348
  def bg_eval_proc(*args)
    if block_given?
      cmd = Proc.new
    else
      unless (cmd = args.shift)
        fail ArgumentError, "A Proc or Method object is expected for 1st argument"
      end
    end
    Thread.new{
      eval_proc(cmd, *args)
      eval_proc_core(false,
                     proc{|safe, *params|
                       $SAFE=safe if $SAFE < safe
                       Thread.new(*params, &cmd).value
                     },
                     safe_level, *args)
    }
  end

# File ext/tk/lib/multi-tk.rb, line 2387
def bg_eval_string(cmd, *eval_args)
  # cmd string ==> proc
  unless cmd.kind_of?(String)
    raise RuntimeError, "A String object is expected for the 'cmd' argument"
  end
  Thread.new{
    eval_proc_core(true,
                   proc{|safe|
                     Kernel.eval("$SAFE=#{safe} if $SAFE < #{safe};" << cmd,
                                 *eval_args)
                   })
  }
end

# File ext/tk/lib/multi-tk.rb, line 199
def call(*args)
  unless @ip.deleted?
    current = Thread.current
    backup_ip = current[:callback_ip]
    current[:callback_ip] = @ip
    begin
      ret = @ip.cb_eval(@cmd, *args)
      fail ret if ret.kind_of?(Exception)
      ret
    rescue TkCallbackBreak, TkCallbackContinue => e
      fail e
    rescue SecurityError => e
      # in 'exit', 'exit!', and 'abort' : security error --> delete IP
      if e.backtrace[0] =~ /^(.+?):(\d+):in `(exit|exit!|abort)'/
        @ip.delete
      elsif @ip.safe?
        if @ip.respond_to?(:cb_error)
          @ip.cb_error(e)
        else
          nil # ignore
        end
      else
        fail e
      end
    rescue Exception => e
      fail e if e.message =~ /^TkCallback/

      if @ip.safe?
        if @ip.respond_to?(:cb_error)
          @ip.cb_error(e)
        else
          nil # ignore
        end
      else
        fail e
      end
    ensure
      current[:callback_ip] = backup_ip
    end
  end
end

# File ext/tk/lib/multi-tk.rb, line 308
def cb_error(e)
  if @cb_error_proc[0].respond_to?(:call)
    @cb_error_proc[0].call(e)
  end
end

# File ext/tk/lib/multi-tk.rb, line 1935
def cb_eval(cmd, *args)
  self.eval_callback(*args,
                     &_proc_on_safelevel{|*params|
                       TkComm._get_eval_string(TkUtil.eval_cmd(cmd, *params))
                     })
end

# File ext/tk/lib/multi-tk.rb, line 3207
def def_alias(slave, new_cmd, org_cmd, *args)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  ret = @interp._invoke('interp', 'alias', _slavearg(slave), new_cmd,
                        '', org_cmd, *args)
  (ret == new_cmd)? self: nil
end

# File ext/tk/lib/multi-tk.rb, line 3614
def default_encoding=(enc)
  __getip.default_encoding=(enc)
end

# File ext/tk/lib/multi-tk.rb, line 2552
def delete
  __getip.delete
end

# File ext/tk/lib/multi-tk.rb, line 3246
def delete_cmd(slave, cmd)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  slave_invoke = @interp._invoke('list', 'rename', cmd, '')
  @interp._invoke('interp', 'eval', _slavearg(slave), slave_invoke)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3226
def delete_slaves(*args)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  slaves = args.collect{|s| _slavearg(s)}
  @interp._invoke('interp', 'delete', *slaves) if slaves.size > 0
  self
end

# File ext/tk/lib/multi-tk.rb, line 2556
def deleted?
  __getip.deleted?
end

# File ext/tk/lib/multi-tk.rb, line 2491
def do_one_event(flag = TclTkLib::EventFlag::ALL)
  __getip.do_one_event(flag)
end

# File ext/tk/lib/multi-tk.rb, line 3618
def encoding=(enc)
  __getip.encoding=(enc)
end

# File ext/tk/lib/multi-tk.rb, line 3632
def encoding_convertfrom(str, enc=None)
  __getip.encoding_convertfrom(str, enc)
end

# File ext/tk/lib/multi-tk.rb, line 3637
def encoding_convertto(str, enc=None)
  __getip.encoding_convertto(str, enc)
end

# File ext/tk/lib/multi-tk.rb, line 3622
def encoding_name
  __getip.encoding_name
end

# File ext/tk/lib/multi-tk.rb, line 3626
def encoding_obj
  __getip.encoding_obj
end

# File ext/tk/lib/multi-tk.rb, line 3602
def encoding_table
  __getip.encoding_table
end

# File ext/tk/lib/multi-tk.rb, line 2404
def eval(*args, &blk)
  if block_given?
    eval_proc(*args, &blk)
  elsif args[0]
    if args[0].respond_to?(:call)
      eval_proc(*args)
    else
      eval_string(*args)
    end
  else
    fail ArgumentError, "no argument to eval"
  end
end

# File ext/tk/lib/multi-tk.rb, line 2242
def eval_callback(*args)
  if block_given?
    cmd = Proc.new
  else
    cmd = args.shift
  end
  begin
    if @@CALLBACK_SUBTHREAD.table[self].index(Thread.current)
      last_th = nil
    else
      last_th = @@CALLBACK_SUBTHREAD.table[self][-1]
    end
    @@CALLBACK_SUBTHREAD.new(self){
      @@CALLBACK_SUBTHREAD.table[self] << Thread.current
      begin
        last_th.join if last_th
        eval_proc_core(false, cmd, *args)
      rescue Exception=>e
        e
      ensure
        @@CALLBACK_SUBTHREAD.table[self].delete(Thread.current)
      end
    }
  end
end

# File ext/tk/lib/multi-tk.rb, line 2283
def eval_proc(*args, &blk)
  if block_given?
    cmd = _proc_on_safelevel(&blk)
  else
    unless (cmd = args.shift)
      fail ArgumentError, "A Proc or Method object is expected for 1st argument"
    end
    cmd = _proc_on_safelevel(&cmd)
  end
  if TclTkLib.mainloop_thread? == true
    # call from eventloop
    current = Thread.current
    backup_ip = current[:callback_ip]
    current[:callback_ip] = self
    begin
      eval_proc_core(false, cmd, *args)
    ensure
      current[:callback_ip] = backup_ip
    end
  else
    eval_proc_core(true,
                   proc{|safe, *params|
                     Thread.new{cmd.call(safe, *params)}.value
                   },
                   *args)
  end
end

# File ext/tk/lib/multi-tk.rb, line 2373
def eval_string(cmd, *eval_args)
  # cmd string ==> proc
  unless cmd.kind_of?(String)
    raise RuntimeError, "A String object is expected for the 'cmd' argument"
  end

  eval_proc_core(true,
                 proc{|safe|
                   Kernel.eval("$SAFE=#{safe} if $SAFE < #{safe};" << cmd,
                               *eval_args)
                 })
end

# File ext/tk/lib/multi-tk.rb, line 3237
def exist?(slave = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  ret = @interp._invoke('interp', 'exists', _slavearg(slave))
  (ret == '1')? true: false
end

# File ext/tk/lib/multi-tk.rb, line 2572
def exit(st = true)
  __getip.exit(st)
end

# File ext/tk/lib/multi-tk.rb, line 2576
def exit!(st = false)
  __getip.exit!(st)
end

# File ext/tk/lib/multi-tk.rb, line 3257
def expose_cmd(slave, cmd, aliasname = nil)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  if aliasname
    @interp._invoke('interp', 'expose', _slavearg(slave), cmd, aliasname)
  else
    @interp._invoke('interp', 'expose', _slavearg(slave), cmd)
  end
  self
end

# File ext/tk/lib/multi-tk.rb, line 3606
def force_default_encoding=(mode)
  __getip.force_default_encoding=(mode)
end

# File ext/tk/lib/multi-tk.rb, line 3610
def force_default_encoding?
  __getip.force_default_encoding?
end

# File ext/tk/lib/multi-tk.rb, line 3379
def get_bgerror_handler(slave = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  procedure(@interp._invoke('interp', 'bgerror', _slavearg(slave)))
end

# File ext/tk/lib/multi-tk.rb, line 2505
def get_eventloop_tick
  __getip.get_eventloop_tick
end

# File ext/tk/lib/multi-tk.rb, line 2517
def get_eventloop_weight
  __getip.get_eventloop_weight
end

# File ext/tk/lib/multi-tk.rb, line 3395
def get_limit(limit_type, slave = '', slot = nil)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?

  if slot
    num_or_str(@interp._invoke('interp', 'limit', _slavearg(slave),
                               limit_type, slot))
  else
    l = @interp._split_tklist(@interp._invoke_without_enc('interp', 'limit',
                                                          _slavearg(slave),
                                                          limit_type))
    l.map!{|s| _fromUTF8(s)}
    r = {}
    until l.empty?
      key = l.shift[1..-1]
      val = l.shift
      val = num_or_str(val) if val
      r[key] = val
    end
    r
  end
end

# File ext/tk/lib/multi-tk.rb, line 2511
def get_no_event_wait
  __getip.get_no_event_wait
end

# File ext/tk/lib/multi-tk.rb, line 2560
def has_mainwindow?
  __getip.has_mainwindow?
end

# File ext/tk/lib/multi-tk.rb, line 3285
def hidden_cmds(slave = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  _lst2ary(@interp._invoke('interp', 'hidden', _slavearg(slave)))
end

# File ext/tk/lib/multi-tk.rb, line 3271
def hide_cmd(slave, cmd, aliasname = nil)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  if aliasname
    @interp._invoke('interp', 'hide', _slavearg(slave), cmd, aliasname)
  else
    @interp._invoke('interp', 'hide', _slavearg(slave), cmd)
  end
  self
end

# File ext/tk/lib/multi-tk.rb, line 196
def inspect
  cmd.inspect
end

# File ext/tk/lib/multi-tk.rb, line 2564
def invalid_namespace?
  __getip.invalid_namespace?
end

# File ext/tk/lib/multi-tk.rb, line 3293
def invoke_hidden(slave, cmd, *args)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  if args[-1].kind_of?(Hash)
    keys = _symbolkey2str(args.pop)
  else
    keys = []
  end
  keys << _slavearg(slave)
  if Tk::TCL_MAJOR_VERSION > 8 ||
      (Tk::TCL_MAJOR_VERSION == 8 && Tk::TCL_MINOR_VERSION >= 5)
    keys << '--'
  end
  keys << cmd
  keys.concat(args)
  @interp._invoke('interp', 'invokehidden', *keys)
end

# File ext/tk/lib/multi-tk.rb, line 3313
def invoke_hidden_on_global(slave, cmd, *args)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  if args[-1].kind_of?(Hash)
    keys = _symbolkey2str(args.pop)
  else
    keys = []
  end
  keys << _slavearg(slave)
  keys << '-global'
  if Tk::TCL_MAJOR_VERSION > 8 ||
      (Tk::TCL_MAJOR_VERSION == 8 && Tk::TCL_MINOR_VERSION >= 5)
    keys << '--'
  end
  keys << cmd
  keys.concat(args)
  @interp._invoke('interp', 'invokehidden', *keys)
end

# File ext/tk/lib/multi-tk.rb, line 3334
def invoke_hidden_on_namespace(slave, ns, cmd, *args)
  # for Tcl8.5 or later
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  if args[-1].kind_of?(Hash)
    keys = _symbolkey2str(args.pop)
  else
    keys = []
  end
  keys << _slavearg(slave)
  keys << '-namespace' << TkComm._get_eval_string(ns)
  keys << '--' << cmd
  keys.concat(args)
  @interp._invoke('interp', 'invokehidden', *keys)
end

# File ext/tk/lib/multi-tk.rb, line 1706
def ip_name
  @ip_name || ''
end

# File ext/tk/lib/multi-tk.rb, line 2485
def mainloop(check_root = true)
  __getip.mainloop(check_root)
end

# File ext/tk/lib/multi-tk.rb, line 2494
def mainloop_abort_on_exception
  # __getip.mainloop_abort_on_exception
  TclTkLib.mainloop_abort_on_exception
end

# File ext/tk/lib/multi-tk.rb, line 2498
def mainloop_abort_on_exception=(mode)
  # __getip.mainloop_abort_on_exception=(mode)
  TclTkLib.mainloop_abort_on_exception=(mode)
end

# File ext/tk/lib/multi-tk.rb, line 2488
def mainloop_watchdog(check_root = true)
  __getip.mainloop_watchdog(check_root)
end

# File ext/tk/lib/multi-tk.rb, line 2528
def make_safe
  __getip.make_safe
end

# File ext/tk/lib/multi-tk.rb, line 1735
def manipulable?
  return true if (Thread.current.group == ThreadGroup::Default)
  ip = MultiTkIp.__getip
  (ip == self) || ip._is_master_of?(@interp)
end

# File ext/tk/lib/multi-tk.rb, line 3352
def mark_trusted(slave = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'marktrusted', _slavearg(slave))
  self
end

# File ext/tk/lib/multi-tk.rb, line 1667
def master?
  if @ip_name
    false
  else
    true
  end
end

# File ext/tk/lib/multi-tk.rb, line 2524
def method_missing(id, *args)
  __getip.__send__(id, *args)
end

# File ext/tk/lib/multi-tk.rb, line 92
def mutex; @mutex; end

# File ext/tk/lib/multi-tk.rb, line 1561
def new_master(safe=nil, keys={}, &blk)
  if MultiTkIp::WITH_RUBY_VM
    #### TODO !!!!!!
    fail RuntimeError,
         'sorry, still not support multiple master-interpreters on RubyVM'
  end

  if safe.kind_of?(Hash)
    keys = safe
  elsif safe.kind_of?(Integer)
    raise ArgumentError, "unexpected argument(s)" unless keys.kind_of?(Hash)
    if !keys.key?(:safe) && !keys.key?('safe')
      keys[:safe] = safe
    end
  elsif safe == nil
    # do nothing
  else
    raise ArgumentError, "unexpected argument(s)"
  end

  ip = __new(__getip, nil, keys)
  #ip.eval_proc(proc{$SAFE=ip.safe_level; Proc.new}.call) if block_given?
  if block_given?
    #Thread.new{ip.eval_proc(proc{$SAFE=ip.safe_level; Proc.new}.call)}
    #Thread.new{ip.eval_proc(proc{$SAFE=ip.safe_level; yield}.call)}
    ip._proc_on_safelevel(&blk).call(ip.safe_level)
  end
  ip
end

# File ext/tk/lib/multi-tk.rb, line 1618
def new_safe_slave(safe=4, keys={}, &blk)
  if safe.kind_of?(Hash)
    keys = safe
  elsif safe.kind_of?(Integer)
    raise ArgumentError, "unexpected argument(s)" unless keys.kind_of?(Hash)
    if !keys.key?(:safe) && !keys.key?('safe')
      keys[:safe] = safe
    end
  else
    raise ArgumentError, "unexpected argument(s)"
  end

  ip = __new(__getip, true, keys)
  # ip.eval_proc(proc{$SAFE=ip.safe_level; Proc.new}.call) if block_given?
  if block_given?
    #Thread.new{ip.eval_proc(proc{$SAFE=ip.safe_level; Proc.new}.call)}
    #Thread.new{ip.eval_proc(proc{$SAFE=ip.safe_level; yield}.call)}
    ip._proc_on_safelevel(&blk).call(ip.safe_level)
  end
  ip
end

# File ext/tk/lib/multi-tk.rb, line 1593
def new_slave(safe=nil, keys={}, &blk)
  if safe.kind_of?(Hash)
    keys = safe
  elsif safe.kind_of?(Integer)
    raise ArgumentError, "unexpected argument(s)" unless keys.kind_of?(Hash)
    if !keys.key?(:safe) && !keys.key?('safe')
      keys[:safe] = safe
    end
  elsif safe == nil
    # do nothing
  else
    raise ArgumentError, "unexpected argument(s)"
  end

  ip = __new(__getip, false, keys)
  # ip.eval_proc(proc{$SAFE=ip.safe_level; Proc.new}.call) if block_given?
  if block_given?
    #Thread.new{ip.eval_proc(proc{$SAFE=ip.safe_level; Proc.new}.call)}
    #Thread.new{ip.eval_proc(proc{$SAFE=ip.safe_level; yield}.call)}
    ip._proc_on_safelevel(&blk).call(ip.safe_level)
  end
  ip
end

# File ext/tk/lib/multi-tk.rb, line 1700
def path
  @ip_name || ''
end

# File ext/tk/lib/multi-tk.rb, line 3420
def recursion_limit(slave = '', limit = None)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  number(@interp._invoke('interp', 'recursionlimit',
                         _slavearg(slave), limit))
end

# File ext/tk/lib/multi-tk.rb, line 2580
def restart(app_name = nil, keys = {})
  init_ip_internal

  __getip._invoke('set', 'argv0', app_name) if app_name
  if keys.kind_of?(Hash)
    __getip._invoke('set', 'argv', _keys2opts(keys))
  end

  __getip.restart
end

# File ext/tk/lib/multi-tk.rb, line 346
def running_mainloop?
  @wait_on_mainloop[1] > 0
end

# File ext/tk/lib/multi-tk.rb, line 2532
def safe?
  __getip.safe?
end

# File ext/tk/lib/multi-tk.rb, line 2536
def safe_base?
  begin
    __getip.safe_base?
  rescue
    false
  end
end

# File ext/tk/lib/multi-tk.rb, line 332
def safe_level
  @safe_level[0]
end

# File ext/tk/lib/multi-tk.rb, line 323
def safe_level=(safe)
  set_safe_level(safe)
end

# File ext/tk/lib/multi-tk.rb, line 3583
def safeip_add_to_access_path(dir)
  ip = MultiTkIp.__getip
  ip._eval("::safe::interpAddToAccessPath #{@ip_name} #{dir}")
end

# File ext/tk/lib/multi-tk.rb, line 3538
  def safeip_configinfo(slot = nil)
    ip = MultiTkIp.__getip
    ret = {}
    if slot
      conf = _lst2ary(ip._eval("::safe::interpConfigure " +
                               @ip_name + " -#{slot}"))
      if conf[0] == '-deleteHook'
        if conf[1] =~ /^rb_out\S* (c(_\d+_)?\d+)/
          ret[conf[0][1..-1]] = MultiTkIp._tk_cmd_tbl[$1]
        if conf[1] =~ /rb_out\S*(?:\s+(::\S*|[{](::.*)[}]|["](::.*)["]))? (c(_\d+_)?(\d+))/
          ret[conf[0][1..-1]] = MultiTkIp._tk_cmd_tbl[$4]
        else
          ret[conf[0][1..-1]] = conf[1]
        end
      else
        ret[conf[0][1..-1]] = conf[1]
      end
    else
      Hash[*_lst2ary(ip._eval("::safe::interpConfigure " +
                              @ip_name))].each{|k, v|
        if k == '-deleteHook'
          if v =~ /^rb_out\S* (c(_\d+_)?\d+)/
            ret[k[1..-1]] = MultiTkIp._tk_cmd_tbl[$1]
          if v =~ /rb_out\S*(?:\s+(::\S*|[{](::.*)[}]|["](::.*)["]))? (c(_\d+_)?(\d+))/
            ret[k[1..-1]] = MultiTkIp._tk_cmd_tbl[$4]
          else
            ret[k[1..-1]] = v
          end
        else
          ret[k[1..-1]] = v
        end
      }
    end
    ret
  end

# File ext/tk/lib/multi-tk.rb, line 3525
def safeip_configure(slot, value=None)
  # use for '-noStatics' option ==> {statics=>false}
  #     for '-nestedLoadOk' option ==> {nested=>true}
  if slot.kind_of?(Hash)
    ip = MultiTkIp.__getip
    ip._eval('::safe::interpConfigure ' + @ip_name + ' ' + _keys2opts(slot))
  else
    ip._eval('::safe::interpConfigure ' + @ip_name + ' ' +
             "-#{slot} #{_get_eval_string(value)}")
  end
  self
end

# File ext/tk/lib/multi-tk.rb, line 3578
def safeip_delete
  ip = MultiTkIp.__getip
  ip._eval("::safe::interpDelete " + @ip_name)
end

# File ext/tk/lib/multi-tk.rb, line 3588
def safeip_find_in_access_path(dir)
  ip = MultiTkIp.__getip
  ip._eval("::safe::interpFindInAccessPath #{@ip_name} #{dir}")
end

# File ext/tk/lib/multi-tk.rb, line 3593
def safeip_set_log_cmd(cmd = Proc.new)
  ip = MultiTkIp.__getip
  ip._eval("::safe::setLogCmd #{@ip_name} #{_get_eval_string(cmd)}")
end

# File ext/tk/lib/multi-tk.rb, line 3362
def set_bgerror_handler(cmd = Proc.new, slave = nil, &b)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?

  unless TkComm._callback_entry?(cmd)
    if !slave && b
      slave = cmd
      cmd = Proc.new(&b)
    end
  end
  slave = '' unless slave

  @interp._invoke('interp', 'bgerror', _slavearg(slave), cmd)
end

# File ext/tk/lib/multi-tk.rb, line 304
def set_cb_error(cmd = Proc.new)
  @cb_error_proc[0] = cmd
end

# File ext/tk/lib/multi-tk.rb, line 2502
def set_eventloop_tick(tick)
  __getip.set_eventloop_tick(tick)
end

# File ext/tk/lib/multi-tk.rb, line 2514
def set_eventloop_weight(loop_max, no_event_tick)
  __getip.set_eventloop_weight(loop_max, no_event_tick)
end

# File ext/tk/lib/multi-tk.rb, line 3387
def set_limit(limit_type, slave = '', opts = {})
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'limit', _slavearg(slave), limit_type, opts)
end

# File ext/tk/lib/multi-tk.rb, line 2508
def set_no_event_wait(tick)
  __getip.set_no_event_wait(tick)
end

# File ext/tk/lib/multi-tk.rb, line 316
def set_safe_level(safe)
  if safe > @safe_level[0]
    @safe_level[0] = safe
    @cmd_queue.enq([@system, 'set_safe_level', safe])
  end
  @safe_level[0]
end

# File ext/tk/lib/multi-tk.rb, line 3457
def share_stderr(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'share', src, 'stderr', dist)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3437
def share_stdin(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'share', src, 'stdin', dist)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3497
def share_stdio(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'share', src, 'stdin',  dist)
  @interp._invoke('interp', 'share', src, 'stdout', dist)
  @interp._invoke('interp', 'share', src, 'stderr', dist)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3447
def share_stdout(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'share', src, 'stdout', dist)
  self
end

# File ext/tk/lib/multi-tk.rb, line 1678
def slave?
  not master?
end

# File ext/tk/lib/multi-tk.rb, line 1719
def slaves(all = false)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp','slaves').split.map!{|name|
    if @slave_ip_tbl.key?(name)
      @slave_ip_tbl[name]
    elsif all
      name
    else
      nil
    end
  }.compact!
end

# File ext/tk/lib/multi-tk.rb, line 1712
def to_eval
  @ip_name || ''
end

# File ext/tk/lib/multi-tk.rb, line 3487
def transfer_stderr(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'transfer', src, 'stderr', dist)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3467
def transfer_stdin(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'transfer', src, 'stdin', dist)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3509
def transfer_stdio(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'transfer', src, 'stdin',  dist)
  @interp._invoke('interp', 'transfer', src, 'stdout', dist)
  @interp._invoke('interp', 'transfer', src, 'stderr', dist)
  self
end

# File ext/tk/lib/multi-tk.rb, line 3477
def transfer_stdout(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'transfer', src, 'stdout', dist)
  self
end

# File ext/tk/lib/multi-tk.rb, line 342
def wait_on_mainloop=(bool)
  @wait_on_mainloop[0] = bool
end

# File ext/tk/lib/multi-tk.rb, line 339
def wait_on_mainloop?
  @wait_on_mainloop[0]
end

# File ext/tk/lib/multi-tk.rb, line 1744
def _is_master_of?(tcltkip_obj)
  tcltkip_obj.slave_of?(@interp)
end