Class: MultiTkIp

Inherits:

Object

Object
MultiTkIp

show all

Defined in:: lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/remote-tk.rb,
lib/remote-tk.rb

Overview

check Ruby 1.9 !!!!!!!

Direct Known Subclasses

RemoteTkIp

Constant Summary collapse

BASE_DIR =

File.dirname(__FILE__)

WITH_RUBY_VM =

Object.const_defined?(:VM) && ::VM.class == Class

WITH_ENCODING =

Object.const_defined?(:Encoding) && ::Encoding.class == Class

RUN_EVENTLOOP_ON_MAIN_THREAD = Ruby 1.9 !!!!!!!!!!!!!!!!!!!!!!!!!!

false

INTERP_THREAD =

@@DEFAULT_MASTER.instance_variable_get('@interp_thread')

INTERP_MUTEX =

INTERP_ROOT_CHECK =

@@IP_TABLE =

{}.taint

@@INIT_IP_ENV = table of Procs

[].taint

@@ADD_TK_PROCS = table of [name, args, body]

[].taint

@@TK_TABLE_LIST =

[].taint

@@TK_CMD_TBL =

Object.new.taint

@@CB_ENTRY_CLASS =

Class.new(TkCallbackEntry){
  def initialize(ip, cmd)
    @ip = ip
    @cmd = cmd
    self.freeze
  end
  attr_reader :ip, :cmd
  def inspect
    cmd.inspect
  end
  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
}.freeze

@@DEFAULT_MASTER =

self.allocate

@@SAFE_OPT_LIST =

[
  'accessPath'.freeze, 
  'statics'.freeze, 
  'nested'.freeze, 
  'deleteHook'.freeze
].freeze

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(master, safeip = true, keys = {}) ⇒ `MultiTkIp`

Returns a new instance of MultiTkIp.

# File 'lib/multi-tk.rb', line 1220

def initialize(master, safeip=true, keys={})
  if $SAFE >= 4
    fail SecurityError, "cannot create a new interpreter at level #{$SAFE}"
  end

  if safeip == nil && $SAFE >= 2
    fail SecurityError, "cannot create a master-ip at level #{$SAFE}"
  end

  if master.deleted? && safeip == nil
    fail RuntimeError, "cannot create a slave of a deleted interpreter"
  end

  if !master.deleted? && !master.master? && master.safe?
    fail SecurityError, "safe-slave-ip cannot create a new interpreter"
  end

  if safeip == nil && !master.master?
    fail SecurityError, "slave-ip cannot create a master-ip"
  end

  unless keys.kind_of? Hash
    fail ArgumentError, "expecting a Hash object for the 2nd argument"
  end

  @tk_windows = {}
  @tk_table_list = []
  @slave_ip_tbl = {}
  @slave_ip_top = {}
  @cb_error_proc = []
  @evloop_thread = []

  @tk_windows.taint unless @tk_windows.tainted?
  @tk_table_list.taint unless @tk_table_list.tainted?
  @slave_ip_tbl.taint unless @slave_ip_tbl.tainted?
  @slave_ip_top.taint unless @slave_ip_top.tainted?
  @cb_error_proc.taint unless @cb_error_proc.tainted?
  @evloop_thread.taint unless @evloop_thread.tainted?

  @callback_status = []

  name, safe, safe_opts, tk_opts = _parse_slaveopts(keys)

  safe = 4 if safe && !safe.kind_of?(Fixnum)

  @safe_base = false

  if safeip == nil
    # create master-ip
    unless WITH_RUBY_VM
      @interp = TclTkIp.new(name, _keys2opts(tk_opts))
    else ### Ruby 1.9 !!!!!!!!!!!
      @interp_thread = Thread.new{
        Thread.current[:interp] = interp = TclTkIp.new(name, _keys2opts(tk_opts))
        #sleep
        TclTkLib.mainloop(true)
      }
      until @interp_thread[:interp]
        Thread.pass
      end
      # INTERP_THREAD.run
      @interp = @interp_thread[:interp]
    end

    @ip_name = nil
    if safe
      safe = $SAFE if safe < $SAFE
      @safe_level = [safe]
    else
      @safe_level = [$SAFE]
    end
  else
    # create slave-ip
    if safeip || master.safe?
      @safe_base = true
      @interp, @ip_name = master.__create_safe_slave_obj(safe_opts, 
                                                         name, tk_opts)
      # @interp_thread = nil if RUBY_VERSION < '1.9.0' ### !!!!!!!!!!!
      @interp_thread = nil unless WITH_RUBY_VM  ### Ruby 1.9 !!!!!!!!!!!
      if safe
        safe = master.safe_level if safe < master.safe_level
        @safe_level = [safe]
      else
        @safe_level = [4]
      end
    else
      @interp, @ip_name = master.__create_trusted_slave_obj(name, tk_opts)
      # @interp_thread = nil if RUBY_VERSION < '1.9.0' ### !!!!!!!!!!!
      @interp_thread = nil unless WITH_RUBY_VM  ### Ruby 1.9 !!!!!!!!!!!
      if safe
        safe = master.safe_level if safe < master.safe_level
        @safe_level = [safe]
      else
        @safe_level = [master.safe_level]
      end
    end
    @set_alias_proc = proc{|name| 
      master._invoke('interp', 'alias', @ip_name, name, '', name)
    }.freeze
  end

  @system = Object.new

  @wait_on_mainloop = [true, 0].taint
  # @wait_on_mainloop = [false, 0].taint

  @threadgroup  = ThreadGroup.new

  @pseudo_toplevel = [false, nil]

  @cmd_queue = Queue.new

=begin
  @cmd_receiver, @receiver_watchdog = _create_receiver_and_watchdog(@safe_level[0])

  @threadgroup.add @cmd_receiver
  @threadgroup.add @receiver_watchdog

  @threadgroup.enclose
=end
  @@DEFAULT_MASTER.assign_receiver_and_watchdog(self)

  @@IP_TABLE[@threadgroup] = self
  @@TK_TABLE_LIST.size.times{ 
    (tbl = {}).tainted? || tbl.taint
    @tk_table_list << tbl
  }
  _init_ip_internal(@@INIT_IP_ENV, @@ADD_TK_PROCS)

  class << self
    undef :instance_eval
  end

  # dummy call for initialization
  self.eval_proc{ Tk.tk_call('set', 'tcl_patchLevel') }

  self.freeze  # defend against modification
end

Class Method Details

.__getip ⇒ `Object`

# File 'lib/multi-tk.rb', line 1401

def self.__getip
  current = Thread.current
  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

._conv_listelement(arg) ⇒ `Object`



2371
2372
2373

# File 'lib/multi-tk.rb', line 2371

def _conv_listelement(arg)
  __getip._conv_listelement(arg)
end

._create_console ⇒ `Object`



2375
2376
2377

# File 'lib/multi-tk.rb', line 2375

def _create_console
  __getip._create_console
end

._DEFAULT_MASTER ⇒ `Object`

# File 'lib/remote-tk.rb', line 19

def self._DEFAULT_MASTER
  # work only once
  if @flag
    @flag = nil
    @@DEFAULT_MASTER
  else
    nil
  end
end

._eval(str) ⇒ `Object`



2279
2280
2281

# File 'lib/multi-tk.rb', line 2279

def _eval(str)
  __getip._eval(str)
end

._eval_with_enc(str) ⇒ `Object`



2295
2296
2297

# File 'lib/multi-tk.rb', line 2295

def _eval_with_enc(str)
  __getip._eval_with_enc(str)
end

._eval_without_enc(str) ⇒ `Object`



2287
2288
2289

# File 'lib/multi-tk.rb', line 2287

def _eval_without_enc(str)
  __getip._eval_without_enc(str)
end

._fromUTF8(str, encoding = nil) ⇒ `Object`



2307
2308
2309

# File 'lib/multi-tk.rb', line 2307

def _fromUTF8(str, encoding=nil)
  __getip._fromUTF8(str, encoding)
end

._get_global_var(var) ⇒ `Object`



2342
2343
2344

# File 'lib/multi-tk.rb', line 2342

def _get_global_var(var)
  __getip._get_global_var(var)
end

._get_global_var2(var, idx) ⇒ `Object`



2345
2346
2347

# File 'lib/multi-tk.rb', line 2345

def _get_global_var2(var, idx)
  __getip._get_global_var2(var, idx)
