Module: TkCore

Extended by:
TkComm
Includes:
TkComm
Included in:
Tk, Tk::BLT, Tk::BLT::Bitmap, Tk::BLT::Busy, Tk::BLT::DnD, Tk::BLT::DragDrop, Tk::BLT::Printer, Tk::BLT::Spline, Tk::BLT::Ted, Tk::BLT::Watch, Tk::BLT::Winop, Tk::BWidget, Tk::Clock, Tk::Iwidgets, Tk::Iwidgets::Labeledwidget, Tk::Tcllib::Autoscroll, Tk::Tcllib::Cursor, Tk::Tcllib::History, Tk::Tcllib::Plotchart, Tk::Tcllib::Plotchart::ChartMethod, Tk::Tcllib::Style, Tk::Tcllib::Tooltip, Tk::Tile::Style, Tk::TkDND::Shape, Tk::Trofs, Tk::Wm, TkFont, TkFont::CoreMethods, TkMsgCatalog, TkObject, TkPackage, TkTimer, TkTimer, TkVariable
Defined in:
lib/multi-tk.rb,
lib/multi-tk.rb,
lib/tk.rb

Overview

start Tk which depends on MultiTkIp

Defined Under Namespace

Classes: Tk_OBJECT_TABLE

Constant Summary collapse

INTERP_THREAD = 
Thread.new{
  begin
    Thread.current[:interp] = interp = TclTkIp.new(name, opts)
  rescue => e
    Thread.current[:interp] = e
    raise e
  end
  Thread.current[:status] = nil
  #sleep

  begin
    Thread.current[:status] = TclTkLib.mainloop(true)
  rescue Exception=>e
    Thread.current[:status] = e
  ensure
    INTERP_MUTEX.synchronize{ INTERP_ROOT_CHECK.broadcast }
  end
  Thread.current[:status] = TclTkLib.mainloop(false)
}
INTERP_MUTEX = 
Mutex.new
INTERP_ROOT_CHECK = 
ConditionVariable.new
INTERP = 

      
        
WITH_RUBY_VM =
          
        

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

      
        
WITH_ENCODING =
          
        

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

      
        
RUN_EVENTLOOP_ON_MAIN_THREAD =
          

  

    

Ruby 1.9 !!!!!!!!!!!!!!!!!!!!!!!!!!



  





  



        

        
false

      
        
WIDGET_DESTROY_HOOK =
          
        

        
'<WIDGET_DESTROY_HOOK>'

      
        
EventFlag =
          
        

        
TclTkLib::EventFlag

      
    

  



  
  
  
Constants included
     from TkComm

  
TkComm::GET_CONFIGINFO_AS_ARRAY, TkComm::GET_CONFIGINFOwoRES_AS_ARRAY, TkComm::TkExtlibAutoloadModule, TkComm::Tk_CMDTBL, TkComm::Tk_IDs, TkComm::Tk_WINDOWS, TkComm::USE_TCLs_LIST_FUNCTIONS, TkComm::WidgetClassNames


  
  
  
Constants included
     from TkUtil

  
TkUtil::None, TkUtil::RELEASE_DATE






  
    

      Class Method Summary
      collapse
    


    
  
    

      Instance Method Summary
      collapse
    


    
  


  
  
  
  
  
  
  
  
  
Methods included from TkComm

  
_at, _callback_entry?, _callback_entry_class?, _curr_cmd_id, _fromUTF8, _genobj_for_tkwidget, _next_cmd_id, _toUTF8, array2tk_list, bind, bind_all, bind_append, bind_append_all, bind_remove, bind_remove_all, bindinfo, bindinfo_all, bool, image_obj, install_cmd, install_cmd, list, num_or_str, number, procedure, simplelist, string, subst, tk_tcl2ruby, uninstall_cmd, uninstall_cmd, window


  
  
  
  
  
  
  
  
  
Methods included from TkUtil

  
#_conv_args, _conv_args, #_fromUTF8, #_get_eval_enc_str, _get_eval_enc_str, #_get_eval_string, _get_eval_string, _symbolkey2str, #_symbolkey2str, #_toUTF8, bool, #bool, eval_cmd, #hash_kv, hash_kv, install_cmd, num_or_str, #num_or_str, number, #number, string, #string, uninstall_cmd


  
  
  
  
  
  
  
  
  
Methods included from TkEvent

  
#install_bind, #install_bind_for_event_class



  

    
Class Method Details


    
      

  

  
    .callback(*arg)  ⇒ Object 
  

  

  




  

    
      


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

    		
    
      
# File 'lib/tk.rb', line 1381

