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.



1267
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
1473
1474
1475
1476
1477
1478
1479
 
# File 'lib/multi-tk.rb', line 1267

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

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

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

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

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

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

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

  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 = 4 if safe && !safe.kind_of?(Fixnum)

  @safe_base = false

  if safeip == nil
    # create master-ip
    unless WITH_RUBY_VM
      @interp = TclTkIp.new(name, _keys2opts(tk_opts))
      @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 = [4]
      end
    else
      @interp, @ip_name = master.__create_trusted_slave_obj(name, tk_opts)
      # @interp_thread = nil if RUBY_VERSION < '1.9.0' ### !!!!!!!!!!!
      @interp_thread = nil unless WITH_RUBY_VM  ### Ruby 1.9 !!!!!!!!!!!
      if safe
        safe = master.safe_level if safe < master.safe_level
        @safe_level = [safe]
      else
        @safe_level = [master.safe_level]
      end
    end
    @set_alias_proc = proc{|name|
      master._invoke('interp', 'alias', @ip_name, name, '', name)
    }.freeze
  end

  @system = Object.new

  @wait_on_mainloop = 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 



1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
 
# File 'lib/multi-tk.rb', line 1534

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

._conv_listelement(arg) ⇒ Object 



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

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

._create_console ⇒ Object 



2687
2688
2689
 
# File 'lib/multi-tk.rb', line 2687

def _create_console
  __getip._create_console
end

._DEFAULT_MASTER ⇒ Object 



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

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

._eval(str) ⇒ Object 



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

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

._eval_with_enc(str) ⇒ Object 



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

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

._eval_without_enc(str) ⇒ Object 



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

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

._fromUTF8(str, encoding = nil) ⇒ Object 



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

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

._get_global_var(var) ⇒ Object 



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

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

._get_global_var2(var, idx) ⇒ Object 



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

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

._get_variable(var, flag) ⇒ Object 



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

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

._get_variable2(var, idx, flag) ⇒ Object 



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

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

._invoke(*args) ⇒ Object 



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

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

._invoke_with_enc(*args) ⇒ Object 



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

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

._invoke_without_enc(*args) ⇒ Object 



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

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

._ip_id_ ⇒ Object 



1526
1527
1528
 
# File 'lib/multi-tk.rb', line 1526

def self._ip_id_
  __getip._ip_id_
end

._IP_TABLE ⇒ Object 



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

def self._IP_TABLE; @@IP_TABLE; end

._make_menu_embeddable(menu_path) ⇒ Object 



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

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

._merge_tklist(*args) ⇒ Object 



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

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

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



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

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 



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

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

._return_value ⇒ Object 



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

def _return_value
  __getip._return_value
end

._set_global_var(var, value) ⇒ Object 



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

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

._set_global_var2(var, idx, value) ⇒ Object 



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

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

._set_variable(var, value, flag) ⇒ Object 



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

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

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



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

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

._split_tklist(str) ⇒ Object 



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

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

._thread_tkwait(mode, target) ⇒ Object 



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

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

._thread_vwait(var) ⇒ Object 



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

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

._TK_TABLE_LIST ⇒ Object 



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

def self._TK_TABLE_LIST; @@TK_TABLE_LIST; end

._toUTF8(str, encoding = nil) ⇒ Object 



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

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

._unset_global_var(var) ⇒ Object 



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

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

._unset_global_var2(var, idx) ⇒ Object 



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

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

._unset_variable(var, flag) ⇒ Object 



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

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

._unset_variable2(var, idx, flag) ⇒ Object 



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

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

.abort(msg = nil) ⇒ Object 



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

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

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



1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
 
# File 'lib/multi-tk.rb', line 1883

def self.add_tk_procs(name, args=nil, body=nil)
  if name.kind_of?(Array) # => an array of [name, args, body]
    name.each{|param| self.add_tk_procs(*param)}
  else
    name = name.to_s
    @@ADD_TK_PROCS << [name, args, body]
    @@IP_TABLE.each{|tg, ip|
      ip._add_tk_procs(name, args, body)
    }
  end
