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/multi-tk.rb,
lib/remote-tk.rb,
lib/remote-tk.rb

Overview

check Ruby 1.9 !!!!!!!

Direct Known Subclasses

RemoteTkIp

Defined Under Namespace

Classes: Command_Queue

Constant Summary collapse

BASE_DIR =

File.dirname(__FILE__)

WITH_RUBY_VM =

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

WITH_ENCODING =

defined?(::Encoding.default_external)

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

false

INTERP_THREAD =

@@DEFAULT_MASTER.instance_variable_get('@interp_thread')

INTERP_THREAD_STATUS =

INTERP_MUTEX =

INTERP_ROOT_CHECK =

@@IP_TABLE =

{}

@@INIT_IP_ENV = table of Procs

[]

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

[]

@@TK_TABLE_LIST =

[]

@@TK_CMD_TBL =

Object.new

@@CB_ENTRY_CLASS =

Class.new(TkCallbackEntry){
  def initialize(ip, cmd)
    @ip = ip
    @safe = safe = 0
    # @cmd = cmd
    cmd = MultiTkIp._proc_on_safelevel(&cmd)
    @cmd = proc{|*args| cmd.call(safe, *args)}
    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

@@CALLBACK_SUBTHREAD =

Class.new(Thread){
  def self.new(interp, &blk)
    super(interp){|ip| Thread.current[:callback_ip] = ip; blk.call}
  end
   @table = Hash.new{|h,k| h[k] = []}
  def self.table
    @table
  end
}

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 1255

def initialize(master, safeip=true, keys={})
  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 = []
  @callback_status = []

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

  safe = 1 if safe && !safe.kind_of?(Integer)

  @safe_base = false

  if safeip == nil
    # create master-ip
    unless WITH_RUBY_VM
      @interp = TclTkIp.new(name, _keys2opts(tk_opts))
      @interp.instance_eval{
        @force_default_encoding ||= [false]
        @encoding ||= [nil]
        def @encoding.to_s; self.join(nil); end
      }

    else ### Ruby 1.9 !!!!!!!!!!!
      @interp_thread = Thread.new{
        current = Thread.current
        begin
          current[:interp] = interp = TclTkIp.new(name, _keys2opts(tk_opts))
        rescue e
          current[:interp] = e
          raise e
        end
        #sleep
        #TclTkLib.mainloop(true)
        current[:mutex] = mutex = Mutex.new
        current[:root_check] = cond_ver = ConditionVariable.new

        status = [nil]
        def status.value
          self[0]
        end
        def status.value=(val)
          self[0] = val
        end
        current[:status] = status

        begin
          begin
            current[:status].value = interp.mainloop(true)
          rescue SystemExit=>e
            current[:status].value = e
          rescue Exception=>e
            current[:status].value = e
            retry if interp.has_mainwindow?
          ensure
            mutex.synchronize{ cond_var.broadcast }
          end
          current[:status].value = interp.mainloop(false)
        ensure
          interp.delete
        end
      }
      until @interp_thread[:interp]
        Thread.pass
      end
      # INTERP_THREAD.run
      @interp = @interp_thread[:interp]

      @evloop_thread[0] = @interp_thread

      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
    end

    @interp.instance_eval{
      @force_default_encoding ||= [false]
      @encoding ||= [nil]
      def @encoding.to_s; self.join(nil); end
    }

    @ip_name = nil

  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 !!!!!!!!!!!
    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 !!!!!!!!!!!
    end
    @set_alias_proc = proc{|name|
      master._invoke('interp', 'alias', @ip_name, name, '', name)
    }.freeze
  end

  @system = Object.new

  @wait_on_mainloop = [true, 0]

  @threadgroup  = ThreadGroup.new

  @pseudo_toplevel = [false, nil]

  @cmd_queue = MultiTkIp::Command_Queue.new(@interp)

  @@DEFAULT_MASTER.assign_receiver_and_watchdog(self)

  @@IP_TABLE[@threadgroup] = self
  @@TK_TABLE_LIST.size.times{
    @tk_table_list << {}
  }
  _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 1460

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

._conv_listelement(arg) ⇒ `Object`



2453
2454
2455

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

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

._create_console ⇒ `Object`



2457
2458
2459

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

def _create_console
  __getip._create_console
end

._DEFAULT_MASTER ⇒ `Object`

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

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

._eval(str) ⇒ `Object`



2361
2362
2363

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

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

._eval_with_enc(str) ⇒ `Object`



2377
2378
2379

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

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

._eval_without_enc(str) ⇒ `Object`



2369
2370
2371

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

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

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



2389
2390
2391

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

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

._get_global_var(var) ⇒ `Object`



2424
2425
2426

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

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

._get_global_var2(var, idx) ⇒ `Object`



2427
2428
2429

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

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

._get_variable(var, flag) ⇒ `Object`



2405
2406
2407

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

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

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



2408
2409
2410

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

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

._invoke(*args) ⇒ `Object`



2365
2366
2367

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

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

._invoke_with_enc(*args) ⇒ `Object`



2381
2382
2383

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

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

._invoke_without_enc(*args) ⇒ `Object`



2373
2374
2375

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

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

._ip_id_ ⇒ `Object`



1452
1453
1454

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

def self._ip_id_
  __getip._ip_id_
end

._IP_TABLE ⇒ `Object`

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

._make_menu_embeddable(menu_path) ⇒ `Object`



2443
2444
2445

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

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

._merge_tklist(*args) ⇒ `Object`



2450
2451
2452

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

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

._proc_on_current_safelevel(cmd = nil, &blk) ⇒ `Object`



1966
1967
1968

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

def MultiTkIp._proc_on_current_safelevel(cmd=nil, &blk)
  MultiTkIp.__getip._proc_on_current_safelevel(cmd, &blk)
end

._proc_on_safelevel(cmd = nil, &blk) ⇒ `Object`



1958
1959
1960

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

def MultiTkIp._proc_on_safelevel(cmd=nil, &blk)
  MultiTkIp.__getip._proc_on_safelevel(cmd, &blk)
end

._return_value ⇒ `Object`



2401
2402
2403

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

def _return_value
  __getip._return_value
end

._set_global_var(var, value) ⇒ `Object`



2430
2431
2432

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

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

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



2433
2434
2435

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

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

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



2411
2412
2413

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

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

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



2414
2415
2416

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

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

._split_tklist(str) ⇒ `Object`



2447
2448
2449

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

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

._thread_tkwait(mode, target) ⇒ `Object`



2397
2398
2399

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

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

._thread_vwait(var) ⇒ `Object`



2393
2394
2395

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

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

._TK_TABLE_LIST ⇒ `Object`

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

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



2385
2386
2387

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

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

._unset_global_var(var) ⇒ `Object`



2436
2437
2438

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

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

._unset_global_var2(var, idx) ⇒ `Object`



2439
2440
2441

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

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

._unset_variable(var, flag) ⇒ `Object`



2417
2418
2419

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

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

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



2420
2421
2422

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

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

.abort(msg = nil) ⇒ `Object`



2338
2339
2340

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

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

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

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

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 2968

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

.alias_info(slave, cmd_name) ⇒ `Object`



2959
2960
2961

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

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

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



3200
3201
3202

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

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

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



2988
2989
2990

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

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

.alive? ⇒ `Boolean`

Returns:

(Boolean)



1613
1614
1615

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

def self.alive?
  __getip.alive?
end

.allow_ruby_exit=(mode) ⇒ `Object`



2318
2319
2320

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

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

.allow_ruby_exit? ⇒ `Boolean`

Returns:

(Boolean)



2314
2315
2316

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

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 2239

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 2212

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 2227

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

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



3142
3143
3144

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

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

.cb_entry_class ⇒ `Object`



1832
1833
1834

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

def self.cb_entry_class
  @@CB_ENTRY_CLASS
end

.create_table ⇒ `Object`

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

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 2979

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

.default_encoding ⇒ `Object`



3398
3399
3400

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

def encoding_name
  __getip.encoding_name
end

.default_encoding=(enc) ⇒ `Object`



3382
3383
3384

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

def default_encoding=(enc)
  __getip.default_encoding=(enc)
end

.default_master? ⇒ `Boolean`

Returns:

(Boolean)



2250
2251
2252

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

def self.default_master?
  __getip == @@DEFAULT_MASTER
end

.delete ⇒ `Object`



2322
2323
2324

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

def delete
  __getip.delete
end

.delete_cmd(slave, cmd) ⇒ `Object`

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

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

.delete_slaves(*args) ⇒ `Object`

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

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

.deleted? ⇒ `Boolean`

Returns:

(Boolean)



2326
2327
2328

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

def deleted?
  __getip.deleted?
end

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



2261
2262
2263

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

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

.encoding ⇒ `Object`



3397
3398
3399

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

def encoding_name
  __getip.encoding_name
end

.encoding=(enc) ⇒ `Object`



3386
3387
3388

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

def encoding=(enc)
  __getip.encoding=(enc)
end

.encoding_convert_from ⇒ `Object`



3403
3404
3405

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

def encoding_convertfrom(str, enc=None)
  __getip.encoding_convertfrom(str, enc)
end

.encoding_convert_to ⇒ `Object`



3408
3409
3410

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

def encoding_convertto(str, enc=None)
  __getip.encoding_convertto(str, enc)
end

.encoding_convertfrom(str, enc = None) ⇒ `Object`



3400
3401
3402

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

def encoding_convertfrom(str, enc=None)
  __getip.encoding_convertfrom(str, enc)
end

.encoding_convertto(str, enc = None) ⇒ `Object`



3405
3406
3407

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

def encoding_convertto(str, enc=None)
  __getip.encoding_convertto(str, enc)
end

.encoding_name ⇒ `Object`



3390
3391
3392

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

def encoding_name
  __getip.encoding_name
end

.encoding_obj ⇒ `Object`



3394
3395
3396

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

def encoding_obj
  __getip.encoding_obj
end

.encoding_table ⇒ `Object`



3370
3371
3372

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

def encoding_table
  __getip.encoding_table
end

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

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

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 2206

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 2221

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

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

Returns:

(Boolean)



3008
3009
3010

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

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

.exit(st = true) ⇒ `Object`



2342
2343
2344

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

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

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



2346
2347
2348

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

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

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

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

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

.force_default_encoding=(mode) ⇒ `Object`



3374
3375
3376

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

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

.force_default_encoding? ⇒ `Boolean`

Returns:

(Boolean)



3378
3379
3380

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

def force_default_encoding?
  __getip.force_default_encoding?
end

.get_cb_entry(cmd) ⇒ `Object`



1835
1836
1837

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

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

.get_eventloop_tick ⇒ `Object`



2275
2276
2277

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

def get_eventloop_tick
  __getip.get_eventloop_tick
end

.get_eventloop_weight ⇒ `Object`



2287
2288
2289

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

def get_eventloop_weight
  __getip.get_eventloop_weight
end

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



3183
3184
3185

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

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

.get_no_event_wait ⇒ `Object`



2281
2282
2283

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

def get_no_event_wait
  __getip.get_no_event_wait
end

.has_mainwindow? ⇒ `Boolean`

Returns:

(Boolean)



2330
2331
2332

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

def has_mainwindow?
  __getip.has_mainwindow?
end

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



3055
3056
3057

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

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

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

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

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 970

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

.init_ip_env(script = nil, &block) ⇒ `Object`

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

def self.init_ip_env(script = nil, &block)
  script ||= block
  @@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`



1825
1826
1827

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

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

.invalid_namespace? ⇒ `Boolean`

Returns:

(Boolean)



2334
2335
2336

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

def invalid_namespace?
  __getip.invalid_namespace?
end

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



3075
3076
3077

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

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

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



3096
3097
3098

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

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`



3114
3115
3116

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

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

.ip_name ⇒ `Object`



1626
1627
1628

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

def self.ip_name
  __getip.ip_name
end

.mainloop(check_root = true) ⇒ `Object`



2255
2256
2257

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

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

.mainloop_abort_on_exception ⇒ `Object`

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

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 2268

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`



2258
2259
2260

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

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

.make_safe ⇒ `Object`



2298
2299
2300

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

def make_safe
  __getip.make_safe
end

.manipulable? ⇒ `Boolean`

Returns:

(Boolean)



1657
1658
1659

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

def self.manipulable?
  true
end

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

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

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

.master? ⇒ `Boolean`

Returns:

(Boolean)



1591
1592
1593

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

def self.master?
  __getip.master?
end

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



2294
2295
2296

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

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

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

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

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)
  if block_given?
    ip._proc_on_safelevel(&blk).call(0)
  end
  ip
end

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

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

def new_safe_slave(safe=1, 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)
  if block_given?
    ip._proc_on_safelevel(&blk).call(0)
  end
  ip
end

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

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

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)
  if block_given?
    ip._proc_on_safelevel(&blk).call(0)
  end
  ip
end

.path ⇒ `Object`



1620
1621
1622

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

def self.path
  __getip.path
end

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



3192
3193
3194

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

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

.remove_tk_procs(*names) ⇒ `Object`

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

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 2350

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)



2302
2303
2304

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

def safe?
  __getip.safe?
end

.safe_base? ⇒ `Boolean`

Returns:

(Boolean)

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

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

.safe_level ⇒ `Object`



331
332
333

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

def self.safe_level
  0
end

.safe_level=(safe) ⇒ `Object`



325
326
327

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

def self.safe_level=(safe)
  0
end

.set_eventloop_tick(tick) ⇒ `Object`



2272
2273
2274

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

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

.set_eventloop_weight(loop_max, no_event_tick) ⇒ `Object`



2284
2285
2286

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

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`



3158
3159
3160

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

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

.set_no_event_wait(tick) ⇒ `Object`



2278
2279
2280

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

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

.set_safe_level(safe) ⇒ `Object`



322
323
324

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

def self.set_safe_level(safe)
  0
end

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

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

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

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

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

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

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

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

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

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

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

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

.slave? ⇒ `Boolean`

Returns:

(Boolean)



1598
1599
1600

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

def self.slave?
  not self.master?
end

.slaves(all = false) ⇒ `Object`



1648
1649
1650

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

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

.tk_cmd_tbl ⇒ `Object`



1734
1735
1736

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

def self.tk_cmd_tbl
  @@TK_CMD_TBL
end

.tk_object_table(id) ⇒ `Object`



1740
1741
1742

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

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

.tk_windows ⇒ `Object`



1737
1738
1739

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

def self.tk_windows
  __getip._tk_windows
end

.to_eval ⇒ `Object`



1632
1633
1634

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

def self.to_eval
  __getip.to_eval
end

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

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

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

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

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

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

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

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

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

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

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

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 1177

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 ||= [false]
    @encoding ||= [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

#__create_trusted_slave_obj(name, keys) ⇒ `Object`

Raises:

(SecurityError)

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

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 ||= [false]
    @encoding ||= [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

#__eval(str) ⇒ `Object`

Raises:

(SecurityError)

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

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 2780

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 1850

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 1856

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 1880

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 1872

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 1684

def _add_new_tables
  (@@TK_TABLE_LIST.size - @tk_table_list.size).times{
    @tk_table_list << {}
  }
end

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

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

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 2903

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 1246

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 1409

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("Warning: fail to call '::safe::disallowTk'") if $DEBUG
      end
    else # toplevel path
      begin
        @interp._eval("::safe::tkDelete {} #{top} #{slave}")
      rescue
        warn("Warning: fail to call '::safe::tkDelete'") if $DEBUG
        begin
          @interp._eval("destroy #{top}")
        rescue
          warn("Warning: fail to destroy toplevel") if $DEBUG
        end
      end
    end
  end
end

#_destroy_slaves_of_slaveIP(ip) ⇒ `Object`

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

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 2785

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 2805

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 2795

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 2820

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 2865

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 2869

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 2840

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 2844

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`



1690
1691
1692

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

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 1718

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 2790

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 2810

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 2800

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 1455

def _ip_id_
  # for RemoteTkIp
  ''
end

#_make_menu_embeddable(menu_path) ⇒ `Object`

Raises:

(SecurityError)

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

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 2899

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

#_proc_on_current_safelevel(cmd = nil, &blk) ⇒ `Object`

require a block for eval

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

def _proc_on_current_safelevel(cmd=nil, &blk) # require a block for eval
  cmd = _proc_on_safelevel(cmd, &blk)
  Proc.new{|*args| cmd.call(0, *args)}
end

#_proc_on_safelevel(cmd = nil) ⇒ `Object`

instance & class method

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

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|
      yield(*args)
    }
  end
end

#_receiver_mainloop(check_root) ⇒ `Object`

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

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 1702

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 2835

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 2873

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 2877

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 2848

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 2852

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 2895

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 2830

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 2825

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 1670

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`



1680
1681
1682

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

def _tk_table_list
  @tk_table_list
end

#_tk_windows ⇒ `Object`



1676
1677
1678

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

def _tk_windows
  @tk_windows
end

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

Raises:

(SecurityError)

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

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 2881

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 2885

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 2856

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 2860

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 2727

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 2963

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 2955

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 3196

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 2984

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 1602

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 2644

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 2639

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 2143

def bg_eval_proc(*args, &block)
  if block
    cmd = block
  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)
  }
end

#background_eval ⇒ `Object`

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

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 2140

def bg_eval_proc(*args, &block)
  if block
    cmd = block
  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)
  }