def TkCore.callback(*arg)
  begin
    if TkCore::INTERP.tk_cmd_tbl.kind_of?(Hash)
      #TkCore::INTERP.tk_cmd_tbl[arg.shift].call(*arg)
      normal_ret = false
      ret = catch(:IRB_EXIT) do  # IRB hack
        retval = TkCore::INTERP.tk_cmd_tbl[arg.shift].call(*arg)
        normal_ret = true
        retval
      end
      unless normal_ret
        # catch IRB_EXIT
        exit(ret)
      end
      ret
    end
  rescue SystemExit=>e
    exit(e.status)
  rescue Interrupt=>e
    fail(e)
  rescue Exception => e
    begin
      msg = _toUTF8(e.class.inspect) + ': ' + 
            _toUTF8(e.message) + "\n" + 
            "\n---< backtrace of Ruby side >-----\n" + 
            _toUTF8(e.backtrace.join("\n")) + 
            "\n---< backtrace of Tk side >-------"
      if TkCore::WITH_ENCODING
        msg.force_encoding('utf-8')
      else
        msg.instance_variable_set(:@encoding, 'utf-8')
      end
    rescue Exception
      msg = e.class.inspect + ': ' + e.message + "\n" + 
            "\n---< backtrace of Ruby side >-----\n" + 
            e.backtrace.join("\n") + 
            "\n---< backtrace of Tk side >-------"
    end
    # TkCore::INTERP._set_global_var('errorInfo', msg)
    # fail(e)
    fail(e, msg)
  end
end

    		
  





    
  


  

    
Instance Method Details


    
      

  

  
    #_tk_call_to_list_core(depth, arg_enc, val_enc, *args)  ⇒ Object 
  

  

  




  

    
      


1878
1879
1880
1881
1882
1883
1884
1885
1886

    		
    
      
# File 'lib/tk.rb', line 1878

def _tk_call_to_list_core(depth, arg_enc, val_enc, *args)
  args = _conv_args([], arg_enc, *args)
  val = _tk_call_core(false, *args)
  if !depth.kind_of?(Integer) || depth == 0
    tk_split_simplelist(val, false, val_enc)
  else
    tk_split_list(val, depth, false, val_enc)
  end
end

    		
  





    
      

  

  
    #after(ms, cmd = Proc.new)  ⇒ Object 
  

  

  




  

    
      


1467
1468
1469
1470
1471
1472

    		
    
      
# File 'lib/tk.rb', line 1467

def after(ms, cmd=Proc.new)
  cmdid = install_cmd(proc{ret = cmd.call;uninstall_cmd(cmdid); ret})
  after_id = tk_call_without_enc("after",ms,cmdid)
  after_id.instance_variable_set('@cmdid', cmdid)
  after_id
end

    		
  





    
      

  

  
    #after_cancel(afterId)  ⇒ Object 
  

  

  




  

    

def after_idle(cmd=Proc.new)



  crit_bup = Thread.critical
  Thread.critical = true

  myid = _curr_cmd_id
  cmdid = install_cmd(proc{ret = cmd.call;uninstall_cmd(myid); ret})

  Thread.critical = crit_bup

  tk_call_without_enc('after','idle',cmdid)
end




  





  



  

    
      


1519
1520
1521
1522
1523
1524
1525
1526

    		
    
      
# File 'lib/tk.rb', line 1519