end

.alias_delete(slave, cmd_name) ⇒ Object 



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

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

.alias_info(slave, cmd_name) ⇒ Object 



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

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

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



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

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

.aliases(slave = '') ⇒ Object 



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

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

.alive? ⇒ Boolean

Returns:

  • (Boolean) 


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

def self.alive?
  __getip.alive?
end

.allow_ruby_exit=(mode) ⇒ Object 



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

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

.allow_ruby_exit? ⇒ Boolean

Returns:

  • (Boolean) 


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

def allow_ruby_exit?
  __getip.allow_ruby_exit?
end

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



2469
2470
2471
2472
 
# File 'lib/multi-tk.rb', line 2469

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 



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

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 



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

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

.bgerror(slave = '') ⇒ Object 



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

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

.cb_entry_class ⇒ Object 



1914
1915
1916
 
# File 'lib/multi-tk.rb', line 1914

def self.cb_entry_class
  @@CB_ENTRY_CLASS
end

.create_table ⇒ Object 



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
1852
1853
1854
1855
1856
1857
1858
 
# File 'lib/multi-tk.rb', line 1826

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

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

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



3213
3214
3215
3216
 
# File 'lib/multi-tk.rb', line 3213

def self.def_alias(slave, new_cmd, org_cmd, *args)
  ret = __getip.def_alias(slave, new_cmd, org_cmd, *args)
  (ret == new_cmd)? self: nil
end

.default_encoding ⇒ Object 



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

def encoding_name
  __getip.encoding_name
end

.default_encoding=(enc) ⇒ Object 



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

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

.default_master? ⇒ Boolean

Returns:

  • (Boolean) 


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

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

.delete ⇒ Object 



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

def delete
  __getip.delete
end

.delete_cmd(slave, cmd) ⇒ Object 



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

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

.delete_slaves(*args) ⇒ Object 



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

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

.deleted? ⇒ Boolean

Returns:

  • (Boolean) 


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

def deleted?
  __getip.deleted?
end

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



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

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

.encoding ⇒ Object 



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

def encoding_name
  __getip.encoding_name
end

.encoding=(enc) ⇒ Object 



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

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

.encoding_convert_from ⇒ Object 



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

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

.encoding_convert_to ⇒ Object 



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

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

.encoding_convertfrom(str, enc = None) ⇒ Object 



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

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

.encoding_convertto(str, enc = None) ⇒ Object 



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

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

.encoding_name ⇒ Object 



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

def encoding_name
  __getip.encoding_name
end

.encoding_obj ⇒ Object 



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

def encoding_obj
  __getip.encoding_obj
end

.encoding_table ⇒ Object 



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

def encoding_table
  __getip.encoding_table
end

.eval(*args, &blk) ⇒ Object 



2465
2466
2467
2468
 
# File 'lib/multi-tk.rb', line 2465

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

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

class method



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

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 



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

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

.exist?(slave = '') ⇒ Boolean

Returns:

  • (Boolean) 


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

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

.exit(st = true) ⇒ Object 



2572
2573
2574
 
# File 'lib/multi-tk.rb', line 2572

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

.exit!(st = false) ⇒ Object 



2576
2577
2578
 
# File 'lib/multi-tk.rb', line 2576

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

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



3266
3267
3268
3269
 
# File 'lib/multi-tk.rb', line 3266

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

.force_default_encoding=(mode) ⇒ Object 



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

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

.force_default_encoding? ⇒ Boolean

Returns:

  • (Boolean) 


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

def force_default_encoding?
  __getip.force_default_encoding?
end

.get_cb_entry(cmd) ⇒ Object 



1917
1918
1919
 
# File 'lib/multi-tk.rb', line 1917

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

.get_eventloop_tick ⇒ Object 



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

def get_eventloop_tick
  __getip.get_eventloop_tick
