Class: MultiTkIp

Inherits:
Object 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_THREAD[:status]
INTERP_MUTEX = 
INTERP_THREAD[:mutex]
INTERP_ROOT_CHECK = 
INTERP_THREAD[:root_check]
@@IP_TABLE = 
TkUtil.untrust({})
@@INIT_IP_ENV =

table of Procs

TkUtil.untrust([])
@@ADD_TK_PROCS =

table of [name, args, body]

TkUtil.untrust([])
@@TK_TABLE_LIST = 
TkUtil.untrust([])
@@TK_CMD_TBL = 
TkUtil.untrust(Object.new)
@@CB_ENTRY_CLASS = 
Class.new(TkCallbackEntry){
  def initialize(ip, cmd)
    @ip = ip
    @safe = safe = $SAFE
    # @cmd = cmd
    cmd = MultiTkIp._proc_on_safelevel(&cmd)
    @cmd = proc{|*args| cmd.call(safe, *args)}
    self.freeze
  end
  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 = TkUtil.untrust(Hash.new{|h,k| h[k] = TkUtil.untrust([])})
  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.



1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
 
# File 'lib/multi-tk.rb', line 1268

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 = []

  TkUtil.untrust(@tk_windows)    unless @tk_windows.tainted?
  TkUtil.untrust(@tk_table_list) unless @tk_table_list.tainted?
  TkUtil.untrust(@slave_ip_tbl)  unless @slave_ip_tbl.tainted?
  TkUtil.untrust(@slave_ip_top)  unless @slave_ip_top.tainted?
  TkUtil.untrust(@cb_error_proc) unless @cb_error_proc.tainted?
  TkUtil.untrust(@evloop_thread) unless @evloop_thread.tainted?

  @callback_status = []

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

  safe = 1 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))
      @interp.instance_eval{
        @force_default_encoding ||= TkUtil.untrust([false])
        @encoding ||= TkUtil.untrust([nil])
        def @encoding.to_s; self.join(nil); end
      }

    else ### Ruby 1.9 !!!!!!!!!!!
=begin
      @interp_thread = Thread.new{
        Thread.current[:interp] = interp = TclTkIp.new(name, _keys2opts(tk_opts))
        interp.instance_eval{
          @force_default_encoding ||= TkUtil.untrust([false])
          @encoding ||= TkUtil.untrust([nil])
          def @encoding.to_s; self.join(nil); end
        }

        #sleep
        TclTkLib.mainloop(true)
      }
      until @interp_thread[:interp]
        Thread.pass
      end
      # INTERP_THREAD.run
      @interp = @interp_thread[:interp]
=end
      @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 ||= TkUtil.untrust([false])
      @encoding ||= TkUtil.untrust([nil])
      def @encoding.to_s; self.join(nil); 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 = [1]
      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 = TkUtil.untrust([true, 0])
  # @wait_on_mainloop = TkUtil.untrust([false, 0])

  @threadgroup  = ThreadGroup.new

  @pseudo_toplevel = [false, nil]

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

=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{
    @tk_table_list << TkUtil.untrust({})
  }
  _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 



1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
 
# File 'lib/multi-tk.rb', line 1527

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 



2676
2677
2678
 
# File 'lib/multi-tk.rb', line 2676

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

._create_console ⇒ Object 



2680
2681
2682
 
# File 'lib/multi-tk.rb', line 2680

def _create_console
  __getip._create_console
end

._DEFAULT_MASTER ⇒ Object 



20
21
22
23
24
25
26
27
28
 
# File 'lib/remote-tk.rb', line 20

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

._eval(str) ⇒ Object 



2584
2585
2586
 
# File 'lib/multi-tk.rb', line 2584

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

._eval_with_enc(str) ⇒ Object 



2600
2601
2602
 
# File 'lib/multi-tk.rb', line 2600

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

._eval_without_enc(str) ⇒ Object 



2592
2593
2594
 
# File 'lib/multi-tk.rb', line 2592

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

._fromUTF8(str, encoding = nil) ⇒ Object 



2612
2613
2614
 
# File 'lib/multi-tk.rb', line 2612

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