def after_cancel(afterId)
  tk_call_without_enc('after','cancel',afterId)
  if (cmdid = afterId.instance_variable_get('@cmdid'))
    afterId.instance_variable_set('@cmdid', nil)
    uninstall_cmd(cmdid)
  end
  afterId
end

    		
  





    
      

  

  
    #after_idle(cmd = Proc.new)  ⇒ Object 
  

  

  




  

    

def after(ms, cmd=Proc.new)



crit_bup = Thread.critical
Thread.critical = true

myid = _curr_cmd_id
cmdid = install_cmd(proc{ret = cmd.call;uninstall_cmd(myid); ret})

Thread.critical = crit_bup

tk_call_without_enc("after",ms,cmdid)  # return id




#    return #    if false #defined? Thread #      Thread.start do #       ms = Float(ms)/1000 #       ms = 10 if ms == 0 #       sleep ms/1000 #       cmd.call #      end #    else #      cmdid = install_cmd(cmd) #      tk_call(“after”,ms,cmdid) #    end



end




  





  



  

    
      


1499
1500
1501
1502
1503
1504

    		
    
      
# File 'lib/tk.rb', line 1499

def after_idle(cmd=Proc.new)
  cmdid = install_cmd(proc{ret = cmd.call;uninstall_cmd(cmdid); ret})
  after_id = tk_call_without_enc('after','idle',cmdid)
  after_id.instance_variable_set('@cmdid', cmdid)
  after_id
end

    		
  





    
      

  

  
    #appname(name = None)  ⇒ Object 
  

  

  




  

    
      


1560
1561
1562

    		
    
      
# File 'lib/tk.rb', line 1560

def appname(name=None)
  tk_call('tk', 'appname', name)
end

    		
  





    
      

  

  
    #appsend(interp, async, *args)  ⇒ Object 
  

  

  




  

    
      


1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583

    		
    
      
# File 'lib/tk.rb', line 1568

def appsend(interp, async, *args)
  if $SAFE >= 4
    fail SecurityError, "cannot send Tk commands at level 4"
  elsif $SAFE >= 1 && args.find{|obj| obj.tainted?}
    fail SecurityError, "cannot send tainted Tk commands at level #{$SAFE}"
  end
  if async != true && async != false && async != nil
    args.unshift(async)
    async = false
  end
  if async
    tk_call('send', '-async', '--', interp, *args)
  else
    tk_call('send', '--', interp, *args)
  end
end

    		
  





    
      

  

  
    #appsend_deny  ⇒ Object 
  

  

  




  

    
      


1564
1565
1566

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

def appsend_deny
  tk_call('rename', 'send', '')
end

    		
  





    
      

  

  
    #appsend_displayof(interp, win, async, *args)  ⇒ Object 
  

  

  




  

    
      


1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619

    		
    
      
# File 'lib/tk.rb', line 1603

def appsend_displayof(interp, win, async, *args)
  if $SAFE >= 4
    fail SecurityError, "cannot send Tk commands at level 4"
  elsif $SAFE >= 1 && args.find{|obj| obj.tainted?}
    fail SecurityError, "cannot send tainted Tk commands at level #{$SAFE}"
  end
  win = '.' if win == nil
  if async != true && async != false && async != nil
    args.unshift(async)
    async = false
  end
  if async
    tk_call('send', '-async', '-displayof', win, '--', interp, *args)
  else
    tk_call('send', '-displayor', win, '--', interp, *args)
  end
end

    		
  





    
      

  

  
    #callback_break  ⇒ Object 
  

  

  




  

    
      


1369
1370
1371

    		
    
      
# File 'lib/tk.rb', line 1369

def callback_break
  fail TkCallbackBreak, "Tk callback returns 'break' status"
end

    		
  





    
      

  

  
    #callback_continue  ⇒ Object 
  

  

  




  

    
      


1373
1374
1375

    		
    
      
# File 'lib/tk.rb', line 1373