end

.get_eventloop_weight ⇒ Object 



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

def get_eventloop_weight
  __getip.get_eventloop_weight
end

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



3416
3417
3418
 
# File 'lib/multi-tk.rb', line 3416

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

.get_no_event_wait ⇒ Object 



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

def get_no_event_wait
  __getip.get_no_event_wait
end

.has_mainwindow? ⇒ Boolean

Returns:

  • (Boolean) 


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

def has_mainwindow?
  __getip.has_mainwindow?
end

.hidden_cmds(slave = '') ⇒ Object 



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

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

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



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

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

.inherited(subclass) ⇒ Object 



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

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

.init_ip_env(script = Proc.new) ⇒ Object 



1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
 
# File 'lib/multi-tk.rb', line 1860

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

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

.init_ip_internal ⇒ Object 



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

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

.invalid_namespace? ⇒ Boolean

Returns:

  • (Boolean) 


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

def invalid_namespace?
  __getip.invalid_namespace?
end

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



3309
3310
3311
 
# File 'lib/multi-tk.rb', line 3309

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

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



3330
3331
3332
 
# File 'lib/multi-tk.rb', line 3330

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 



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

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

.ip_name ⇒ Object 



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

def self.ip_name
  __getip.ip_name
end

.mainloop(check_root = true) ⇒ Object 



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

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

.mainloop_abort_on_exception ⇒ Object 



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

def mainloop_abort_on_exception
  # __getip.mainloop_abort_on_exception
  TclTkLib.mainloop_abort_on_exception
end

.mainloop_abort_on_exception=(mode) ⇒ Object 



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

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

.mainloop_watchdog(check_root = true) ⇒ Object 



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

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

.make_safe ⇒ Object 



2528
2529
2530
 
# File 'lib/multi-tk.rb', line 2528

def make_safe
  __getip.make_safe
end

.manipulable? ⇒ Boolean

Returns:

  • (Boolean) 


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

def self.manipulable?
  true
end

.mark_trusted(slave = '') ⇒ Object 



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

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

.master? ⇒ Boolean

Returns:

  • (Boolean) 


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

def self.master?
  __getip.master?
end

.method_missing(id, *args) ⇒ Object 



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

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

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



1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
 
# File 'lib/multi-tk.rb', line 1561

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

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

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

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



1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
 
# File 'lib/multi-tk.rb', line 1618

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

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

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



1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
 
# File 'lib/multi-tk.rb', line 1593

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

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

.path ⇒ Object 



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

def self.path
  __getip.path
end

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



3425
3426
3427
 
# File 'lib/multi-tk.rb', line 3425

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

.remove_tk_procs(*names) ⇒ Object 



1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
 
# File 'lib/multi-tk.rb', line 1895

def self.remove_tk_procs(*names)
  names.each{|name|
    name = name.to_s
    @@ADD_TK_PROCS.delete_if{|elem|
      elem.kind_of?(Array) && elem[0].to_s == name
    }
  }
  @@IP_TABLE.each{|tg, ip|
    ip._remove_tk_procs(*names)
  }
end

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



2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
 
# File 'lib/multi-tk.rb', line 2580

def restart(app_name = nil, keys = {})
  init_ip_internal

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

  __getip.restart
end

.safe? ⇒ Boolean

Returns:

  • (Boolean) 


2532
2533
2534
 
# File 'lib/multi-tk.rb', line 2532

def safe?
  __getip.safe?
end

.safe_base? ⇒ Boolean

Returns:

  • (Boolean) 


2536
2537
2538
2539
2540
2541
2542
 
# File 'lib/multi-tk.rb', line 2536

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

.safe_level ⇒ Object 



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

def self.safe_level
  __getip.safe_level
end

.safe_level=(safe) ⇒ Object 



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

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

.set_eventloop_tick(tick) ⇒ Object 



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

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

.set_eventloop_weight(loop_max, no_event_tick) ⇒ Object 



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

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

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