._get_global_var(var) ⇒ Object 



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

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

._get_global_var2(var, idx) ⇒ Object 



2650
2651
2652
 
# File 'lib/multi-tk.rb', line 2650

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

._get_variable(var, flag) ⇒ Object 



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

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

._get_variable2(var, idx, flag) ⇒ Object 



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

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

._invoke(*args) ⇒ Object 



2588
2589
2590
 
# File 'lib/multi-tk.rb', line 2588

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

._invoke_with_enc(*args) ⇒ Object 



2604
2605
2606
 
# File 'lib/multi-tk.rb', line 2604

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

._invoke_without_enc(*args) ⇒ Object 



2596
2597
2598
 
# File 'lib/multi-tk.rb', line 2596

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

._ip_id_ ⇒ Object 



1519
1520
1521
 
# File 'lib/multi-tk.rb', line 1519

def self._ip_id_
  __getip._ip_id_
end

._IP_TABLE ⇒ Object 



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

def self._IP_TABLE; @@IP_TABLE; end

._make_menu_embeddable(menu_path) ⇒ Object 



2666
2667
2668
 
# File 'lib/multi-tk.rb', line 2666

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

._merge_tklist(*args) ⇒ Object 



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

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

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



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

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 



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

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

._return_value ⇒ Object 



2624
2625
2626
 
# File 'lib/multi-tk.rb', line 2624

def _return_value
  __getip._return_value
end

._set_global_var(var, value) ⇒ Object 



2653
2654
2655
 
# File 'lib/multi-tk.rb', line 2653

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

._set_global_var2(var, idx, value) ⇒ Object 



2656
2657
2658
 
# File 'lib/multi-tk.rb', line 2656

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

._set_variable(var, value, flag) ⇒ Object 



2634
2635
2636
 
# File 'lib/multi-tk.rb', line 2634

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

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



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

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

._split_tklist(str) ⇒ Object 



2670
2671
2672
 
# File 'lib/multi-tk.rb', line 2670

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

._thread_tkwait(mode, target) ⇒ Object 



2620
2621
2622
 
# File 'lib/multi-tk.rb', line 2620

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

._thread_vwait(var) ⇒ Object 



2616
2617
2618
 
# File 'lib/multi-tk.rb', line 2616

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

._TK_TABLE_LIST ⇒ Object 



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

def self._TK_TABLE_LIST; @@TK_TABLE_LIST; end

._toUTF8(str, encoding = nil) ⇒ Object 



2608
2609
2610
 
# File 'lib/multi-tk.rb', line 2608

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

._unset_global_var(var) ⇒ Object 



2659
2660
2661
 
# File 'lib/multi-tk.rb', line 2659

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

._unset_global_var2(var, idx) ⇒ Object 



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

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

._unset_variable(var, flag) ⇒ Object 



2640
2641
2642
 
# File 'lib/multi-tk.rb', line 2640

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

._unset_variable2(var, idx, flag) ⇒ Object 



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

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

.abort(msg = nil) ⇒ Object 



2561
2562
2563
 
# File 'lib/multi-tk.rb', line 2561

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

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



1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
 
# File 'lib/multi-tk.rb', line 1876

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 



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

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

.alias_info(slave, cmd_name) ⇒ Object 



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

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

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



3422
3423
3424
 
# File 'lib/multi-tk.rb', line 3422

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

.aliases(slave = '') ⇒ Object 



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

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

.alive? ⇒ Boolean

Returns:

  • (Boolean) 


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

def self.alive?
  __getip.alive?
end

.allow_ruby_exit=(mode) ⇒ Object 



2541
2542
2543
 
# File 'lib/multi-tk.rb', line 2541

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

.allow_ruby_exit? ⇒ Boolean

Returns:

  • (Boolean) 


2537
2538
2539
 
# File 'lib/multi-tk.rb', line 2537

def allow_ruby_exit?
  __getip.allow_ruby_exit?
end

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



2462
2463
2464
2465
 
# File 'lib/multi-tk.rb', line 2462

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 



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

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 



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

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

.bgerror(slave = '') ⇒ Object 



3364
3365
3366
 
# File 'lib/multi-tk.rb', line 3364

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