def callback_continue
  fail TkCallbackContinue, "Tk callback returns 'continue' status"
end

    		
  





    
      

  

  
    #callback_return  ⇒ Object 
  

  

  




  

    
      


1377
1378
1379

    		
    
      
# File 'lib/tk.rb', line 1377

def callback_return
  fail TkCallbackReturn, "Tk callback returns 'return' status"
end

    		
  





    
      

  

  
    #chooseColor(keys = nil)  ⇒ Object 
  

  

  




  

    
      


1768
1769
1770

    		
    
      
# File 'lib/tk.rb', line 1768

def chooseColor(keys = nil)
  tk_call('tk_chooseColor', *hash_kv(keys))
end

    		
  





    
      

  

  
    #chooseDirectory(keys = nil)  ⇒ Object 
  

  

  




  

    
      


1772
1773
1774

    		
    
      
# File 'lib/tk.rb', line 1772

def chooseDirectory(keys = nil)
  tk_call('tk_chooseDirectory', *hash_kv(keys))
end

    		
  





    
      

  

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

  

  




  

    
      


1694
1695
1696

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

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

    		
  





    
      

  

  
    #event_generate(win, context, keys = nil)  ⇒ Object 
  

  

  




  

    
      


1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748

    		
    
      
# File 'lib/tk.rb', line 1735

def event_generate(win, context, keys=nil)
  #win = win.path if win.kind_of?(TkObject)
  if context.kind_of?(TkEvent::Event)
    context.generate(win, ((keys)? keys: {}))
  elsif keys
    tk_call_without_enc('event', 'generate', win, 
                        "<#{tk_event_sequence(context)}>", 
                        *hash_kv(keys, true))
  else
    tk_call_without_enc('event', 'generate', win, 
                        "<#{tk_event_sequence(context)}>")
  end
  nil
end

    		
  





    
      

  

  
    #get_eventloop_tick  ⇒ Object 
  

  

  




  

    
      


1702
1703
1704

    		
    
      
# File 'lib/tk.rb', line 1702

def get_eventloop_tick()
  TclTkLib.get_eventloop_tick
end

    		
  





    
      

  

  
    #get_eventloop_weight  ⇒ Object 
  

  

  




  

    
      


1718
1719
1720

    		
    
      
# File 'lib/tk.rb', line 1718

def get_eventloop_weight()
  TclTkLib.get_eventloop_weight
end

    		
  





    
      

  

  
    #get_no_event_wait  ⇒ Object 
  

  

  




  

    
      


1710
1711
1712

    		
    
      
# File 'lib/tk.rb', line 1710

def get_no_event_wait()
  TclTkLib.get_no_eventloop_wait
end

    		
  





    
      

  

  
    #getMultipleOpenFile(keys = nil)  ⇒ Object 
  

  

  




  

    
      


1757
1758
1759

    		
    
      
# File 'lib/tk.rb', line 1757

def getMultipleOpenFile(keys = nil)
  simplelist(tk_call('tk_getOpenFile', '-multiple', '1', *hash_kv(keys)))
end

    		
  





    
      

  

  
    #getMultipleSaveFile(keys = nil)  ⇒ Object 
  

  

  




  

    
      


1764
1765
1766

    		
    
      
# File 'lib/tk.rb', line 1764

def getMultipleSaveFile(keys = nil)
  simplelist(tk_call('tk_getSaveFile', '-multiple', '1', *hash_kv(keys)))
end

    		
  





    
      

  

  
    #getOpenFile(keys = nil)  ⇒ Object 
  

  

  




  

    
      


1754
1755
1756

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

def getOpenFile(keys = nil)
  tk_call('tk_getOpenFile', *hash_kv(keys))
end

    		
  





    
      

  

  
    #getSaveFile(keys = nil)  ⇒ Object 
  

  

  




  

    
      


1761
1762
1763

    		
    
      
# File 'lib/tk.rb', line 1761