3391
3392
3393
 
# File 'lib/multi-tk.rb', line 3391

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

.set_no_event_wait(tick) ⇒ Object 



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

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

.set_safe_level(safe) ⇒ Object 



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

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

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



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

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

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



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

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

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



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

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

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



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

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

.slave? ⇒ Boolean

Returns:

  • (Boolean) 


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

def self.slave?
  not self.master?
end

.slaves(all = false) ⇒ Object 



1731
1732
1733
 
# File 'lib/multi-tk.rb', line 1731

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

.tk_cmd_tbl ⇒ Object 



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

def self.tk_cmd_tbl
  @@TK_CMD_TBL
end

.tk_object_table(id) ⇒ Object 



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

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

.tk_windows ⇒ Object 



1820
1821
1822
 
# File 'lib/multi-tk.rb', line 1820

def self.tk_windows
  __getip._tk_windows
end

.to_eval ⇒ Object 



1715
1716
1717
 
# File 'lib/multi-tk.rb', line 1715

def self.to_eval
  __getip.to_eval
end

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



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

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

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



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

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

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



3516
3517
3518
3519
 
# File 'lib/multi-tk.rb', line 3516

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

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



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

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) 


1189
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
 
# File 'lib/multi-tk.rb', line 1189

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

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

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

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

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

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

  [slave_ip, ip_name]
end

#__create_trusted_slave_obj(name, keys) ⇒ Object

Raises:

  • (SecurityError) 


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

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

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

#__eval(str) ⇒ Object

Raises:

  • (SecurityError) 


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

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

#__invoke(*args) ⇒ Object

Raises:

  • (SecurityError) 


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

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

#__pseudo_toplevel ⇒ Object

instance method



2002
2003
2004
2005
2006
 
# File 'lib/multi-tk.rb', line 2002

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

#__pseudo_toplevel=(m) ⇒ Object 



2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
 
# File 'lib/multi-tk.rb', line 2008

def __pseudo_toplevel=(m)
  unless (Thread.current.group == ThreadGroup::Default &&
            MultiTkIp.__getip == @@DEFAULT_MASTER)
    fail SecurityError, "no permission to manipulate"
  end

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

#__pseudo_toplevel_evaluable=(mode) ⇒ Object 



2032
2033
2034
2035
2036
2037
2038
2039
 
# File 'lib/multi-tk.rb', line 2032

def __pseudo_toplevel_evaluable=(mode)
  unless (Thread.current.group == ThreadGroup::Default &&
            MultiTkIp.__getip == @@DEFAULT_MASTER)
    fail SecurityError, "no permission to manipulate"
  end

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

#__pseudo_toplevel_evaluable? ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#_add_new_tables ⇒ Object 



1767
1768
1769
1770
1771
 
# File 'lib/multi-tk.rb', line 1767

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

#_add_tk_procs(name, args, body) ⇒ Object 



1777
1778
1779
1780
1781
1782
1783
 
# File 'lib/multi-tk.rb', line 1777

def _add_tk_procs(name, args, body)
  return if slave?
  @interp._invoke('proc', name, args, body) if args && body
  @interp._invoke('interp', 'slaves').split.each{|slave|
    @interp._invoke('interp', 'alias', slave, name, '', name)
  }
end

#_conv_listelement(arg) ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


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

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

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

#_default_delete_hook(slave) ⇒ Object

Raises:

  • (SecurityError) 


1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
 
# File 'lib/multi-tk.rb', line 1483

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

#_destroy_slaves_of_slaveIP(ip) ⇒ Object 



350
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
 
# File 'lib/multi-tk.rb', line 350

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

      # safe_base?
      if ip._eval_without_enc("catch {::safe::interpConfigure #{name}}") == '0'
        begin
          ip._eval_without_enc("::safe::interpDelete #{name}")
        rescue Exception
        end
      end
=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) 


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

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

#_eval_with_enc(str) ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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 



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

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