.cb_entry_class ⇒ Object 



1907
1908
1909
 
# File 'lib/multi-tk.rb', line 1907

def self.cb_entry_class
  @@CB_ENTRY_CLASS
end

.create_table ⇒ Object 



1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
 
# File 'lib/multi-tk.rb', line 1819

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 



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

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 



3619
3620
3621
 
# File 'lib/multi-tk.rb', line 3619

def encoding_name
  __getip.encoding_name
end

.default_encoding=(enc) ⇒ Object 



3603
3604
3605
 
# File 'lib/multi-tk.rb', line 3603

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

.default_master? ⇒ Boolean

Returns:

  • (Boolean) 


2473
2474
2475
 
# File 'lib/multi-tk.rb', line 2473

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

.delete ⇒ Object 



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

def delete
  __getip.delete
end

.delete_cmd(slave, cmd) ⇒ Object 



3241
3242
3243
3244
 
# File 'lib/multi-tk.rb', line 3241

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

.delete_slaves(*args) ⇒ Object 



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

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

.deleted? ⇒ Boolean

Returns:

  • (Boolean) 


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

def deleted?
  __getip.deleted?
end

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



2484
2485
2486
 
# File 'lib/multi-tk.rb', line 2484

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

.encoding ⇒ Object 



3618
3619
3620
 
# File 'lib/multi-tk.rb', line 3618

def encoding_name
  __getip.encoding_name
end

.encoding=(enc) ⇒ Object 



3607
3608
3609
 
# File 'lib/multi-tk.rb', line 3607

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

.encoding_convert_from ⇒ Object 



3624
3625
3626
 
# File 'lib/multi-tk.rb', line 3624

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

.encoding_convert_to ⇒ Object 



3629
3630
3631
 
# File 'lib/multi-tk.rb', line 3629

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

.encoding_convertfrom(str, enc = None) ⇒ Object 



3621
3622
3623
 
# File 'lib/multi-tk.rb', line 3621

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

.encoding_convertto(str, enc = None) ⇒ Object 



3626
3627
3628
 
# File 'lib/multi-tk.rb', line 3626

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

.encoding_name ⇒ Object 



3611
3612
3613
 
# File 'lib/multi-tk.rb', line 3611

def encoding_name
  __getip.encoding_name
end

.encoding_obj ⇒ Object 



3615
3616
3617
 
# File 'lib/multi-tk.rb', line 3615

def encoding_obj
  __getip.encoding_obj
end

.encoding_table ⇒ Object 



3591
3592
3593
 
# File 'lib/multi-tk.rb', line 3591

def encoding_table
  __getip.encoding_table
end

.eval(*args, &blk) ⇒ Object 



2458
2459
2460
2461
 
# File 'lib/multi-tk.rb', line 2458

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

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

class method



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

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 



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

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

.exist?(slave = '') ⇒ Boolean

Returns:

  • (Boolean) 


3231
3232
3233
 
# File 'lib/multi-tk.rb', line 3231

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

.exit(st = true) ⇒ Object 



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

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

.exit!(st = false) ⇒ Object 



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

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

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



3255
3256
3257
3258
 
# File 'lib/multi-tk.rb', line 3255

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

.force_default_encoding=(mode) ⇒ Object 



3595
3596
3597
 
# File 'lib/multi-tk.rb', line 3595

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

.force_default_encoding? ⇒ Boolean

Returns:

  • (Boolean) 


3599
3600
3601
 
# File 'lib/multi-tk.rb', line 3599

def force_default_encoding?
  __getip.force_default_encoding?
end

.get_cb_entry(cmd) ⇒ Object 



1910
1911
1912
 
# File 'lib/multi-tk.rb', line 1910

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

.get_eventloop_tick ⇒ Object 



2498
2499
2500
 
# File 'lib/multi-tk.rb', line 2498

def get_eventloop_tick
  __getip.get_eventloop_tick
end

.get_eventloop_weight ⇒ Object 



2510
2511
2512
 
# File 'lib/multi-tk.rb', line 2510

def get_eventloop_weight
  __getip.get_eventloop_weight
end

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



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

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