end

._get_variable(var, flag) ⇒ `Object`



2323
2324
2325

# File 'lib/multi-tk.rb', line 2323

def _get_variable(var, flag)
  __getip._get_variable(var, flag)
end

._get_variable2(var, idx, flag) ⇒ `Object`



2326
2327
2328

# File 'lib/multi-tk.rb', line 2326

def _get_variable2(var, idx, flag)
  __getip._get_variable2(var, idx, flag)
end

._invoke(*args) ⇒ `Object`



2283
2284
2285

# File 'lib/multi-tk.rb', line 2283

def _invoke(*args)
  __getip._invoke(*args)
end

._invoke_with_enc(*args) ⇒ `Object`



2299
2300
2301

# File 'lib/multi-tk.rb', line 2299

def _invoke_with_enc(*args)
  __getip._invoke_with_enc(*args)
end

._invoke_without_enc(*args) ⇒ `Object`



2291
2292
2293

# File 'lib/multi-tk.rb', line 2291

def _invoke_without_enc(*args)
  __getip._invoke_without_enc(*args)
end

._ip_id_ ⇒ `Object`



1393
1394
1395

# File 'lib/multi-tk.rb', line 1393

def self._ip_id_
  __getip._ip_id_
end

._IP_TABLE ⇒ `Object`

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

._make_menu_embeddable(menu_path) ⇒ `Object`



2361
2362
2363

# File 'lib/multi-tk.rb', line 2361

def _make_menu_embeddable(menu_path)
  __getip._make_menu_embeddable(menu_path)
end

._merge_tklist(*args) ⇒ `Object`



2368
2369
2370

# File 'lib/multi-tk.rb', line 2368

def _merge_tklist(*args)
  __getip._merge_tklist(*args)
end

._return_value ⇒ `Object`



2319
2320
2321

# File 'lib/multi-tk.rb', line 2319

def _return_value
  __getip._return_value
end

._set_global_var(var, value) ⇒ `Object`



2348
2349
2350

# File 'lib/multi-tk.rb', line 2348

def _set_global_var(var, value)
  __getip._set_global_var(var, value)
end

._set_global_var2(var, idx, value) ⇒ `Object`



2351
2352
2353

# File 'lib/multi-tk.rb', line 2351

def _set_global_var2(var, idx, value)
  __getip._set_global_var2(var, idx, value)
end

._set_variable(var, value, flag) ⇒ `Object`



2329
2330
2331

# File 'lib/multi-tk.rb', line 2329

def _set_variable(var, value, flag)
  __getip._set_variable(var, value, flag)
end

._set_variable2(var, idx, value, flag) ⇒ `Object`



2332
2333
2334

# File 'lib/multi-tk.rb', line 2332

def _set_variable2(var, idx, value, flag)
  __getip._set_variable2(var, idx, value, flag)
end

._split_tklist(str) ⇒ `Object`



2365
2366
2367

# File 'lib/multi-tk.rb', line 2365

def _split_tklist(str)
  __getip._split_tklist(str)
end

._thread_tkwait(mode, target) ⇒ `Object`



2315
2316
2317

# File 'lib/multi-tk.rb', line 2315

def _thread_tkwait(mode, target)
  __getip._thread_tkwait(mode, target)
end

._thread_vwait(var) ⇒ `Object`



2311
2312
2313

# File 'lib/multi-tk.rb', line 2311

def _thread_vwait(var)
  __getip._thread_vwait(var)
end

._TK_TABLE_LIST ⇒ `Object`

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

._toUTF8(str, encoding = nil) ⇒ `Object`



2303
2304
2305

# File 'lib/multi-tk.rb', line 2303

def _toUTF8(str, encoding=nil)
  __getip._toUTF8(str, encoding)
end

._unset_global_var(var) ⇒ `Object`



2354
2355
2356

# File 'lib/multi-tk.rb', line 2354

def _unset_global_var(var)
  __getip._unset_global_var(var)
end

._unset_global_var2(var, idx) ⇒ `Object`



2357
2358
2359

# File 'lib/multi-tk.rb', line 2357

def _unset_global_var2(var, idx)
  __getip._unset_global_var2(var, idx)
end

._unset_variable(var, flag) ⇒ `Object`



2335
2336
2337

# File 'lib/multi-tk.rb', line 2335

def _unset_variable(var, flag)
  __getip._unset_variable(var, flag)
end

._unset_variable2(var, idx, flag) ⇒ `Object`



2338
2339
2340

# File 'lib/multi-tk.rb', line 2338

def _unset_variable2(var, idx, flag)
  __getip._unset_variable2(var, idx, flag)
end

.abort(msg = nil) ⇒ `Object`



2256
2257
2258

# File 'lib/multi-tk.rb', line 2256

def abort(msg = nil)
  __getip.abort(msg)
end

.add_tk_procs(name, args = nil, body = nil) ⇒ `Object`

# File 'lib/multi-tk.rb', line 1742

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

.alias_delete(slave, cmd_name) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2889

def self.alias_delete(slave, cmd_name)
  __getip.alias_delete(slave, cmd_name)
  self
end

.alias_info(slave, cmd_name) ⇒ `Object`



2880
2881
2882

# File 'lib/multi-tk.rb', line 2880

def self.alias_info(slave, cmd_name)
  __getip.alias_info(slave, cmd_name)
end

.alias_target(aliascmd, slave = '') ⇒ `Object`



3120
3121
3122

# File 'lib/multi-tk.rb', line 3120

def self.alias_target(aliascmd, slave = '')
  __getip.alias_target(aliascmd, slave)
end

.aliases(slave = '') ⇒ `Object`



2909
2910
2911

# File 'lib/multi-tk.rb', line 2909

def self.aliases(slave = '')
  __getip.aliases(slave)
end

.alive? ⇒ `Boolean`

Returns:

(Boolean)



1554
1555
1556

# File 'lib/multi-tk.rb', line 1554

def self.alive?
  __getip.alive?
end

.allow_ruby_exit=(mode) ⇒ `Object`



2236
2237
2238

# File 'lib/multi-tk.rb', line 2236

def allow_ruby_exit= (mode)
  __getip.allow_ruby_exit = mode
end

.allow_ruby_exit? ⇒ `Boolean`

Returns:

(Boolean)



2232
2233
2234

# File 'lib/multi-tk.rb', line 2232

def allow_ruby_exit?
  __getip.allow_ruby_exit?
end

.bg_eval(*args, &blk) ⇒ `Object` Also known as: background_eval

# File 'lib/multi-tk.rb', line 2162

def bg_eval(*args, &blk)
  # class ==> interp object
  __getip.bg_eval(*args, &blk)
end

.bg_eval_proc(*args, &blk) ⇒ `Object` Also known as: background_eval_proc, thread_eval_proc, bg_call, background_call

# File 'lib/multi-tk.rb', line 2135

def bg_eval_proc(*args, &blk)
  # class ==> interp object
  __getip.bg_eval_proc(*args, &blk)
end

.bg_eval_string(cmd, *eval_args) ⇒ `Object` Also known as: background_eval_string, bg_eval_str, background_eval_str

# File 'lib/multi-tk.rb', line 2150

def bg_eval_string(cmd, *eval_args)
  # class ==> interp object
  __getip.bg_eval_string(cmd, *eval_args)
end

.bgerror(slave = '') ⇒ `Object`



3062
3063
3064

# File 'lib/multi-tk.rb', line 3062

def self.bgerror(cmd = Proc.new, slave = nil, &b)
  __getip.bgerror(cmd, slave, &b)
end

.cb_entry_class ⇒ `Object`



1774
1775
1776

# File 'lib/multi-tk.rb', line 1774

def self.cb_entry_class
  @@CB_ENTRY_CLASS
end

.create_table ⇒ `Object`

# File 'lib/multi-tk.rb', line 1685

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

.def_alias(slave, new_cmd, org_cmd, *args) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2900

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

.delete ⇒ `Object`



2240
2241
2242

# File 'lib/multi-tk.rb', line 2240

def delete
  __getip.delete
end

.delete_cmd(slave, cmd) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2939

def self.delete_cmd(slave, cmd)
  __getip.delete_cmd(slave, cmd)
  self
end

.delete_slaves(*args) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2919

def self.delete_slaves(*args)
  __getip.delete_slaves(*args)
  self
end