def getSaveFile(keys = nil)
  tk_call('tk_getSaveFile', *hash_kv(keys))
end

    		
  





    
      

  

  
    #inactive  ⇒ Object 
  

  

  




  

    
      


1547
1548
1549

    		
    
      
# File 'lib/tk.rb', line 1547

def inactive
  Integer(tk_call_without_enc('tk', 'inactive'))
end

    		
  





    
      

  

  
    #inactive_displayof(win)  ⇒ Object 
  

  

  




  

    
      


1550
1551
1552

    		
    
      
# File 'lib/tk.rb', line 1550

def inactive_displayof(win)
  Integer(tk_call_without_enc('tk', 'inactive', '-displayof', win))
end

    		
  





    
      

  

  
    #info(*args)  ⇒ Object 
  

  

  




  

    
      


1640
1641
1642

    		
    
      
# File 'lib/tk.rb', line 1640

def info(*args)
  tk_call('info', *args)
end

    		
  





    
      

  

  
    #ip_eval(cmd_string)  ⇒ Object 
  

  

  




  

    
      


1792
1793
1794

    		
    
      
# File 'lib/tk.rb', line 1792

def ip_eval(cmd_string)
  _ip_eval_core(nil, cmd_string)
end

    		
  





    
      

  

  
    #ip_eval_with_enc(cmd_string)  ⇒ Object 
  

  

  




  

    
      


1800
1801
1802

    		
    
      
# File 'lib/tk.rb', line 1800

def ip_eval_with_enc(cmd_string)
  _ip_eval_core(true, cmd_string)
end

    		
  





    
      

  

  
    #ip_eval_without_enc(cmd_string)  ⇒ Object 
  

  

  




  

    
      


1796
1797
1798

    		
    
      
# File 'lib/tk.rb', line 1796

def ip_eval_without_enc(cmd_string)
  _ip_eval_core(false, cmd_string)
end

    		
  





    
      

  

  
    #ip_invoke(*args)  ⇒ Object 
  

  

  




  

    
      


1820
1821
1822

    		
    
      
# File 'lib/tk.rb', line 1820

def ip_invoke(*args)
  _ip_invoke_core(nil, *args)
end

    		
  





    
      

  

  
    #ip_invoke_with_enc(*args)  ⇒ Object 
  

  

  




  

    
      


1828
1829
1830

    		
    
      
# File 'lib/tk.rb', line 1828

def ip_invoke_with_enc(*args)
  _ip_invoke_core(true, *args)
end

    		
  





    
      

  

  
    #ip_invoke_without_enc(*args)  ⇒ Object 
  

  

  




  

    
      


1824
1825
1826

    		
    
      
# File 'lib/tk.rb', line 1824

def ip_invoke_without_enc(*args)
  _ip_invoke_core(false, *args)
end

    		
  





    
      

  

  
    #is_mainloop?  ⇒ Boolean 
  

  

  




  

    

  





  

Returns:


    
  
    
  • 
      
      
        (Boolean)
      
      
      
    
    • 
  





  

    
      


1685
1686
1687

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

def is_mainloop?
  TclTkLib.mainloop_thread? == true
end

    		
  





    
      

  

  
    #load_cmd_on_ip(tk_cmd)  ⇒ Object 
  

  

  




  

    

def TkCore.callback(arg_str)



# arg = tk_split_list(arg_str)
arg = tk_split_simplelist(arg_str)
#_get_eval_string(TkUtil.eval_cmd(Tk_CMDTBL[arg.shift], *arg))
#_get_eval_string(TkUtil.eval_cmd(TkCore::INTERP.tk_cmd_tbl[arg.shift], 
#                        *arg))
# TkCore::INTERP.tk_cmd_tbl[arg.shift].call(*arg)
begin
  TkCore::INTERP.tk_cmd_tbl[arg.shift].call(*arg)
rescue Exception => e
  raise(e, e.class.inspect + ': ' + e.message + "\n" + 
           "\n---< backtrace of Ruby side >-----\n" + 
           e.backtrace.join("\n") + 
           "\n---< backtrace of Tk side >-------")