end

#background_eval_str ⇒ `Object`

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

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(cmd, *eval_args)
                   })
  }
end

#background_eval_string ⇒ `Object`

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

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(cmd, *eval_args)
                   })
  }
end

#bg_call ⇒ `Object`

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

def bg_eval_proc(*args, &block)
  if block
    cmd = block
  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)
  }
end

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

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

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, &block) ⇒ `Object`

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

def bg_eval_proc(*args, &block)
  if block
    cmd = block
  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)
  }
end

#bg_eval_str ⇒ `Object`

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

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(cmd, *eval_args)
                   })
  }
end

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

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

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(cmd, *eval_args)
                   })
  }
end

#call ⇒ `Object`

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

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

#cb_error(e) ⇒ `Object`

# File '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

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

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

def cb_eval(cmd, *args)
  self.eval_callback(*args,
                     &_proc_on_safelevel{|*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 2973

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 3424

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 2649

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 3012

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 2992

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 2712

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 3429

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 3444

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 3450

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 3433

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 3437

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

#encoding_table ⇒ `Object`



3411
3412
3413

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

def encoding_table
  @interp.encoding_table
end

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

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

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, &block) ⇒ `Object`

Ruby 1.8

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

def eval_callback(*args, &block)
  cmd = block || args.shift
  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

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

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

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

#eval_str ⇒ `Object`

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

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(cmd, *eval_args)
                 })