#_init_ip_internal(init_ip_env, add_tk_procs) ⇒ Object 



1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
 
# File 'lib/multi-tk.rb', line 1801

def _init_ip_internal(init_ip_env, add_tk_procs)
  #init_ip_env.each{|script| self.eval_proc{script.call(self)}}
  init_ip_env.each{|script| self._init_ip_env(script)}
  add_tk_procs.each{|name, args, body|
    if master?
      @interp._invoke('proc', name, args, body) if args && body
    else
      @set_alias_proc.call(name)
    end
  }
end

#_invoke(*args) ⇒ Object

Raises:

  • (SecurityError) 


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

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

#_invoke_with_enc(*args) ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


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

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

#_ip_id_ ⇒ Object 



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

def _ip_id_
  # for RemoteTkIp
  ''
end

#_make_menu_embeddable(menu_path) ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


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

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



2137
2138
2139
2140
2141
 
# File 'lib/multi-tk.rb', line 2137

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

#_proc_on_safelevel(cmd = nil) ⇒ Object

instance & class method



2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
 
# File 'lib/multi-tk.rb', line 2106

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

#_receiver_mainloop(check_root) ⇒ Object 



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

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

#_remove_tk_procs(*names) ⇒ Object 



1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
 
# File 'lib/multi-tk.rb', line 1785

def _remove_tk_procs(*names)
  return if slave?
  names.each{|name|
    name = name.to_s

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

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

#_return_value ⇒ Object

Raises:

  • (SecurityError) 


3069
3070
3071
3072
 
# File 'lib/multi-tk.rb', line 3069

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

#_set_global_var(var, value) ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


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

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) 


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

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) 


3086
3087
3088
3089
 
# File 'lib/multi-tk.rb', line 3086

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) 


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

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) 


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

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) 


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

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

#_tk_cmd_tbl ⇒ Object 



1753
1754
1755
1756
1757
 
# File 'lib/multi-tk.rb', line 1753

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

#_tk_table_list ⇒ Object 



1763
1764
1765
 
# File 'lib/multi-tk.rb', line 1763

def _tk_table_list
  @tk_table_list
end

#_tk_windows ⇒ Object 



1759
1760
1761
 
# File 'lib/multi-tk.rb', line 1759

def _tk_windows
  @tk_windows
end

#_toUTF8(str, encoding = nil) ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


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

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) 


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

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) 


3090
3091
3092
3093
 
# File 'lib/multi-tk.rb', line 3090

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) 


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

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) 


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

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) 


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

def alias_delete(slave, cmd_name)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'alias', _slavearg(slave), cmd_name, '')
  self
end

#alias_info(slave, cmd_name) ⇒ Object

Raises:

  • (SecurityError) 


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

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

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

Raises:

  • (SecurityError) 


3429
3430
3431
3432
 
# File 'lib/multi-tk.rb', line 3429

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

#aliases(slave = '') ⇒ Object

Raises:

  • (SecurityError) 


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

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

#alive? ⇒ Boolean

Returns:

  • (Boolean)

Raises:

  • (SecurityError) 


1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
 
# File 'lib/multi-tk.rb', line 1685

def alive?
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  begin
    return false unless @cmd_receiver.alive?
    return false if @interp.deleted?
    return false if @interp._invoke('interp', 'exists', '') == '0'
  rescue Exception
    return false
  end
  true
end

#allow_ruby_exit=(mode) ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


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

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

#background_call ⇒ Object 



2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
 
# File 'lib/multi-tk.rb', line 2371

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 



2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
 
# File 'lib/multi-tk.rb', line 2431

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 



2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
 
# File 'lib/multi-tk.rb', line 2368

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 



2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
 
# File 'lib/multi-tk.rb', line 2402

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 



2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
 
# File 'lib/multi-tk.rb', line 2400

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 



2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
 
# File 'lib/multi-tk.rb', line 2370

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 



2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
 
# File 'lib/multi-tk.rb', line 2418