.get_no_event_wait ⇒ Object 



2504
2505
2506
 
# File 'lib/multi-tk.rb', line 2504

def get_no_event_wait
  __getip.get_no_event_wait
end

.has_mainwindow? ⇒ Boolean

Returns:

  • (Boolean) 


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

def has_mainwindow?
  __getip.has_mainwindow?
end

.hidden_cmds(slave = '') ⇒ Object 



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

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

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



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

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

.inherited(subclass) ⇒ Object 



983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
 
# File 'lib/multi-tk.rb', line 983

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 = Proc.new) ⇒ Object 



1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
 
# File 'lib/multi-tk.rb', line 1853

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 



1900
1901
1902
 
# File 'lib/multi-tk.rb', line 1900

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

.invalid_namespace? ⇒ Boolean

Returns:

  • (Boolean) 


2557
2558
2559
 
# File 'lib/multi-tk.rb', line 2557

def invalid_namespace?
  __getip.invalid_namespace?
end

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



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

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

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



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

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 



3337
3338
3339
 
# File 'lib/multi-tk.rb', line 3337

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

.ip_name ⇒ Object 



1702
1703
1704
 
# File 'lib/multi-tk.rb', line 1702

def self.ip_name
  __getip.ip_name
end

.mainloop(check_root = true) ⇒ Object 



2478
2479
2480
 
# File 'lib/multi-tk.rb', line 2478

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

.mainloop_abort_on_exception ⇒ Object 



2487
2488
2489
2490
 
# File 'lib/multi-tk.rb', line 2487

def mainloop_abort_on_exception
  # __getip.mainloop_abort_on_exception
  TclTkLib.mainloop_abort_on_exception
end

.mainloop_abort_on_exception=(mode) ⇒ Object 



2491
2492
2493
2494
 
# File 'lib/multi-tk.rb', line 2491

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 



2481
2482
2483
 
# File 'lib/multi-tk.rb', line 2481

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

.make_safe ⇒ Object 



2521
2522
2523
 
# File 'lib/multi-tk.rb', line 2521

def make_safe
  __getip.make_safe
end

.manipulable? ⇒ Boolean

Returns:

  • (Boolean) 


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

def self.manipulable?
  true
end

.mark_trusted(slave = '') ⇒ Object 



3346
3347
3348
3349
 
# File 'lib/multi-tk.rb', line 3346

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

.master? ⇒ Boolean

Returns:

  • (Boolean) 


1667
1668
1669
 
# File 'lib/multi-tk.rb', line 1667

def self.master?
  __getip.master?
end

.method_missing(id, *args) ⇒ Object 



2517
2518
2519
 
# File 'lib/multi-tk.rb', line 2517

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

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



1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
 
# File 'lib/multi-tk.rb', line 1554

def new_master(safe=nil, keys={}, &blk)
  if MultiTkIp::WITH_RUBY_VM
    #### TODO !!!!!!
    fail RuntimeError,
         'sorry, still not support multiple master-interpreters on RubyVM'
  end

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

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

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



1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
 
# File 'lib/multi-tk.rb', line 1611

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)
  # ip.eval_proc(proc{$SAFE=ip.safe_level; Proc.new}.call) if block_given?
  if block_given?
    #Thread.new{ip.eval_proc(proc{$SAFE=ip.safe_level; Proc.new}.call)}
    #Thread.new{ip.eval_proc(proc{$SAFE=ip.safe_level; yield}.call)}
    ip._proc_on_safelevel(&blk).call(ip.safe_level)
  end
  ip
end

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



1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
 
# File 'lib/multi-tk.rb', line 1586

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

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

.path ⇒ Object 



1696
1697
1698
 
# File 'lib/multi-tk.rb', line 1696

def self.path
  __getip.path
end

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



3414
3415
3416
 
# File 'lib/multi-tk.rb', line 3414

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

.remove_tk_procs(*names) ⇒ Object 



1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
 
# File 'lib/multi-tk.rb', line 1888

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 



2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
 
# File 'lib/multi-tk.rb', line 2573

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) 


2525
2526
2527
 
# File 'lib/multi-tk.rb', line 2525