.deleted? ⇒ `Boolean`

Returns:

(Boolean)



2244
2245
2246

# File 'lib/multi-tk.rb', line 2244

def deleted?
  __getip.deleted?
end

.do_one_event(flag = TclTkLib::EventFlag::ALL) ⇒ `Object`



2179
2180
2181

# File 'lib/multi-tk.rb', line 2179

def do_one_event(flag = TclTkLib::EventFlag::ALL)
  __getip.do_one_event(flag)
end

.encoding_table ⇒ `Object`



3289
3290
3291

# File 'lib/multi-tk.rb', line 3289

def encoding_table
  __getip.encoding_table
end

.eval(*args, &blk) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2158

def eval(*args, &blk)
  # class ==> interp object
  __getip.eval(*args, &blk)
end

.eval_proc(*args, &blk) ⇒ `Object` Also known as: call

class method

# File 'lib/multi-tk.rb', line 2129

def eval_proc(*args, &blk)
  # class ==> interp object
  __getip.eval_proc(*args, &blk)
end

.eval_string(cmd, *eval_args) ⇒ `Object` Also known as: eval_str

# File 'lib/multi-tk.rb', line 2144

def eval_string(cmd, *eval_args)
  # class ==> interp object
  __getip.eval_string(cmd, *eval_args)
end

.exist?(slave = '') ⇒ `Boolean`

Returns:

(Boolean)



2929
2930
2931

# File 'lib/multi-tk.rb', line 2929

def self.exist?(slave = '')
  __getip.exist?(slave)
end

.exit(st = true) ⇒ `Object`



2260
2261
2262

# File 'lib/multi-tk.rb', line 2260

def exit(st = true)
  __getip.exit(st)
end

.exit!(st = false) ⇒ `Object`



2264
2265
2266

# File 'lib/multi-tk.rb', line 2264

def exit!(st = false)
  __getip.exit!(st)
end

.expose_cmd(slave, cmd, aliasname = nil) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2953

def self.expose_cmd(slave, cmd, aliasname = nil)
  __getip.expose_cmd(slave, cmd, aliasname)
  self
end

.get_cb_entry(cmd) ⇒ `Object`



1777
1778
1779

# File 'lib/multi-tk.rb', line 1777

def self.get_cb_entry(cmd)
  @@CB_ENTRY_CLASS.new(__getip, cmd).freeze
end

.get_eventloop_tick ⇒ `Object`



2193
2194
2195

# File 'lib/multi-tk.rb', line 2193

def get_eventloop_tick
  __getip.get_eventloop_tick
end

.get_eventloop_weight ⇒ `Object`



2205
2206
2207

# File 'lib/multi-tk.rb', line 2205

def get_eventloop_weight
  __getip.get_eventloop_weight
end

.get_limit(limit_type, slave = '', slot = nil) ⇒ `Object`



3103
3104
3105

# File 'lib/multi-tk.rb', line 3103

def self.get_limit(limit_type, slave = '', slot = nil)
  __getip.get_limit(limit_type, slave, slot)
end

.get_no_event_wait ⇒ `Object`



2199
2200
2201

# File 'lib/multi-tk.rb', line 2199

def get_no_event_wait
  __getip.get_no_event_wait
end

.has_mainwindow? ⇒ `Boolean`

Returns:

(Boolean)



2248
2249
2250

# File 'lib/multi-tk.rb', line 2248

def has_mainwindow?
  __getip.has_mainwindow?
end

.hidden_cmds(slave = '') ⇒ `Object`



2976
2977
2978

# File 'lib/multi-tk.rb', line 2976

def self.hidden_cmds(slave = '')
  __getip.hidden_cmds(slave)
end

.hide_cmd(slave, cmd, aliasname = nil) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2967

def self.hide_cmd(slave, cmd, aliasname = nil)
  __getip.hide_cmd(slave, cmd, aliasname)
  self
end

.inherited(subclass) ⇒ `Object`

# File 'lib/multi-tk.rb', line 948

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|
          begin
            unless m == '__id__' || m == '__send__' || m == '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

.init_ip_env(script = Proc.new) ⇒ `Object`

# File 'lib/multi-tk.rb', line 1719

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

.init_ip_internal ⇒ `Object`



1766
1767
1768

# File 'lib/multi-tk.rb', line 1766

def self.init_ip_internal
  __getip._init_ip_internal(@@INIT_IP_ENV, @@ADD_TK_PROCS)
end

.invalid_namespace? ⇒ `Boolean`

Returns:

(Boolean)



2252
2253
2254

# File 'lib/multi-tk.rb', line 2252

def invalid_namespace?
  __getip.invalid_namespace?
end

.invoke_hidden(slave, cmd, *args) ⇒ `Object`



2996
2997
2998

# File 'lib/multi-tk.rb', line 2996

def self.invoke_hidden(slave, cmd, *args)
  __getip.invoke_hidden(slave, cmd, *args)
end

.invoke_hidden_on_global(slave, cmd, *args) ⇒ `Object`



3017
3018
3019

# File 'lib/multi-tk.rb', line 3017

def self.invoke_hidden_on_global(slave, cmd, *args)
  __getip.invoke_hidden_on_global(slave, cmd, *args)
end

.invoke_hidden_on_namespace(slave, ns, cmd, *args) ⇒ `Object`



3035
3036
3037

# File 'lib/multi-tk.rb', line 3035

def self.invoke_hidden_on_namespace(slave, ns, cmd, *args)
  __getip.invoke_hidden_on_namespace(slave, ns, cmd, *args)
end

.ip_name ⇒ `Object`



1567
1568
1569

# File 'lib/multi-tk.rb', line 1567

def self.ip_name
  __getip.ip_name
end

.mainloop(check_root = true) ⇒ `Object`



2173
2174
2175

# File 'lib/multi-tk.rb', line 2173

def mainloop(check_root = true)
  __getip.mainloop(check_root)
end

.mainloop_abort_on_exception ⇒ `Object`

# File 'lib/multi-tk.rb', line 2182

def mainloop_abort_on_exception
  # __getip.mainloop_abort_on_exception
  TclTkLib.mainloop_abort_on_exception
end

.mainloop_abort_on_exception=(mode) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2186

def mainloop_abort_on_exception=(mode)
  # __getip.mainloop_abort_on_exception=(mode)
  TclTkLib.mainloop_abort_on_exception=(mode)
end

.mainloop_watchdog(check_root = true) ⇒ `Object`



2176
2177
2178

# File 'lib/multi-tk.rb', line 2176

def mainloop_watchdog(check_root = true)
  __getip.mainloop_watchdog(check_root)
end

.make_safe ⇒ `Object`



2216
2217
2218

# File 'lib/multi-tk.rb', line 2216

def make_safe
  __getip.make_safe
end

.manipulable? ⇒ `Boolean`

Returns:

(Boolean)



1598
1599
1600

# File 'lib/multi-tk.rb', line 1598

def self.manipulable?
  true
end

.mark_trusted(slave = '') ⇒ `Object`

# File 'lib/multi-tk.rb', line 3044

def self.mark_trusted(slave = '')
  __getip.mark_trusted(slave)
  self
end

.master? ⇒ `Boolean`

Returns:

(Boolean)



1532
1533
1534

# File 'lib/multi-tk.rb', line 1532

def self.master?
  __getip.master?
end

.method_missing(id, *args) ⇒ `Object`



2212
2213
2214

# File 'lib/multi-tk.rb', line 2212

def method_missing(id, *args)
  __getip.__send__(id, *args)
end

.new_master(safe = nil, keys = {}) ⇒ `Object` Also known as: new

# File 'lib/multi-tk.rb', line 1425

def new_master(safe=nil, keys={})
  if MultiTkIp::WITH_RUBY_VM
    #### TODO !!!!!!
    fail RuntimeError, 
         'sorry, still not support multiple master-interpreters on Ruby VM'
  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)}
   end
  ip
end

.new_safe_slave(safe = 4, keys = {}) ⇒ `Object` Also known as: new_safeTk

# File 'lib/multi-tk.rb', line 1478

def new_safe_slave(safe=4, keys={})
  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)}
  end
  ip
end

.new_slave(safe = nil, keys = {}) ⇒ `Object` Also known as: new_trusted_slave

# File 'lib/multi-tk.rb', line 1455

def new_slave(safe=nil, keys={})
  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)}
  end
  ip