def bg_eval(*args, &blk)
  if block_given?
    bg_eval_proc(*args, &blk)
  elsif args[0]
    if args[0].respond_to?(:call)
      bg_eval_proc(*args)
    else
      bg_eval_string(*args)
    end
  else
    fail ArgumentError, "no argument to eval"
  end
end

#bg_eval_proc(*args) ⇒ Object 



2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
 
# File 'lib/multi-tk.rb', line 2348

def bg_eval_proc(*args)
  if block_given?
    cmd = Proc.new
  else
    unless (cmd = args.shift)
      fail ArgumentError, "A Proc or Method object is expected for 1st argument"
    end
  end
  Thread.new{
    eval_proc(cmd, *args)
=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 



2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
 
# File 'lib/multi-tk.rb', line 2401

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 



2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
 
# File 'lib/multi-tk.rb', line 2387

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

#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



2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
 
# File 'lib/multi-tk.rb', line 2346

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 



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

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

#cb_eval(cmd, *args) ⇒ Object

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



1935
1936
1937
1938
1939
1940
 
# File 'lib/multi-tk.rb', line 1935

def cb_eval(cmd, *args)
  self.eval_callback(*args,
                     &_proc_on_safelevel{|*params|
                       TkComm._get_eval_string(TkUtil.eval_cmd(cmd, *params))
                     })
end

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

Raises:

  • (SecurityError) 


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

def def_alias(slave, new_cmd, org_cmd, *args)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  ret = @interp._invoke('interp', 'alias', _slavearg(slave), new_cmd,
                        '', org_cmd, *args)
  (ret == new_cmd)? self: nil
end

#default_encoding=(enc) ⇒ Object

Raises:

  • (SecurityError) 


3656
3657
3658
3659
 
# File 'lib/multi-tk.rb', line 3656

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

#delete ⇒ Object

Raises:

  • (SecurityError) 


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
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
 
# File 'lib/multi-tk.rb', line 2883

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) 


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

def delete_cmd(slave, cmd)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  slave_invoke = @interp._invoke('list', 'rename', cmd, '')
  @interp._invoke('interp', 'eval', _slavearg(slave), slave_invoke)
  self
end

#delete_slaves(*args) ⇒ Object

Raises:

  • (SecurityError) 


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

def delete_slaves(*args)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  slaves = args.collect{|s| _slavearg(s)}
  @interp._invoke('interp', 'delete', *slaves) if slaves.size > 0
  self
end

#deleted? ⇒ Boolean

Returns:

  • (Boolean)

Raises:

  • (SecurityError) 


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

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

#encoding=(enc) ⇒ Object

Raises:

  • (SecurityError) 


3661
3662
3663
3664
 
# File 'lib/multi-tk.rb', line 3661

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) 


3676
3677
3678
3679
 
# File 'lib/multi-tk.rb', line 3676

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) 


3682
3683
3684
3685
 
# File 'lib/multi-tk.rb', line 3682

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) 


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

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

#encoding_obj ⇒ Object

Raises:

  • (SecurityError) 


3669
3670
3671
3672
 
# File 'lib/multi-tk.rb', line 3669

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

#encoding_table ⇒ Object 



3643
3644
3645
 
# File 'lib/multi-tk.rb', line 3643

def encoding_table
  @interp.encoding_table
end

#eval(*args, &blk) ⇒ Object 



2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
 
# File 'lib/multi-tk.rb', line 2404

def eval(*args, &blk)
  if block_given?
    eval_proc(*args, &blk)
  elsif args[0]
    if args[0].respond_to?(:call)
      eval_proc(*args)
    else
      eval_string(*args)
    end
  else
    fail ArgumentError, "no argument to eval"
  end
end

#eval_callback(*args) ⇒ Object

Ruby 1.8



2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
 
# File 'lib/multi-tk.rb', line 2242

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

#eval_proc(*args, &blk) ⇒ Object 



2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
 
# File 'lib/multi-tk.rb', line 2283

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