def safe?
  __getip.safe?
end

.safe_base? ⇒ Boolean

Returns:

  • (Boolean) 


2529
2530
2531
2532
2533
2534
2535
 
# File 'lib/multi-tk.rb', line 2529

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

.safe_level ⇒ Object 



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

def self.safe_level
  __getip.safe_level
end

.safe_level=(safe) ⇒ Object 



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

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

.set_eventloop_tick(tick) ⇒ Object 



2495
2496
2497
 
# File 'lib/multi-tk.rb', line 2495

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

.set_eventloop_weight(loop_max, no_event_tick) ⇒ Object 



2507
2508
2509
 
# File 'lib/multi-tk.rb', line 2507

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 



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

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

.set_no_event_wait(tick) ⇒ Object 



2501
2502
2503
 
# File 'lib/multi-tk.rb', line 2501

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

.set_safe_level(safe) ⇒ Object 



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

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

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



3451
3452
3453
3454
 
# File 'lib/multi-tk.rb', line 3451

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

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



3431
3432
3433
3434
 
# File 'lib/multi-tk.rb', line 3431

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

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



3493
3494
3495
3496
 
# File 'lib/multi-tk.rb', line 3493

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

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



3441
3442
3443
3444
 
# File 'lib/multi-tk.rb', line 3441

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

.slave? ⇒ Boolean

Returns:

  • (Boolean) 


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

def self.slave?
  not self.master?
end

.slaves(all = false) ⇒ Object 



1724
1725
1726
 
# File 'lib/multi-tk.rb', line 1724

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

.tk_cmd_tbl ⇒ Object 



1810
1811
1812
 
# File 'lib/multi-tk.rb', line 1810

def self.tk_cmd_tbl
  @@TK_CMD_TBL
end

.tk_object_table(id) ⇒ Object 



1816
1817
1818
 
# File 'lib/multi-tk.rb', line 1816

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

.tk_windows ⇒ Object 



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

def self.tk_windows
  __getip._tk_windows
end

.to_eval ⇒ Object 



1708
1709
1710
 
# File 'lib/multi-tk.rb', line 1708

def self.to_eval
  __getip.to_eval
end

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



3481
3482
3483
3484
 
# File 'lib/multi-tk.rb', line 3481

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

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



3461
3462
3463
3464
 
# File 'lib/multi-tk.rb', line 3461

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

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



3505
3506
3507
3508
 
# File 'lib/multi-tk.rb', line 3505

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

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



3471
3472
3473
3474
 
# File 'lib/multi-tk.rb', line 3471

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) 


1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
 
# File 'lib/multi-tk.rb', line 1190

def __create_safe_slave_obj(safe_opts, app_name, tk_opts)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?

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

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

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

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

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

  [slave_ip, ip_name]
end

#__create_trusted_slave_obj(name, keys) ⇒ Object

Raises:

  • (SecurityError) 


1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
 
# File 'lib/multi-tk.rb', line 1239

def __create_trusted_slave_obj(name, keys)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?

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

#__eval(str) ⇒ Object

Raises:

  • (SecurityError) 


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

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

#__invoke(*args) ⇒ Object

Raises:

  • (SecurityError) 


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

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

#__pseudo_toplevel ⇒ Object

instance method



1995
1996
1997
1998
1999
 
# File 'lib/multi-tk.rb', line 1995

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

#__pseudo_toplevel=(m) ⇒ Object 



2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
 
# File 'lib/multi-tk.rb', line 2001

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 



2025
2026
2027
2028
2029
2030
2031
2032
 
# File 'lib/multi-tk.rb', line 2025

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) 


2017
2018
2019
2020
2021
2022
2023
 
# File 'lib/multi-tk.rb', line 2017

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

#_add_new_tables ⇒ Object 



1760
1761
1762
1763
1764
 
# File 'lib/multi-tk.rb', line 1760

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

#_add_tk_procs(name, args, body) ⇒ Object 



1770
1771
1772
1773
1774
1775
1776
 
# File 'lib/multi-tk.rb', line 1770

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) 


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

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) 


1259
1260
1261
1262
1263
1264
 
# File 'lib/multi-tk.rb', line 1259

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) 