end

.path ⇒ `Object`



1561
1562
1563

# File 'lib/multi-tk.rb', line 1561

def self.path
  __getip.path
end

.recursion_limit(slave = '', limit = None) ⇒ `Object`



3112
3113
3114

# File 'lib/multi-tk.rb', line 3112

def self.recursion_limit(slave = '', limit = None)
  __getip.recursion_limit(slave)
end

.remove_tk_procs(*names) ⇒ `Object`

# File 'lib/multi-tk.rb', line 1754

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

.restart(app_name = nil, keys = {}) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2268

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

.safe? ⇒ `Boolean`

Returns:

(Boolean)



2220
2221
2222

# File 'lib/multi-tk.rb', line 2220

def safe?
  __getip.safe?
end

.safe_base? ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/multi-tk.rb', line 2224

def safe_base?
  begin
    __getip.safe_base?
  rescue
    false
  end
end

.safe_level ⇒ `Object`



362
363
364

# File 'lib/multi-tk.rb', line 362

def self.safe_level
  __getip.safe_level
end

.safe_level=(safe) ⇒ `Object`



356
357
358

# File 'lib/multi-tk.rb', line 356

def self.safe_level=(safe)
  self.set_safe_level(safe)
end

.set_eventloop_tick(tick) ⇒ `Object`



2190
2191
2192

# File 'lib/multi-tk.rb', line 2190

def set_eventloop_tick(tick)
  __getip.set_eventloop_tick(tick)
end

.set_eventloop_weight(loop_max, no_event_tick) ⇒ `Object`



2202
2203
2204

# File 'lib/multi-tk.rb', line 2202

def set_eventloop_weight(loop_max, no_event_tick)
  __getip.set_eventloop_weight(loop_max, no_event_tick)
end

.set_limit(limit_type, slave = '', opts = {}) ⇒ `Object`



3078
3079
3080

# File 'lib/multi-tk.rb', line 3078

def self.set_limit(limit_type, slave = '', opts = {})
  __getip.set_limit(limit_type, slave, opts)
end

.set_no_event_wait(tick) ⇒ `Object`



2196
2197
2198

# File 'lib/multi-tk.rb', line 2196

def set_no_event_wait(tick)
  __getip.set_no_event_wait(tick)
end

.set_safe_level(safe) ⇒ `Object`



353
354
355

# File 'lib/multi-tk.rb', line 353

def self.set_safe_level(safe)
  __getip.set_safe_level(safe)
end

.share_stderr(dist, src = '') ⇒ `Object`

# File 'lib/multi-tk.rb', line 3149

def self.share_stderr(dist, src = '')
  __getip.share_stderr(dist, src)
  self
end

.share_stdin(dist, src = '') ⇒ `Object`

# File 'lib/multi-tk.rb', line 3129

def self.share_stdin(dist, src = '')
  __getip.share_stdin(dist, src)
  self
end

.share_stdio(dist, src = '') ⇒ `Object`

# File 'lib/multi-tk.rb', line 3191

def self.share_stdio(dist, src = '')
  __getip.share_stdio(dist, src)
  self
end

.share_stdout(dist, src = '') ⇒ `Object`

# File 'lib/multi-tk.rb', line 3139

def self.share_stdout(dist, src = '')
  __getip.share_stdout(dist, src)
  self
end

.slave? ⇒ `Boolean`

Returns:

(Boolean)



1539
1540
1541

# File 'lib/multi-tk.rb', line 1539

def self.slave?
  not self.master?
end

.slaves(all = false) ⇒ `Object`



1589
1590
1591

# File 'lib/multi-tk.rb', line 1589

def self.slaves(all = false)
  __getip.slaves(all)
end

.tk_cmd_tbl ⇒ `Object`



1676
1677
1678

# File 'lib/multi-tk.rb', line 1676

def self.tk_cmd_tbl
  @@TK_CMD_TBL
end

.tk_object_table(id) ⇒ `Object`



1682
1683
1684

# File 'lib/multi-tk.rb', line 1682

def self.tk_object_table(id)
  __getip._tk_table_list[id]
end

.tk_windows ⇒ `Object`



1679
1680
1681

# File 'lib/multi-tk.rb', line 1679

def self.tk_windows
  __getip._tk_windows
end

.to_eval ⇒ `Object`



1573
1574
1575

# File 'lib/multi-tk.rb', line 1573

def self.to_eval
  __getip.to_eval
end

.transfer_stderr(dist, src = '') ⇒ `Object`

# File 'lib/multi-tk.rb', line 3179

def self.transfer_stderr(dist, src = '')
  __getip.transfer_stderr(dist, src)
  self
end

.transfer_stdin(dist, src = '') ⇒ `Object`

# File 'lib/multi-tk.rb', line 3159

def self.transfer_stdin(dist, src = '')
  __getip.transfer_stdin(dist, src)
  self
end

.transfer_stdio(dist, src = '') ⇒ `Object`

# File 'lib/multi-tk.rb', line 3203

def self.transfer_stdio(dist, src = '')
  __getip.transfer_stdio(dist, src)
  self
end

.transfer_stdout(dist, src = '') ⇒ `Object`

# File 'lib/multi-tk.rb', line 3169

def self.transfer_stdout(dist, src = '')
  __getip.transfer_stdout(dist, src)
  self
end

Instance Method Details

#__create_safe_slave_obj(safe_opts, app_name, tk_opts) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 1154

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_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)}")
  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

#__create_trusted_slave_obj(name, keys) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 1197

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._invoke('set', 'argv0', name) if name.kind_of?(String)
  slave_ip._invoke('set', 'argv', _keys2opts(keys))
  @interp._invoke('load', '', 'Tk', ip_name)
  @slave_ip_tbl[ip_name] = slave_ip
  [slave_ip, ip_name]
end

#__eval(str) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2696

def __eval(str)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.__eval(str)
end

#__invoke(*args) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2701

def __invoke(*args)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.__invoke(*args)
end

#__pseudo_toplevel ⇒ `Object`

instance method

# File 'lib/multi-tk.rb', line 1854

def __pseudo_toplevel
  ip = MultiTkIp.__getip
  (ip == @@DEFAULT_MASTER || ip == self) &&
    self.__pseudo_toplevel_evaluable? && @pseudo_toplevel[1]
end

#__pseudo_toplevel=(m) ⇒ `Object`

# File 'lib/multi-tk.rb', line 1860

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

#__pseudo_toplevel_evaluable=(mode) ⇒ `Object`

# File 'lib/multi-tk.rb', line 1884

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

#__pseudo_toplevel_evaluable? ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/multi-tk.rb', line 1876

def __pseudo_toplevel_evaluable?
  begin
    @pseudo_toplevel[0] && @pseudo_toplevel[1].pseudo_toplevel_evaluable?
  rescue Exception
    false
  end
end

#_add_new_tables ⇒ `Object`

# File 'lib/multi-tk.rb', line 1625

def _add_new_tables
  (@@TK_TABLE_LIST.size - @tk_table_list.size).times{ 
    (tbl = {}).tainted? || tbl.taint
    @tk_table_list << tbl
  }
end

#_add_tk_procs(name, args, body) ⇒ `Object`

# File 'lib/multi-tk.rb', line 1636

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

#_conv_listelement(arg) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2824

def _conv_listelement(arg)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._conv_listelement(arg)
end

#_create_slave_object(keys = {}) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 1211

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

#_default_delete_hook(slave) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 1361

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

#_destroy_slaves_of_slaveIP(ip) ⇒ `Object`

# File 'lib/multi-tk.rb', line 377

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
=begin
      if ip._invoke('interp', 'exists', name) == '1'
        begin
          ip._invoke(name, 'eval', 'exit')
        rescue Exception
        end
      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

#_eval(str) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2706

def _eval(str)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._eval(str)
end

#_eval_with_enc(str) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2726

def _eval_with_enc(str)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._eval_with_enc(str)
end

#_eval_without_enc(str) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2716

def _eval_without_enc(str)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._eval_without_enc(str)
end

#_fromUTF8(str, encoding = nil) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2741

def _fromUTF8(str, encoding=nil)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._fromUTF8(str, encoding)
end

#_get_global_var(var) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2786

def _get_global_var(var)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._get_global_var(var)
end

#_get_global_var2(var, idx) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2790

def _get_global_var2(var, idx)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._get_global_var2(var, idx)
end