end




#=begin #    cb_obj = TkCore::INTERP.tk_cmd_tbl #    unless $DEBUG #      cb_obj.call(*arg) #    else #      begin #       raise ‘check backtrace’ #      rescue #       # ignore backtrace before ‘callback’ #       pos = -($!.backtrace.size) #      end #      begin #       cb_obj.call(*arg) #      rescue #       trace = $!.backtrace #       raise $!, “n#0: #TkCore.$!$!.message (#TkCore.$!$!.class)n” + #                 “tfrom #.join(”ntfrom “)” #      end #    end #=end



end




  





  



  

    
      


1463
1464
1465

    		
    
      
# File 'lib/tk.rb', line 1463

def load_cmd_on_ip(tk_cmd)
  bool(tk_call('auto_load', tk_cmd))
end

    		
  





    
      

  

  
    #mainloop(check_root = true)  ⇒ Object 
  

  

  




  

    
      


1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666

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

def mainloop(check_root = true)
  if !TkCore::WITH_RUBY_VM || TkCore::RUN_EVENTLOOP_ON_MAIN_THREAD
    TclTkLib.mainloop(check_root)
  else ### Ruby 1.9 !!!!!
    begin
      TclTkLib.set_eventloop_window_mode(true)
      if check_root
        INTERP_MUTEX.synchronize{
          INTERP_ROOT_CHECK.wait(INTERP_MUTEX)
          status = INTERP_THREAD[:status]
          if status
            INTERP_THREAD[:status] = nil
            raise status if status.kind_of?(Exception)
          end
        }
      else
        INTERP_THREAD.value
      end
    ensure
      TclTkLib.set_eventloop_window_mode(false)
    end
  end
end

    		
  





    
      

  

  
    #mainloop_exist?  ⇒ Boolean 
  

  

  




  

    

  





  

Returns:


    
  
    
  • 
      
      
        (Boolean)
      
      
      
    
    • 
  





  

    
      


1681
1682
1683

    		
    
      
# File 'lib/tk.rb', line 1681

def mainloop_exist?
  TclTkLib.mainloop_thread? != nil
end

    		
  





    
      

  

  
    #mainloop_thread?  ⇒ Boolean 
  

  

  




  

    

  





  

Returns:


    
  
    
  • 
      
      
        (Boolean)
      
      
      
    
    • 
  





  

    
      


1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679

    		
    
      
# File 'lib/tk.rb', line 1668

def mainloop_thread?
  # true  : current thread is mainloop
  # nil   : there is no mainloop
  # false : mainloop is running on the other thread
  #         ( At then, it is dangerous to call Tk interpreter directly. )
  if !TkCore::WITH_RUBY_VM || TkCore::RUN_EVENTLOOP_ON_MAIN_THREAD
    ### Ruby 1.9 !!!!!!!!!!!
    TclTkLib.mainloop_thread?
  else
    Thread.current == INTERP_THREAD
  end
end

    		
  





    
      

  

  
    #mainloop_watchdog(check_root = true)  ⇒ Object 
  

  

  




  

    
      


1689
1690
1691
1692

    		
    
      
# File 'lib/tk.rb', line 1689

def mainloop_watchdog(check_root = true)
  # watchdog restarts mainloop when mainloop is dead
  TclTkLib.mainloop_watchdog(check_root)
end

    		
  





    
      

  

  
    #messageBox(keys)  ⇒ Object 
  

  

  




  

    
      


1750
1751
1752

    		
    
      
# File 'lib/tk.rb', line 1750

def messageBox(keys)
  tk_call('tk_messageBox', *hash_kv(keys))
end

    		
  





    
      

  

  
    #rb_appsend(interp, async, *args)  ⇒ Object 
  

  

  




  

    
      


1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601

    		
    
      
# File 'lib/tk.rb', line 1585