1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
 
# File 'lib/multi-tk.rb', line 1476

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 



351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
 
# File 'lib/multi-tk.rb', line 351

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) 


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

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

#_eval_with_enc(str) ⇒ Object

Raises:

  • (SecurityError) 


3028
3029
3030
3031
 
# File 'lib/multi-tk.rb', line 3028

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) 


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

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) 


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

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) 


3088
3089
3090
3091
 
# File 'lib/multi-tk.rb', line 3088

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) 


3092
3093
3094
3095
 
# File 'lib/multi-tk.rb', line 3092

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) 


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

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) 


3067
3068
3069
3070
 
# File 'lib/multi-tk.rb', line 3067

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 



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

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

#_init_ip_internal(init_ip_env, add_tk_procs) ⇒ Object 



1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
 
# File 'lib/multi-tk.rb', line 1794

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) 


3013
3014
3015
3016
 
# File 'lib/multi-tk.rb', line 3013

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

#_invoke_with_enc(*args) ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


3023
3024
3025
3026
 
# File 'lib/multi-tk.rb', line 3023

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

#_ip_id_ ⇒ Object 



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

def _ip_id_
  # for RemoteTkIp
  ''
end

#_make_menu_embeddable(menu_path) ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


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

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



2130
2131
2132
2133
2134
 
# File 'lib/multi-tk.rb', line 2130

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

#_proc_on_safelevel(cmd = nil) ⇒ Object

instance & class method



2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
 
# File 'lib/multi-tk.rb', line 2099

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

#_receiver_mainloop(check_root) ⇒ Object 



601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
 
# File 'lib/multi-tk.rb', line 601

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 



1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
 
# File 'lib/multi-tk.rb', line 1778

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) 


3058
3059
3060
3061
 
# File 'lib/multi-tk.rb', line 3058

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

#_set_global_var(var, value) ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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

#_tk_cmd_tbl ⇒ Object 



1746
1747
1748
1749
1750
 
# File 'lib/multi-tk.rb', line 1746

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 



1756
1757
1758
 
# File 'lib/multi-tk.rb', line 1756

def _tk_table_list
  @tk_table_list
end

#_tk_windows ⇒ Object 



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

def _tk_windows
  @tk_windows
end

#_toUTF8(str, encoding = nil) ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


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

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) 


3108
3109
3110
3111
 
# File 'lib/multi-tk.rb', line 3108

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) 


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

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) 


3083
3084
3085
3086
 
# File 'lib/multi-tk.rb', line 3083

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) 


2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963
 
# File 'lib/multi-tk.rb', line 2950

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) 


3186
3187
3188
3189
3190
 
# File 'lib/multi-tk.rb', line 3186

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) 


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

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) 


3418
3419
3420
3421
 
# File 'lib/multi-tk.rb', line 3418

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) 


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

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) 


1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
 
# File 'lib/multi-tk.rb', line 1678

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) 


2867
2868
2869
2870
 
# File 'lib/multi-tk.rb', line 2867

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) 


2862
2863
2864
2865
 
# File 'lib/multi-tk.rb', line 2862

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

#background_call ⇒ Object 



2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
 
# File 'lib/multi-tk.rb', line 2364

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 



2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
 
# File 'lib/multi-tk.rb', line 2424

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 



2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
 
# File 'lib/multi-tk.rb', line 2361

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 



2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
 
# File 'lib/multi-tk.rb', line 2395

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 



2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
 
# File 'lib/multi-tk.rb', line 2393

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 



2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
 
# File 'lib/multi-tk.rb', line 2363

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 



2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
 
# File 'lib/multi-tk.rb', line 2411

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 



2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
 
# File 'lib/multi-tk.rb', line 2341

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 



2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
 
# File 'lib/multi-tk.rb', line 2394

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 



2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
 
# File 'lib/multi-tk.rb', line 2380

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

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



2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
 
# File 'lib/multi-tk.rb', line 2339

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 



309
310
311
312
313
 
# File 'lib/multi-tk.rb', line 309

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



1928
1929
1930
1931
1932
1933
 
# File 'lib/multi-tk.rb', line 1928

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) 