#_get_variable(var, flag) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2761

def _get_variable(var, flag)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._get_variable(var, flag)
end

#_get_variable2(var, idx, flag) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2765

def _get_variable2(var, idx, flag)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._get_variable2(var, idx, flag)
end

#_init_ip_env(script) ⇒ `Object`



1632
1633
1634

# File 'lib/multi-tk.rb', line 1632

def _init_ip_env(script)
  self.eval_proc{script.call(self)}
end

#_init_ip_internal(init_ip_env, add_tk_procs) ⇒ `Object`

# File 'lib/multi-tk.rb', line 1660

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

#_invoke(*args) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2711

def _invoke(*args)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke(*args)
end

#_invoke_with_enc(*args) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2731

def _invoke_with_enc(*args)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke_with_enc(*args)
end

#_invoke_without_enc(*args) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2721

def _invoke_without_enc(*args)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke_without_enc(*args)
end

#_ip_id_ ⇒ `Object`

# File 'lib/multi-tk.rb', line 1396

def _ip_id_
  # for RemoteTkIp
  ''
end

#_make_menu_embeddable(menu_path) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2811

def _make_menu_embeddable(menu_path)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._make_menu_embeddable(menu_path)
end

#_merge_tklist(*args) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2820

def _merge_tklist(*args)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._merge_tklist(*args)
end

#_receiver_mainloop(check_root) ⇒ `Object`

# File 'lib/multi-tk.rb', line 627

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

#_remove_tk_procs(*names) ⇒ `Object`

# File 'lib/multi-tk.rb', line 1644

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

#_return_value ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2756

def _return_value
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._return_value
end

#_set_global_var(var, value) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2794

def _set_global_var(var, value)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._set_global_var(var, value)
end

#_set_global_var2(var, idx, value) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2798

def _set_global_var2(var, idx, value)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._set_global_var2(var, idx, value)
end

#_set_variable(var, value, flag) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2769

def _set_variable(var, value, flag)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._set_variable(var, value, flag)
end

#_set_variable2(var, idx, value, flag) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2773

def _set_variable2(var, idx, value, flag)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._set_variable2(var, idx, value, flag)
end

#_split_tklist(str) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2816

def _split_tklist(str)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._split_tklist(str)
end

#_thread_tkwait(mode, target) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2751

def _thread_tkwait(mode, target)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._thread_tkwait(mode, target)
end

#_thread_vwait(var) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2746

def _thread_vwait(var)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._thread_vwait(var)
end

#_tk_cmd_tbl ⇒ `Object`

# File 'lib/multi-tk.rb', line 1611

def _tk_cmd_tbl
  tbl = {}
  MultiTkIp.tk_cmd_tbl.each{|id, ent| tbl[id] = ent if ent.ip == self }
  tbl
end

#_tk_table_list ⇒ `Object`



1621
1622
1623

# File 'lib/multi-tk.rb', line 1621

def _tk_table_list
  @tk_table_list
end

#_tk_windows ⇒ `Object`



1617
1618
1619

# File 'lib/multi-tk.rb', line 1617

def _tk_windows
  @tk_windows
end

#_toUTF8(str, encoding = nil) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2736

def _toUTF8(str, encoding=nil)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._toUTF8(str, encoding)
end

#_unset_global_var(var) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2802

def _unset_global_var(var)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._unset_global_var(var)
end

#_unset_global_var2(var, idx) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2806

def _unset_global_var2(var, idx)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._unset_global_var2(var, idx)
end

#_unset_variable(var, flag) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2777

def _unset_variable(var, flag)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._unset_variable(var, flag)
end

#_unset_variable2(var, idx, flag) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2781

def _unset_variable2(var, idx, flag)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._unset_variable2(var, idx, flag)
end

#abort(msg = nil) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2648

def abort(msg = nil)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  if master? && !safe? && allow_ruby_exit?
    if msg
      Kernel.abort(msg)
    else
      Kernel.abort
    end
  else
    # ignore msg
    delete
    1
  end
end

#alias_delete(slave, cmd_name) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2884

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

#alias_info(slave, cmd_name) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2876

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

#alias_target(aliascmd, slave = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3116

def alias_target(aliascmd, slave = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'target', _slavearg(slave), aliascmd)
end

#aliases(slave = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2905

def aliases(slave = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  _lst2ary(@interp._invoke('interp', 'aliases', _slavearg(slave)))
end

#alive? ⇒ `Boolean`

Returns:

(Boolean)

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 1543

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

#allow_ruby_exit=(mode) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2565

def allow_ruby_exit= (mode)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.allow_ruby_exit = mode
end

#allow_ruby_exit? ⇒ `Boolean`

Returns:

(Boolean)

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2560

def allow_ruby_exit?
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.allow_ruby_exit?
end

#background_call ⇒ `Object`

# File 'lib/multi-tk.rb', line 2064

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)
=begin
    eval_proc_core(false, 
                   proc{|safe, *params| 
                     $SAFE=safe if $SAFE < safe
                     Thread.new(*params, &cmd).value
                   },
                   safe_level, *args)
=end
  }
end

#background_eval ⇒ `Object`

# File 'lib/multi-tk.rb', line 2124

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

#background_eval_proc ⇒ `Object`

# File 'lib/multi-tk.rb', line 2061

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)
=begin
    eval_proc_core(false, 
                   proc{|safe, *params| 
                     $SAFE=safe if $SAFE < safe
                     Thread.new(*params, &cmd).value
                   },
                   safe_level, *args)
=end
  }
end

#background_eval_str ⇒ `Object`

# File 'lib/multi-tk.rb', line 2095

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

#background_eval_string ⇒ `Object`

# File 'lib/multi-tk.rb', line 2093

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

#bg_call ⇒ `Object`

# File 'lib/multi-tk.rb', line 2063

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)
=begin
    eval_proc_core(false, 
                   proc{|safe, *params| 
                     $SAFE=safe if $SAFE < safe
                     Thread.new(*params, &cmd).value
                   },
                   safe_level, *args)
=end
  }
end

#bg_eval(*args, &blk) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2111

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

#bg_eval_proc(*args) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2041

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)
=begin
    eval_proc_core(false, 
                   proc{|safe, *params| 
                     $SAFE=safe if $SAFE < safe
                     Thread.new(*params, &cmd).value
                   },
                   safe_level, *args)
=end
  }
end

#bg_eval_str ⇒ `Object`

# File 'lib/multi-tk.rb', line 2094

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

#bg_eval_string(cmd, *eval_args) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2080

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

#call ⇒ `Object`

# File 'lib/multi-tk.rb', line 2039

def eval_proc(*args)
  # The scope of the eval-block of 'eval_proc' method is different from 
  # the external. If you want to pass local values to the eval-block, 
  # use arguments of eval_proc method. They are passed to block-arguments.
  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
  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, 
              proc{|safe, *params|
         $SAFE=safe if $SAFE < safe
                       cmd.call(*params)
                     }, *args)
    ensure
      current['callback_ip'] = backup_ip
    end
  else
    eval_proc_core(true, 
                   proc{|safe, *params| 
                     $SAFE=safe if $SAFE < safe
                     Thread.new(*params, &cmd).value
                   },
                   *args)
  end
end

#cb_error(e) ⇒ `Object`

# File 'lib/multi-tk.rb', line 335

def cb_error(e)
  if @cb_error_proc[0].respond_to?(:call)
    @cb_error_proc[0].call(e)
  end
end

#cb_eval(cmd, *args) ⇒ `Object`

def cb_eval(cmd, *args)

  #self.eval_callback{ TkComm._get_eval_string(TkUtil.eval_cmd(cmd, *args)) }
  #ret = self.eval_callback{ TkComm._get_eval_string(TkUtil.eval_cmd(cmd, *args)) }
  ret = self.eval_callback(*args){|safe, *params|
    $SAFE=safe if $SAFE < safe
    TkComm._get_eval_string(TkUtil.eval_cmd(cmd, *params))
  }
  if ret.kind_of?(Exception)
    raise ret
  end
  ret
end

# File 'lib/multi-tk.rb', line 1795

def cb_eval(cmd, *args)
  self.eval_callback(*args){|safe, *params|
    $SAFE=safe if $SAFE < safe
    # TkUtil.eval_cmd(cmd, *params)
    TkComm._get_eval_string(TkUtil.eval_cmd(cmd, *params))
  }