#eval_str ⇒ Object 



2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
 
# File 'lib/multi-tk.rb', line 2385

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 



2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
 
# File 'lib/multi-tk.rb', line 2373

def eval_string(cmd, *eval_args)
  # cmd string ==> proc
  unless cmd.kind_of?(String)
    raise RuntimeError, "A String object is expected for the 'cmd' argument"
  end

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

#exist?(slave = '') ⇒ Boolean

Returns:

  • (Boolean)

Raises:

  • (SecurityError) 


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

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

#exit(st = true) ⇒ Object

Raises:

  • (SecurityError) 


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

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) 


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

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) 


3257
3258
3259
3260
3261
3262
3263
3264
3265
 
# File 'lib/multi-tk.rb', line 3257

def expose_cmd(slave, cmd, aliasname = nil)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  if aliasname
    @interp._invoke('interp', 'expose', _slavearg(slave), cmd, aliasname)
  else
    @interp._invoke('interp', 'expose', _slavearg(slave), cmd)
  end
  self
end

#force_default_encoding=(mode) ⇒ Object

Raises:

  • (SecurityError) 


3647
3648
3649
3650
 
# File 'lib/multi-tk.rb', line 3647

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) 


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

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) 


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

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

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

Raises:

  • (SecurityError) 


3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
 
# File 'lib/multi-tk.rb', line 3395

def get_limit(limit_type, slave = '', slot = nil)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?

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

#has_mainwindow? ⇒ Boolean

Returns:

  • (Boolean)

Raises:

  • (SecurityError) 


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

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

#hidden_cmds(slave = '') ⇒ Object

Raises:

  • (SecurityError) 


3285
3286
3287
3288
 
# File 'lib/multi-tk.rb', line 3285

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

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

Raises:

  • (SecurityError) 


3271
3272
3273
3274
3275
3276
3277
3278
3279
 
# File 'lib/multi-tk.rb', line 3271

def hide_cmd(slave, cmd, aliasname = nil)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  if aliasname
    @interp._invoke('interp', 'hide', _slavearg(slave), cmd, aliasname)
  else
    @interp._invoke('interp', 'hide', _slavearg(slave), cmd)
  end
  self
end

#inspect ⇒ Object 



1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
 
# File 'lib/multi-tk.rb', line 1645

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) 


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

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

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

Raises:

  • (SecurityError) 


3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
 
# File 'lib/multi-tk.rb', line 3293

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

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

Raises:

  • (SecurityError) 


3313
3314
3315
3316
3317
3318
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
 
# File 'lib/multi-tk.rb', line 3313

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

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

Raises:

  • (SecurityError) 


3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
 
# File 'lib/multi-tk.rb', line 3334

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

#ip_name ⇒ Object 



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

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) 


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
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
 
# File 'lib/multi-tk.rb', line 2744

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
        if $SAFE >= 4
   _receiver_mainloop(check_root).join
        else
          @cmd_queue.enq([@system, 'call_mainloop',
                          Thread.current, check_root])
          Thread.stop
        end
      rescue MultiTkIp_OK => ret
        # return value
        if ret.value.kind_of?(Thread)
          return ret.value.value
        else
          return ret.value
        end
      rescue SystemExit => e
        # exit IP
        warn("Warning: " + 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) 


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

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

#manipulable? ⇒ Boolean

Returns:

  • (Boolean) 


1735
1736
1737
1738
1739
 
# File 'lib/multi-tk.rb', line 1735

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

#mark_trusted(slave = '') ⇒ Object

Raises:

  • (SecurityError) 


3352
3353
3354
3355
3356
 
# File 'lib/multi-tk.rb', line 3352

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

#master? ⇒ Boolean

Returns:

  • (Boolean) 


1667
1668
1669
1670
1671
1672
1673
 
# File 'lib/multi-tk.rb', line 1667

def master?
  if @ip_name
    false
  else
    true
  end
end

#path ⇒ Object 



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