3196
3197
3198
3199
3200
3201
 
# File 'lib/multi-tk.rb', line 3196

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) 


3645
3646
3647
3648
 
# File 'lib/multi-tk.rb', line 3645

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

#delete ⇒ Object

Raises:

  • (SecurityError) 


2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
 
# File 'lib/multi-tk.rb', line 2872

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) 


3235
3236
3237
3238
3239
3240
 
# File 'lib/multi-tk.rb', line 3235

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) 


3215
3216
3217
3218
3219
3220
 
# File 'lib/multi-tk.rb', line 3215

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) 


2935
2936
2937
2938
 
# File 'lib/multi-tk.rb', line 2935

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

#encoding=(enc) ⇒ Object

Raises:

  • (SecurityError) 


3650
3651
3652
3653
 
# File 'lib/multi-tk.rb', line 3650

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) 


3665
3666
3667
3668
 
# File 'lib/multi-tk.rb', line 3665

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) 


3671
3672
3673
3674
 
# File 'lib/multi-tk.rb', line 3671

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) 


3654
3655
3656
3657
 
# File 'lib/multi-tk.rb', line 3654

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

#encoding_obj ⇒ Object

Raises:

  • (SecurityError) 


3658
3659
3660
3661
 
# File 'lib/multi-tk.rb', line 3658

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

#encoding_table ⇒ Object 



3632
3633
3634
 
# File 'lib/multi-tk.rb', line 3632

def encoding_table
  @interp.encoding_table
end

#eval(*args, &blk) ⇒ Object 



2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
 
# File 'lib/multi-tk.rb', line 2397

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

Ruby 1.8



2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
 
# File 'lib/multi-tk.rb', line 2235

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

#eval_proc(*args, &blk) ⇒ Object 



2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
 
# File 'lib/multi-tk.rb', line 2276

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 



2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
 
# File 'lib/multi-tk.rb', line 2378

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 



2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
 
# File 'lib/multi-tk.rb', line 2366

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) 


3226
3227
3228
3229
3230
 
# File 'lib/multi-tk.rb', line 3226

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) 


2965
2966
2967
2968
2969
2970
2971
2972
2973
 
# File 'lib/multi-tk.rb', line 2965

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) 


2975
2976
2977
2978
2979
2980
2981
2982
2983
 
# File 'lib/multi-tk.rb', line 2975

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) 


3246
3247
3248
3249
3250
3251
3252
3253
3254
 
# File 'lib/multi-tk.rb', line 3246

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) 


3636
3637
3638
3639
 
# File 'lib/multi-tk.rb', line 3636

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) 


3640
3641
3642
3643
 
# File 'lib/multi-tk.rb', line 3640

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) 


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

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) 


3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
 
# File 'lib/multi-tk.rb', line 3384

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) 


2940
2941
2942
2943
 
# File 'lib/multi-tk.rb', line 2940

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

#hidden_cmds(slave = '') ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


3260
3261
3262
3263
3264
3265
3266
3267
3268
 
# File 'lib/multi-tk.rb', line 3260

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 



1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
 
# File 'lib/multi-tk.rb', line 1638

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) 


2945
2946
2947
2948
 
# File 'lib/multi-tk.rb', line 2945

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

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

Raises:

  • (SecurityError) 


3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
 
# File 'lib/multi-tk.rb', line 3282

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) 


3302
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
 
# File 'lib/multi-tk.rb', line 3302

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) 


3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336
 
# File 'lib/multi-tk.rb', line 3323

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 



1699
1700
1701
 
# File 'lib/multi-tk.rb', line 1699

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) 


2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
 
# File 'lib/multi-tk.rb', line 2737

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) 


2847
2848
2849
2850
 
# File 'lib/multi-tk.rb', line 2847

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

#manipulable? ⇒ Boolean

Returns:

  • (Boolean) 


1728
1729
1730
1731
1732
 
# File 'lib/multi-tk.rb', line 1728

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) 


3341
3342
3343
3344
3345
 
# File 'lib/multi-tk.rb', line 3341

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) 


1660
1661
1662
1663
1664
1665
1666
 