end

#def_alias(slave, new_cmd, org_cmd, *args) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2894

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

#default_encoding=(enc) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3307

def default_encoding=(enc)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.default_encoding = enc
end

#delete ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2570

def delete
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @slave_ip_tbl.each{|name, subip|
    _destroy_slaves_of_slaveIP(subip)
=begin
    begin
      subip._invoke('destroy', '.') unless subip.deleted?
    rescue Exception
    end
=end
    begin
      # subip._eval_without_enc("foreach i [after info] {after cancel $i}")
	unless subip.deleted?
 after_ids = subip._eval_without_enc("after info")
 subip._eval_without_enc("foreach i {#{after_ids}} {after cancel $i}")
	end
    rescue Exception
    end

    # safe_base?
    if @interp._eval_without_enc("catch {::safe::interpConfigure #{name}}") == '0'
      begin
        @interp._eval_without_enc("::safe::interpDelete #{name}")
      rescue Exception
      else
        next if subip.deleted?
      end
    end
    if subip.respond_to?(:safe_base?) && subip.safe_base? && 
        !subip.deleted?
      # do 'exit' to call the delete_hook procedure
      begin
        subip._eval_without_enc('exit') 
      rescue Exception
      end
    else
      begin
        subip.delete unless subip.deleted?
      rescue Exception
      end
    end
  }

  begin
    # @interp._eval_without_enc("foreach i [after info] {after cancel $i}")
    after_ids = @interp._eval_without_enc("after info")
    @interp._eval_without_enc("foreach i {#{after_ids}} {after cancel $i}")
  rescue Exception
  end

  begin
    @interp._invoke('destroy', '.') unless @interp.deleted?
  rescue Exception
  end

  if @safe_base && !@interp.deleted?
    # do 'exit' to call the delete_hook procedure
    @interp._eval_without_enc('exit')
  end
  @interp.delete
  self
end

#delete_cmd(slave, cmd) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2933

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

#delete_slaves(*args) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2913

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

#deleted? ⇒ `Boolean`

Returns:

(Boolean)

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2633

def deleted?
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.deleted?
end

#encoding=(enc) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3312

def encoding=(enc)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.encoding = enc
end

#encoding_convertfrom(str, enc = None) ⇒ `Object` Also known as: encoding_convert_from

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3327

def encoding_convertfrom(str, enc=None)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.encoding_convertfrom(str, enc)
end

#encoding_convertto(str, enc = None) ⇒ `Object` Also known as: encoding_convert_to

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3333

def encoding_convertto(str, enc=None)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.encoding_convertto(str, enc)
end

#encoding_name ⇒ `Object` Also known as: encoding, default_encoding

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3316

def encoding_name
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.encoding_name
end

#encoding_obj ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3320

def encoding_obj
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.encoding_obj
end

#encoding_table ⇒ `Object`



3294
3295
3296

# File 'lib/multi-tk.rb', line 3294

def encoding_table
  @interp.encoding_table
end

#eval(*args, &blk) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2097

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

#eval_callback(*args) ⇒ `Object`

# File 'lib/multi-tk.rb', line 1989

def eval_callback(*args)
  if block_given?
    cmd = Proc.new
  else
    cmd = args.shift
  end
  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
end

#eval_proc(*args) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2005

def eval_proc(*args)
  # The scope of the eval-block of 'eval_proc' method is different from 
  # the external. If you want to pass local values to the eval-block, 
  # use arguments of eval_proc method. They are passed to block-arguments.
  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
  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, 
              proc{|safe, *params|
         $SAFE=safe if $SAFE < safe
                       cmd.call(*params)
                     }, *args)
    ensure
      current['callback_ip'] = backup_ip
    end
  else
    eval_proc_core(true, 
                   proc{|safe, *params| 
                     $SAFE=safe if $SAFE < safe
                     Thread.new(*params, &cmd).value
                   },
                   *args)
  end
end

#eval_str ⇒ `Object`

# File 'lib/multi-tk.rb', line 2078

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

#eval_string(cmd, *eval_args) ⇒ `Object`

# File 'lib/multi-tk.rb', line 2066

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

#exist?(slave = '') ⇒ `Boolean`

Returns:

(Boolean)

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2924