end

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

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

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(cmd, *eval_args)
                 })
end

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

Returns:

(Boolean)

Raises:

(SecurityError)

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

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 2742

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 2752

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 3023

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 3415

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 3419

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 3146

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 3162

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 2717

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 3051

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 3037

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 1562

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 2722

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 3059

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 3079

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 3100

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`



1623
1624
1625

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

def ip_name
  @ip_name || ''
end

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

def mainloop(check_root = true, restart_on_dead = true)

Raises:

(SecurityError)

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

def mainloop(check_root = true, restart_on_dead = false)
  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
        @cmd_queue.enq([@system, 'call_mainloop',
                        Thread.current, check_root])
        Thread.stop
      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: " + e.inspect + " 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 2624

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 1652

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 3118

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 1584

def master?
  if @ip_name
    false
  else
    true
  end
end

#path ⇒ `Object`



1617
1618
1619

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

def path
  @ip_name || ''
end

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

Raises:

(SecurityError)

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

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 2762

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)



342
343
344

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

def running_mainloop?
  @wait_on_mainloop[1] > 0
end

#safe? ⇒ `Boolean`

Returns:

(Boolean)

Raises:

(SecurityError)

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

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 2634

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

#safe_level ⇒ `Object`



328
329
330

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

def safe_level
  0
end

#safe_level=(safe) ⇒ `Object`



319
320
321

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

def safe_level=(safe)
  0
end

#safeip_add_to_access_path(dir) ⇒ `Object`

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

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 3305

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 3292

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 3345

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 3355

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

#safeip_set_log_cmd(cmd = nil, &block) ⇒ `Object`

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

def safeip_set_log_cmd(cmd = nil, &block)
  cmd ||= block
  ip = MultiTkIp.__getip
  ip._eval("::safe::setLogCmd #{@ip_name} #{_get_eval_string(cmd)}")
end

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

Raises:

(SecurityError)

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

def set_bgerror_handler(cmd = nil, slave = nil, &b)
  cmd ||= b
  raise SecurityError, "no permission to manipulate" unless self.manipulable?

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

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

#set_cb_error(cmd = nil, &block) ⇒ `Object`



304
305
306

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

def set_cb_error(cmd = nil, &block)
  @cb_error_proc[0] = cmd || block
end

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

Raises:

(SecurityError)

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

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`