def rb_appsend(interp, async, *args)
  if $SAFE >= 4
    fail SecurityError, "cannot send Ruby commands at level 4"
  elsif $SAFE >= 1 && args.find{|obj| obj.tainted?}
    fail SecurityError, "cannot send tainted Ruby commands at level #{$SAFE}"
  end
  if async != true && async != false && async != nil
    args.unshift(async)
    async = false
  end
  #args = args.collect!{|c| _get_eval_string(c).gsub(/[\[\]$"]/, '\\\\\&')}
  args = args.collect!{|c| _get_eval_string(c).gsub(/[\[\]$"\\]/, '\\\\\&')}
  # args.push(').to_s"')
  # appsend(interp, async, 'ruby "(', *args)
  args.push('}.call)"')
  appsend(interp, async, 'ruby "TkComm._get_eval_string(proc{', *args)
end

    		
  





    
      

  

  
    #rb_appsend_displayof(interp, win, async, *args)  ⇒ Object 
  

  

  




  

    
      


1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638

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

def rb_appsend_displayof(interp, win, async, *args)
  if $SAFE >= 4
    fail SecurityError, "cannot send Ruby commands at level 4"
  elsif $SAFE >= 1 && args.find{|obj| obj.tainted?}
    fail SecurityError, "cannot send tainted Ruby commands at level #{$SAFE}"
  end
  win = '.' if win == nil
  if async != true && async != false && async != nil
    args.unshift(async)
    async = false
  end
  #args = args.collect!{|c| _get_eval_string(c).gsub(/[\[\]$"]/, '\\\\\&')}
  args = args.collect!{|c| _get_eval_string(c).gsub(/[\[\]$"\\]/, '\\\\\&')}
  # args.push(').to_s"')
  # appsend_displayof(interp, win, async, 'ruby "(', *args)
  args.push('}.call)"')
  appsend(interp, win, async, 'ruby "TkComm._get_eval_string(proc{', *args)
end

    		
  





    
      

  

  
    #reset_inactive  ⇒ Object 
  

  

  




  

    
      


1553
1554
1555

    		
    
      
# File 'lib/tk.rb', line 1553

def reset_inactive
  tk_call_without_enc('tk', 'inactive', 'reset')
end

    		
  





    
      

  

  
    #reset_inactive_displayof(win)  ⇒ Object 
  

  

  




  

    
      


1556
1557
1558

    		
    
      
# File 'lib/tk.rb', line 1556

def reset_inactive_displayof(win)
  tk_call_without_enc('tk', 'inactive', '-displayof', win, 'reset')
end

    		
  





    
      

  

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

  

  




  

    
      


1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733

    		
    
      
# File 'lib/tk.rb', line 1722

def restart(app_name = nil, keys = {})
  TkCore::INTERP.init_ip_internal

  tk_call('set', 'argv0', app_name) if app_name
  if keys.kind_of?(Hash)
    # tk_call('set', 'argc', keys.size * 2)
    tk_call('set', 'argv', hash_kv(keys).join(' '))
  end

  INTERP.restart
  nil
end

    		
  





    
      

  

  
    #scaling(scale = nil)  ⇒ Object 
  

  

  




  

    
      


1532
1533
1534
1535
1536
1537
1538

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

def scaling(scale=nil)
  if scale
    tk_call_without_enc('tk', 'scaling', scale)
  else
    Float(number(tk_call_without_enc('tk', 'scaling')))
  end
end

    		
  





    
      

  

  
    #scaling_displayof(win, scale = nil)  ⇒ Object 
  

  

  




  

    
      


1539
1540
1541
1542
1543
1544
1545

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

def scaling_displayof(win, scale=nil)
  if scale
    tk_call_without_enc('tk', 'scaling', '-displayof', win, scale)
  else
    Float(number(tk_call_without_enc('tk', '-displayof', win, 'scaling')))
  end
end

    		
  





    
      

  

  
    #set_eventloop_tick(timer_tick)  ⇒ Object 
  

  

  




  

    
      


1698
1699
1700

    		
    
      
# File 'lib/tk.rb', line 1698

def set_eventloop_tick(timer_tick)
  TclTkLib.set_eventloop_tick(timer_tick)
end

    		
  





    
      

  

  
    #set_eventloop_weight(loop_max, no_event_tick)  ⇒ Object 
  

  

  




  

    
      


1714
1715
1716

    		
    
      
# File 'lib/tk.rb', line 1714

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

    		
  





    
      

  

  
    #set_no_event_wait(wait)  ⇒ Object 
  

  

  




  

    
      


1706
1707
1708

    		
    
      
# File 'lib/tk.rb', line 1706

def set_no_event_wait(wait)
  TclTkLib.set_no_even_wait(wait)
end

    		
  





    
      

  

  
    #tk_call(*args)  ⇒ Object 
  

  

  




  

    
      


1866
1867
1868

    		
    
      
# File 'lib/tk.rb', line 1866

def tk_call(*args)
  _tk_call_core(nil, *args)
end

    		
  





    
      

  

  
    #tk_call_to_list(*args)  ⇒ Object 
  

  

  




  

    

private :_tk_call_to_list_core



  





  



  

    
      


1889
1890
1891

    		
    
      
# File 'lib/tk.rb', line 1889

def tk_call_to_list(*args)
  _tk_call_to_list_core(-1, nil, true, *args)
end

    		
  





    
      

  

  
    #tk_call_to_list_with_enc(*args)  ⇒ Object 
  

  

  




  

    
      


1897
1898
1899

    		
    
      
# File 'lib/tk.rb', line 1897

def tk_call_to_list_with_enc(*args)
  _tk_call_to_list_core(-1, true, true, *args)
end

    		
  





    
      

  

  
    #tk_call_to_list_without_enc(*args)  ⇒ Object 
  

  

  




  

    
      


1893
1894
1895

    		
    
      
# File 'lib/tk.rb', line 1893

def tk_call_to_list_without_enc(*args)
  _tk_call_to_list_core(-1, false, false, *args)
end

    		
  





    
      

  

  
    #tk_call_to_simplelist(*args)  ⇒ Object 
  

  

  




  

    
      


1901
1902
1903

    		
    
      
# File 'lib/tk.rb', line 1901

def tk_call_to_simplelist(*args)
  _tk_call_to_list_core(0, nil, true, *args)
end

    		
  





    
      

  

  
    #tk_call_to_simplelist_with_enc(*args)  ⇒ Object 
  

  

  




  

    
      


1909
1910
1911

    		
    
      
# File 'lib/tk.rb', line 1909

def tk_call_to_simplelist_with_enc(*args)
  _tk_call_to_list_core(0, true, true, *args)
end

    		
  





    
      

  

  
    #tk_call_to_simplelist_without_enc(*args)  ⇒ Object 
  

  

  




  

    
      


1905
1906
1907

    		
    
      
# File 'lib/tk.rb', line 1905

def tk_call_to_simplelist_without_enc(*args)
  _tk_call_to_list_core(0, false, false, *args)
end

    		
  





    
      

  

  
    #tk_call_with_enc(*args)  ⇒ Object 
  

  

  




  

    
      


1874
1875
1876

    		
    
      
# File 'lib/tk.rb', line 1874

def tk_call_with_enc(*args)
  _tk_call_core(true, *args)
end

    		
  





    
      

  

  
    #tk_call_without_enc(*args)  ⇒ Object 
  

  

  




  

    
      


1870
1871
1872

    		
    
      
# File 'lib/tk.rb', line 1870

def tk_call_without_enc(*args)
  _tk_call_core(false, *args)
end

    		
  





    
      

  

  
    #windowingsystem  ⇒ Object 
  

  

  




  

    
      


1528
1529
1530

    		
    
      
# File 'lib/tk.rb', line 1528

def windowingsystem
  tk_call_without_enc('tk', 'windowingsystem')
end