def exist?(slave = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  ret = @interp._invoke('interp', 'exists', _slavearg(slave))
  (ret == '1')? true: false
end

#exit(st = true) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2663

def exit(st = true)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  if master? && !safe? && allow_ruby_exit?
    Kernel.exit(st)
  else
    delete
    st
  end
end

#exit!(st = false) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2673

def exit!(st = false)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  if master? && !safe? && allow_ruby_exit?
    Kernel.exit!(st)
  else
    delete
    st
  end
end

#expose_cmd(slave, cmd, aliasname = nil) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2944

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

#force_default_encoding=(mode) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3298

def force_default_encoding=(mode)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.force_default_encoding = mode
end

#force_default_encoding? ⇒ `Boolean`

Returns:

(Boolean)

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3302

def force_default_encoding?
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.force_default_encoding?
end

#get_bgerror_handler(slave = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3066

def get_bgerror_handler(slave = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  procedure(@interp._invoke('interp', 'bgerror', _slavearg(slave)))
end

#get_limit(limit_type, slave = '', slot = nil) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3082

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

#has_mainwindow? ⇒ `Boolean`

Returns:

(Boolean)

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2638

def has_mainwindow?
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.has_mainwindow?
end

#hidden_cmds(slave = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2972

def hidden_cmds(slave = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  _lst2ary(@interp._invoke('interp', 'hidden', _slavearg(slave)))
end

#hide_cmd(slave, cmd, aliasname = nil) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2958

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

#inspect ⇒ `Object`

# File 'lib/multi-tk.rb', line 1503

def inspect
  s = self.to_s.chop!
  if self.manipulable?
    if master?
      if @interp.deleted?
        s << ':deleted-master'
      else
        s << ':master'
      end
    else
      if @interp.deleted?
        s << ':deleted-slave'
      elsif @interp.safe?
        s << ':safe-slave'
      else
        s << ':trusted-slave'
      end
    end
  end
  s << '>'
end

#invalid_namespace? ⇒ `Boolean`

Returns:

(Boolean)

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2643

def invalid_namespace?
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.invalid_namespace?
end

#invoke_hidden(slave, cmd, *args) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2980

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

#invoke_hidden_on_global(slave, cmd, *args) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3000

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

#invoke_hidden_on_namespace(slave, ns, cmd, *args) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3021

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

#ip_name ⇒ `Object`



1564
1565
1566

# File 'lib/multi-tk.rb', line 1564

def ip_name
  @ip_name || ''
end

#mainloop(check_root = true, restart_on_dead = true) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2431

def mainloop(check_root = true, restart_on_dead = true)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?

  if WITH_RUBY_VM  ### Ruby 1.9 !!!!!!!!!!!
    return @interp_thread.value if @interp_thread
  end

  #return self if self.slave?
  #return self if self != @@DEFAULT_MASTER
  if self != @@DEFAULT_MASTER
    if @wait_on_mainloop[0]
      begin
        @wait_on_mainloop[1] += 1
        if $SAFE >= 4
   _receiver_mainloop(check_root).join
        else
          @cmd_queue.enq([@system, 'call_mainloop', 
                          Thread.current, check_root])
          Thread.stop
        end
      rescue MultiTkIp_OK => ret
        # return value
        if ret.value.kind_of?(Thread)
          return ret.value.value
        else
          return ret.value
        end
      rescue SystemExit => e
        # exit IP
        warn("Warning: " + $! + " on " + self.inspect) if $DEBUG
        begin
          self._eval_without_enc('exit')
        rescue Exception
        end
        self.delete
      rescue StandardError => e
        if $DEBUG
          warn("Warning: " + e.class.inspect + 
               ((e.message.length > 0)? ' "' + e.message + '"': '') +  
               " on " + self.inspect) 
        end
        return e
      rescue Exception => e
 return e
      ensure
        @wait_on_mainloop[1] -= 1
      end
    end
    return
  end

  unless restart_on_dead
    @wait_on_mainloop[1] += 1
=begin
    begin
      @interp.mainloop(check_root)
    rescue StandardError => e
      if $DEBUG
        warn("Warning: " + e.class.inspect + 
             ((e.message.length > 0)? ' "' + e.message + '"': '') +  
             " on " + self.inspect) 
      end
    end
=end
    begin
	@interp.mainloop(check_root)
    ensure
	@wait_on_mainloop[1] -= 1
    end
  else
    loop do
      break unless self.alive?
      if check_root
        begin
          break if TclTkLib.num_of_mainwindows == 0
        rescue StandardError
          break
        end
      end
      break if @interp.deleted?
      begin
 @wait_on_mainloop[1] += 1
        @interp.mainloop(check_root)
      rescue StandardError => e
        if TclTkLib.mainloop_abort_on_exception != nil
          #STDERR.print("Warning: Tk mainloop receives ", $!.class.inspect, 
          #             " exception (ignore) : ", $!.message, "\n");
          if $DEBUG
            warn("Warning: Tk mainloop receives " << e.class.inspect <<
                 " exception (ignore) : " << e.message);
          end
        end
        #raise e
      rescue Exception => e
=begin
        if TclTkLib.mainloop_abort_on_exception != nil
          #STDERR.print("Warning: Tk mainloop receives ", $!.class.inspect, 
          #             " exception (ignore) : ", $!.message, "\n");
          if $DEBUG
            warn("Warning: Tk mainloop receives " << e.class.inspect <<
                 " exception (ignore) : " << e.message);
          end
        end
=end
        raise e
      ensure
        @wait_on_mainloop[1] -= 1
        Thread.pass  # avoid eventloop conflict
      end
    end
  end
  self
end

#make_safe ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2545

def make_safe
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.make_safe
end

#manipulable? ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/multi-tk.rb', line 1593

def manipulable?
  return true if (Thread.current.group == ThreadGroup::Default)
  ip = MultiTkIp.__getip
  (ip == self) || ip._is_master_of?(@interp)
end

#mark_trusted(slave = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3039

def mark_trusted(slave = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'marktrusted', _slavearg(slave))
  self
end

#master? ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/multi-tk.rb', line 1525

def master?
  if @ip_name
    false
  else
    true
  end
end

#path ⇒ `Object`



1558
1559
1560

# File 'lib/multi-tk.rb', line 1558

def path
  @ip_name || ''
end

#recursion_limit(slave = '', limit = None) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3107

def recursion_limit(slave = '', limit = None)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  number(@interp._invoke('interp', 'recursionlimit', 
                         _slavearg(slave), limit))
end

#restart(app_name = nil, keys = {}) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2683

def restart(app_name = nil, keys = {})
  raise SecurityError, "no permission to manipulate" unless self.manipulable?

  _init_ip_internal(@@INIT_IP_ENV, @@ADD_TK_PROCS)

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

  @interp.restart
end

#running_mainloop? ⇒ `Boolean`

Returns:

(Boolean)



373
374
375

# File 'lib/multi-tk.rb', line 373

def running_mainloop?
  @wait_on_mainloop[1] > 0
end

#safe? ⇒ `Boolean`

Returns:

(Boolean)

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2550

def safe?
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp.safe?
end

#safe_base? ⇒ `Boolean`

Returns:

(Boolean)

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 2555

def safe_base?
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @safe_base
end

#safe_level ⇒ `Object`



359
360
361

# File 'lib/multi-tk.rb', line 359

def safe_level
  @safe_level[0]
end

#safe_level=(safe) ⇒ `Object`



350
351
352

# File 'lib/multi-tk.rb', line 350

def safe_level=(safe)
  set_safe_level(safe)
end

#safeip_add_to_access_path(dir) ⇒ `Object`

# File 'lib/multi-tk.rb', line 3270

def safeip_add_to_access_path(dir)
  ip = MultiTkIp.__getip
  ip._eval("::safe::interpAddToAccessPath #{@ip_name} #{dir}")
end

#safeip_configinfo(slot = nil) ⇒ `Object`

# File 'lib/multi-tk.rb', line 3225

def safeip_configinfo(slot = nil)
  ip = MultiTkIp.__getip
  ret = {}
  if slot
    conf = _lst2ary(ip._eval("::safe::interpConfigure " + 
                             @ip_name + " -#{slot}"))
    if conf[0] == '-deleteHook'
=begin
      if conf[1] =~ /^rb_out\S* (c(_\d+_)?\d+)/
        ret[conf[0][1..-1]] = MultiTkIp._tk_cmd_tbl[$1]
=end
      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'
=begin
        if v =~ /^rb_out\S* (c(_\d+_)?\d+)/
          ret[k[1..-1]] = MultiTkIp._tk_cmd_tbl[$1]
=end
        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

#safeip_configure(slot, value = None) ⇒ `Object`

# File 'lib/multi-tk.rb', line 3212

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

#safeip_delete ⇒ `Object`

# File 'lib/multi-tk.rb', line 3265

def safeip_delete
  ip = MultiTkIp.__getip
  ip._eval("::safe::interpDelete " + @ip_name)
end

#safeip_find_in_access_path(dir) ⇒ `Object`

# File 'lib/multi-tk.rb', line 3275

def safeip_find_in_access_path(dir)
  ip = MultiTkIp.__getip
  ip._eval("::safe::interpFindInAccessPath #{@ip_name} #{dir}")
end

#safeip_set_log_cmd(cmd = Proc.new) ⇒ `Object`

# File 'lib/multi-tk.rb', line 3280

def safeip_set_log_cmd(cmd = Proc.new)
  ip = MultiTkIp.__getip
  ip._eval("::safe::setLogCmd #{@ip_name} #{_get_eval_string(cmd)}")
end

#set_bgerror_handler(cmd = Proc.new, slave = nil, &b) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3049

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

#set_cb_error(cmd = Proc.new) ⇒ `Object`



331
332
333

# File 'lib/multi-tk.rb', line 331

def set_cb_error(cmd = Proc.new)
  @cb_error_proc[0] = cmd
end

#set_limit(limit_type, slave = '', opts = {}) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3074

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

#set_safe_level(safe) ⇒ `Object`

# File 'lib/multi-tk.rb', line 343

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

#share_stderr(dist, src = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3144

def share_stderr(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'share', src, 'stderr', dist)
  self
end

#share_stdin(dist, src = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3124

def share_stdin(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'share', src, 'stdin', dist)
  self
end

#share_stdio(dist, src = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3184

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

#share_stdout(dist, src = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3134

def share_stdout(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'share', src, 'stdout', dist)
  self
end

#slave? ⇒ `Boolean`

Returns:

(Boolean)



1536
1537
1538

# File 'lib/multi-tk.rb', line 1536

def slave?
  not master?
end

#slaves(all = false) ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 1577

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

#thread_eval_proc ⇒ `Object`

# File 'lib/multi-tk.rb', line 2062

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)
=begin
    eval_proc_core(false, 
                   proc{|safe, *params| 
                     $SAFE=safe if $SAFE < safe
                     Thread.new(*params, &cmd).value
                   },
                   safe_level, *args)
=end
  }
end

#to_eval ⇒ `Object`



1570
1571
1572

# File 'lib/multi-tk.rb', line 1570

def to_eval
  @ip_name || ''
end

#transfer_stderr(dist, src = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3174

def transfer_stderr(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'transfer', src, 'stderr', dist)
  self
end

#transfer_stdin(dist, src = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3154

def transfer_stdin(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'transfer', src, 'stdin', dist)
  self
end

#transfer_stdio(dist, src = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3196

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

#transfer_stdout(dist, src = '') ⇒ `Object`

Raises:

(SecurityError)

# File 'lib/multi-tk.rb', line 3164

def transfer_stdout(dist, src = '')
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'transfer', src, 'stdout', dist)
  self
end

#wait_on_mainloop=(bool) ⇒ `Object`



369
370
371

# File 'lib/multi-tk.rb', line 369

def wait_on_mainloop=(bool)
  @wait_on_mainloop[0] = bool
end

#wait_on_mainloop? ⇒ `Boolean`

Returns:

(Boolean)



366
367
368

# File 'lib/multi-tk.rb', line 366

def wait_on_mainloop?
  @wait_on_mainloop[0]
end

Class: MultiTkIp

Overview

Direct Known Subclasses

Constant Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(master, safeip = true, keys = {}) ⇒ MultiTkIp

Class Method Details

.__getip ⇒ Object

._conv_listelement(arg) ⇒ Object

._create_console ⇒ Object

._DEFAULT_MASTER ⇒ Object