def path
  @ip_name || ''
end

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

Raises:

  • (SecurityError) 


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

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

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

Raises:

  • (SecurityError) 


2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
 
# File 'lib/multi-tk.rb', line 2996

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) 


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

def running_mainloop?
  @wait_on_mainloop[1] > 0
end

#safe? ⇒ Boolean

Returns:

  • (Boolean)

Raises:

  • (SecurityError) 


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

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

#safe_base? ⇒ Boolean

Returns:

  • (Boolean)

Raises:

  • (SecurityError) 


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

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

#safe_level ⇒ Object 



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

def safe_level
  @safe_level[0]
end

#safe_level=(safe) ⇒ Object 



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

def safe_level=(safe)
  set_safe_level(safe)
end

#safeip_add_to_access_path(dir) ⇒ Object 



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

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

#safeip_configinfo(slot = nil) ⇒ Object 



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
3566
3567
3568
3569
3570
3571
3572
3573
3574
3575
3576
 
# File 'lib/multi-tk.rb', line 3538

def safeip_configinfo(slot = nil)
  ip = MultiTkIp.__getip
  ret = {}
  if slot
    conf = _lst2ary(ip._eval("::safe::interpConfigure " +
                             @ip_name + " -#{slot}"))
    if conf[0] == '-deleteHook'
=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 



3525
3526
3527
3528
3529
3530
3531
3532
3533
3534
3535
3536
 
# File 'lib/multi-tk.rb', line 3525

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

#safeip_delete ⇒ Object 



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

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

#safeip_find_in_access_path(dir) ⇒ Object 



3588
3589
3590
3591
 
# File 'lib/multi-tk.rb', line 3588

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 



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

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

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

Raises:

  • (SecurityError) 


3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
 
# File 'lib/multi-tk.rb', line 3362

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

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

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

#set_cb_error(cmd = Proc.new) ⇒ Object 



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

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

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

Raises:

  • (SecurityError) 


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

def set_limit(limit_type, slave = '', opts = {})
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp', 'limit', _slavearg(slave), limit_type, opts)
end

#set_safe_level(safe) ⇒ Object 



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

def set_safe_level(safe)
  if safe > @safe_level[0]
    @safe_level[0] = safe
    @cmd_queue.enq([@system, 'set_safe_level', safe])
  end
  @safe_level[0]
end

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

Raises:

  • (SecurityError) 


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

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

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

Raises:

  • (SecurityError) 


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

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

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

Raises:

  • (SecurityError) 


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

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

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

Raises:

  • (SecurityError) 


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

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

#slave? ⇒ Boolean

Returns:

  • (Boolean) 


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

def slave?
  not master?
end

#slaves(all = false) ⇒ Object

Raises:

  • (SecurityError) 


1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
 
# File 'lib/multi-tk.rb', line 1719

def slaves(all = false)
  raise SecurityError, "no permission to manipulate" unless self.manipulable?
  @interp._invoke('interp','slaves').split.map!{|name|
    if @slave_ip_tbl.key?(name)
      @slave_ip_tbl[name]
    elsif all
      name
    else
      nil
    end
  }.compact!
end

#thread_eval_proc ⇒ Object 



2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
 
# File 'lib/multi-tk.rb', line 2369

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 



1712
1713
1714
 
# File 'lib/multi-tk.rb', line 1712

def to_eval
  @ip_name || ''
end

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

Raises:

  • (SecurityError) 


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

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

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

Raises:

  • (SecurityError) 


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

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

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

Raises:

  • (SecurityError) 


3509
3510
3511
3512
3513
3514
3515
 
# File 'lib/multi-tk.rb', line 3509

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

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

Raises:

  • (SecurityError) 


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

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

#wait_on_mainloop=(bool) ⇒ Object 



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

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

#wait_on_mainloop? ⇒ Boolean

Returns:

  • (Boolean) 


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

def wait_on_mainloop?
  @wait_on_mainloop[0]
end