# File 'lib/multi-tk.rb', line 1660

def master?
  if @ip_name
    false
  else
    true
  end
end

#path ⇒ Object 



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

def path
  @ip_name || ''
end

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

Raises:

  • (SecurityError) 


3409
3410
3411
3412
3413
 
# File 'lib/multi-tk.rb', line 3409

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) 


2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
 
# File 'lib/multi-tk.rb', line 2985

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) 


347
348
349
 
# File 'lib/multi-tk.rb', line 347

def running_mainloop?
  @wait_on_mainloop[1] > 0
end

#safe? ⇒ Boolean

Returns:

  • (Boolean)

Raises:

  • (SecurityError) 


2852
2853
2854
2855
 
# File 'lib/multi-tk.rb', line 2852

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

#safe_base? ⇒ Boolean

Returns:

  • (Boolean)

Raises:

  • (SecurityError) 


2857
2858
2859
2860
 
# File 'lib/multi-tk.rb', line 2857

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

#safe_level ⇒ Object 



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

def safe_level
  @safe_level[0]
end

#safe_level=(safe) ⇒ Object 



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

def safe_level=(safe)
  set_safe_level(safe)
end

#safeip_add_to_access_path(dir) ⇒ Object 



3572
3573
3574
3575
 
# File 'lib/multi-tk.rb', line 3572

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

#safeip_configinfo(slot = nil) ⇒ Object 



3527
3528
3529
3530
3531
3532
3533
3534
3535
3536
3537
3538
3539
3540
3541
3542
3543
3544
3545
3546
3547
3548
3549
3550
3551
3552
3553
3554
3555
3556
3557
3558
3559
3560
3561
3562
3563
3564
3565
 
# File 'lib/multi-tk.rb', line 3527

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 



3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524
3525
 
# File 'lib/multi-tk.rb', line 3514

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 



3567
3568
3569
3570
 
# File 'lib/multi-tk.rb', line 3567

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

#safeip_find_in_access_path(dir) ⇒ Object 



3577
3578
3579
3580
 
# File 'lib/multi-tk.rb', line 3577

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 



3582
3583
3584
3585
 
# File 'lib/multi-tk.rb', line 3582

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) 


3351
3352
3353
3354
3355
3356
3357
3358
3359
3360
3361
3362
3363
 
# File 'lib/multi-tk.rb', line 3351

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 



305
306
307
 
# File 'lib/multi-tk.rb', line 305

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

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

Raises:

  • (SecurityError) 


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

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 



317
318
319
320
321
322
323
 
# File 'lib/multi-tk.rb', line 317

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) 


3446
3447
3448
3449
3450
 
# File 'lib/multi-tk.rb', line 3446

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) 


3426
3427
3428
3429
3430
 
# File 'lib/multi-tk.rb', line 3426

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) 


3486
3487
3488
3489
3490
3491
3492
 
# File 'lib/multi-tk.rb', line 3486

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) 


3436
3437
3438
3439
3440
 
# File 'lib/multi-tk.rb', line 3436

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) 


1671
1672
1673
 
# File 'lib/multi-tk.rb', line 1671

def slave?
  not master?
end

#slaves(all = false) ⇒ Object

Raises:

  • (SecurityError) 


1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
 
# File 'lib/multi-tk.rb', line 1712

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 



2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
 
# File 'lib/multi-tk.rb', line 2362

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 



1705
1706
1707
 
# File 'lib/multi-tk.rb', line 1705

def to_eval
  @ip_name || ''
end

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

Raises:

  • (SecurityError) 


3476
3477
3478
3479
3480
 
# File 'lib/multi-tk.rb', line 3476

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) 


3456
3457
3458
3459
3460
 
# File 'lib/multi-tk.rb', line 3456

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) 


3498
3499
3500
3501
3502
3503
3504
 
# File 'lib/multi-tk.rb', line 3498

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) 


3466
3467
3468
3469
3470
 
# File 'lib/multi-tk.rb', line 3466

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 



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

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

#wait_on_mainloop? ⇒ Boolean

Returns:

  • (Boolean) 


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

def wait_on_mainloop?
  @wait_on_mainloop[0]
end