._eval(str) ⇒ Object

._eval_with_enc(str) ⇒ Object

._eval_without_enc(str) ⇒ Object

._fromUTF8(str, encoding = nil) ⇒ Object

._get_global_var(var) ⇒ Object

._get_global_var2(var, idx) ⇒ Object

._get_variable(var, flag) ⇒ Object

._get_variable2(var, idx, flag) ⇒ Object

._invoke(*args) ⇒ Object

._invoke_with_enc(*args) ⇒ Object

._invoke_without_enc(*args) ⇒ Object

._ip_id_ ⇒ Object

._IP_TABLE ⇒ Object

._make_menu_embeddable(menu_path) ⇒ Object

._merge_tklist(*args) ⇒ Object

._return_value ⇒ Object

._set_global_var(var, value) ⇒ Object

._set_global_var2(var, idx, value) ⇒ Object

._set_variable(var, value, flag) ⇒ Object

._set_variable2(var, idx, value, flag) ⇒ Object

._split_tklist(str) ⇒ Object

._thread_tkwait(mode, target) ⇒ Object

._thread_vwait(var) ⇒ Object

._TK_TABLE_LIST ⇒ Object

._toUTF8(str, encoding = nil) ⇒ Object

._unset_global_var(var) ⇒ Object

._unset_global_var2(var, idx) ⇒ Object

._unset_variable(var, flag) ⇒ Object

._unset_variable2(var, idx, flag) ⇒ Object

.abort(msg = nil) ⇒ Object

.add_tk_procs(name, args = nil, body = nil) ⇒ Object

.alias_delete(slave, cmd_name) ⇒ Object

.alias_info(slave, cmd_name) ⇒ Object

.alias_target(aliascmd, slave = '') ⇒ Object

.aliases(slave = '') ⇒ Object

.alive? ⇒ Boolean

.allow_ruby_exit=(mode) ⇒ Object

.allow_ruby_exit? ⇒ Boolean

.bg_eval(*args, &blk) ⇒ Object Also known as: background_eval

.bg_eval_proc(*args, &blk) ⇒ Object Also known as: background_eval_proc, thread_eval_proc, bg_call, background_call

.bg_eval_string(cmd, *eval_args) ⇒ Object Also known as: background_eval_string, bg_eval_str, background_eval_str

.bgerror(slave = '') ⇒ Object

.cb_entry_class ⇒ Object

.create_table ⇒ Object

.def_alias(slave, new_cmd, org_cmd, *args) ⇒ Object

.delete ⇒ Object

.delete_cmd(slave, cmd) ⇒ Object

.delete_slaves(*args) ⇒ Object

.deleted? ⇒ Boolean

.do_one_event(flag = TclTkLib::EventFlag::ALL) ⇒ Object

.encoding_table ⇒ Object

.eval(*args, &blk) ⇒ Object

.eval_proc(*args, &blk) ⇒ Object Also known as: call

.eval_string(cmd, *eval_args) ⇒ Object Also known as: eval_str

.exist?(slave = '') ⇒ Boolean

.exit(st = true) ⇒ Object

.exit!(st = false) ⇒ Object

.expose_cmd(slave, cmd, aliasname = nil) ⇒ Object

.get_cb_entry(cmd) ⇒ Object

.get_eventloop_tick ⇒ Object

.get_eventloop_weight ⇒ Object

.get_limit(limit_type, slave = '', slot = nil) ⇒ Object

.get_no_event_wait ⇒ Object

.has_mainwindow? ⇒ Boolean

.hidden_cmds(slave = '') ⇒ Object

.hide_cmd(slave, cmd, aliasname = nil) ⇒ Object

.inherited(subclass) ⇒ Object

#initialize(master, safeip = true, keys = {}) ⇒ `MultiTkIp`

.__getip ⇒ `Object`

._conv_listelement(arg) ⇒ `Object`

._create_console ⇒ `Object`

._DEFAULT_MASTER ⇒ `Object`

._eval(str) ⇒ `Object`

._eval_with_enc(str) ⇒ `Object`

._eval_without_enc(str) ⇒ `Object`

._fromUTF8(str, encoding = nil) ⇒ `Object`

._get_global_var(var) ⇒ `Object`

._get_global_var2(var, idx) ⇒ `Object`

._get_variable(var, flag) ⇒ `Object`

._get_variable2(var, idx, flag) ⇒ `Object`

._invoke(*args) ⇒ `Object`

._invoke_with_enc(*args) ⇒ `Object`

._invoke_without_enc(*args) ⇒ `Object`

._ip_id_ ⇒ `Object`

._IP_TABLE ⇒ `Object`

._make_menu_embeddable(menu_path) ⇒ `Object`

._merge_tklist(*args) ⇒ `Object`

._return_value ⇒ `Object`

._set_global_var(var, value) ⇒ `Object`

._set_global_var2(var, idx, value) ⇒ `Object`

._set_variable(var, value, flag) ⇒ `Object`

._set_variable2(var, idx, value, flag) ⇒ `Object`

._split_tklist(str) ⇒ `Object`

._thread_tkwait(mode, target) ⇒ `Object`

._thread_vwait(var) ⇒ `Object`

._TK_TABLE_LIST ⇒ `Object`

._toUTF8(str, encoding = nil) ⇒ `Object`

._unset_global_var(var) ⇒ `Object`

._unset_global_var2(var, idx) ⇒ `Object`

._unset_variable(var, flag) ⇒ `Object`

._unset_variable2(var, idx, flag) ⇒ `Object`

.abort(msg = nil) ⇒ `Object`

.add_tk_procs(name, args = nil, body = nil) ⇒ `Object`

.alias_delete(slave, cmd_name) ⇒ `Object`

.alias_info(slave, cmd_name) ⇒ `Object`

.alias_target(aliascmd, slave = '') ⇒ `Object`

.aliases(slave = '') ⇒ `Object`

.alive? ⇒ `Boolean`

.allow_ruby_exit=(mode) ⇒ `Object`

.allow_ruby_exit? ⇒ `Boolean`

.bg_eval(*args, &blk) ⇒ `Object` Also known as: background_eval

.bg_eval_proc(*args, &blk) ⇒ `Object` Also known as: background_eval_proc, thread_eval_proc, bg_call, background_call

.bg_eval_string(cmd, *eval_args) ⇒ `Object` Also known as: background_eval_string, bg_eval_str, background_eval_str

.bgerror(slave = '') ⇒ `Object`

.cb_entry_class ⇒ `Object`

.create_table ⇒ `Object`

.def_alias(slave, new_cmd, org_cmd, *args) ⇒ `Object`

.delete ⇒ `Object`

.delete_cmd(slave, cmd) ⇒ `Object`

.delete_slaves(*args) ⇒ `Object`

.deleted? ⇒ `Boolean`

.do_one_event(flag = TclTkLib::EventFlag::ALL) ⇒ `Object`

.encoding_table ⇒ `Object`

.eval(*args, &blk) ⇒ `Object`

.eval_proc(*args, &blk) ⇒ `Object` Also known as: call

.eval_string(cmd, *eval_args) ⇒ `Object` Also known as: eval_str

.exist?(slave = '') ⇒ `Boolean`

.exit(st = true) ⇒ `Object`

.exit!(st = false) ⇒ `Object`

.expose_cmd(slave, cmd, aliasname = nil) ⇒ `Object`

.get_cb_entry(cmd) ⇒ `Object`

.get_eventloop_tick ⇒ `Object`

.get_eventloop_weight ⇒ `Object`

.get_limit(limit_type, slave = '', slot = nil) ⇒ `Object`

.get_no_event_wait ⇒ `Object`

.has_mainwindow? ⇒ `Boolean`

.hidden_cmds(slave = '') ⇒ `Object`

.hide_cmd(slave, cmd, aliasname = nil) ⇒ `Object`

.inherited(subclass) ⇒ `Object`

.init_ip_env(script = Proc.new) ⇒ `Object`

.init_ip_internal ⇒ `Object`

.invalid_namespace? ⇒ `Boolean`

.invoke_hidden(slave, cmd, *args) ⇒ `Object`

.invoke_hidden_on_global(slave, cmd, *args) ⇒ `Object`

.invoke_hidden_on_namespace(slave, ns, cmd, *args) ⇒ `Object`

.ip_name ⇒ `Object`

.mainloop(check_root = true) ⇒ `Object`