316
317
318

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

def set_safe_level(safe)
  0
end

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

Raises:

(SecurityError)

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

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 3204

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 3264

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 3214

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)



1595
1596
1597

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

def slave?
  not master?
end

#slaves(all = false) ⇒ `Object`

Raises:

(SecurityError)

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

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 2141

def bg_eval_proc(*args, &block)
  if block
    cmd = block
  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)
  }
end

#to_eval ⇒ `Object`



1629
1630
1631

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

def to_eval
  @ip_name || ''
end

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

Raises:

(SecurityError)

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

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 3234

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 3276

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 3244

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`



338
339
340

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

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

#wait_on_mainloop? ⇒ `Boolean`

Returns:

(Boolean)



335
336
337

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

def wait_on_mainloop?
  @wait_on_mainloop[0]
end

Class: MultiTkIp

Overview

Direct Known Subclasses

Defined Under Namespace

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

._proc_on_current_safelevel(cmd = nil, &blk) ⇒ Object

._proc_on_safelevel(cmd = nil, &blk) ⇒ 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

.default_encoding ⇒ Object

.default_encoding=(enc) ⇒ Object

.default_master? ⇒ Boolean

.delete ⇒ Object

.delete_cmd(slave, cmd) ⇒ Object

.delete_slaves(*args) ⇒ Object

.deleted? ⇒ Boolean

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

.encoding ⇒ Object

.encoding=(enc) ⇒ Object

.encoding_convert_from ⇒ Object

.encoding_convert_to ⇒ Object

.encoding_convertfrom(str, enc = None) ⇒ Object

.encoding_convertto(str, enc = None) ⇒ Object

.encoding_name ⇒ Object

.encoding_obj ⇒ Object

.encoding_table ⇒ Object

.eval(*args, &blk) ⇒ Object

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

#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`

._proc_on_current_safelevel(cmd = nil, &blk) ⇒ `Object`

._proc_on_safelevel(cmd = nil, &blk) ⇒ `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`

.default_encoding ⇒ `Object`

.default_encoding=(enc) ⇒ `Object`

.default_master? ⇒ `Boolean`

.delete ⇒ `Object`

.delete_cmd(slave, cmd) ⇒ `Object`

.delete_slaves(*args) ⇒ `Object`

.deleted? ⇒ `Boolean`

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

.encoding ⇒ `Object`

.encoding=(enc) ⇒ `Object`

.encoding_convert_from ⇒ `Object`

.encoding_convert_to ⇒ `Object`

.encoding_convertfrom(str, enc = None) ⇒ `Object`

.encoding_convertto(str, enc = None) ⇒ `Object`

.encoding_name ⇒ `Object`

.encoding_obj ⇒ `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`

.force_default_encoding=(mode) ⇒ `Object`

.force_default_encoding? ⇒ `Boolean`

.get_cb_entry(cmd) ⇒ `Object`

.get_eventloop_tick ⇒ `Object`