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::Busy, Tk::Busy, Tk::Clock, Tk::Iwidgets, Tk::Iwidgets::Labeledwidget, Tk::Mac, Tk::Tcllib::Autoscroll, Tk::Tcllib::Crosshair, Tk::Tcllib::Cursor, Tk::Tcllib::Diagrams, Tk::Tcllib::History, Tk::Tcllib::Plotchart, Tk::Tcllib::Plotchart::ChartMethod, Tk::Tcllib::Style, Tk::Tcllib::Tooltip, Tk::Tcllib::Validator, Tk::Tile::Style, Tk::TkDND::Shape, Tk::Trofs, Tk::Wm, TkFont, TkFont::Chooser, 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)
    interp = TclTkIp.new(name, opts)
  rescue => e
    Thread.current[:interp] = e
    raise e
  end

  interp.mainloop_abort_on_exception = true
  Thread.current.instance_variable_set("@interp", interp)

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

  Thread.current[:status] = status
  #sleep

  # like as 1.8, withdraw a root widget before calling Tk.mainloop
  interp._eval "wm withdraw .\nrename wm __wm_orig__\nproc wm {subcmd win args} {\n  set val [eval [list __wm_orig__ $subcmd $win] $args]\n  if {[string equal $subcmd withdraw] && [string equal $win .]} {\n    rename wm {}\n    rename __wm_orig__ wm\n  }\n  return $val\n}\nproc __startup_rbtk_mainloop__ {args} {\n  rename __startup_rbtk_mainloop__ {}\n  if {[info command __wm_orig__] == \"__wm_orig__\"} {\n    rename wm {}\n    rename __wm_orig__ wm\n    if [string equal [wm state .] withdrawn] {\nwm deiconify .\n    }\n  }\n}\nset __initial_state_of_rubytk__ 1\ntrace add variable __initial_state_of_rubytk__ unset __startup_rbtk_mainloop__\n\n# complete initializing\nruby {TkCore::INTERP_THREAD[:interp] = TkCore::INTERP_THREAD.instance_variable_get('@interp')}\n"

  begin
    begin
      #TclTkLib.mainloop_abort_on_exception = false
      #interp.mainloop_abort_on_exception = true
      #Thread.current[:interp] = interp
      #Thread.current[:status].value = TclTkLib.mainloop(true)
      Thread.current[:status].value = interp.mainloop(true)
    rescue SystemExit=>e
      Thread.current[:status].value = e
    rescue Exception=>e
      Thread.current[:status].value = e
      p e if $DEBUG
      retry if interp.has_mainwindow?
    ensure
      INTERP_MUTEX.synchronize{ INTERP_ROOT_CHECK.broadcast }
    end

    unless interp.deleted?
      begin
        #Thread.current[:status].value = TclTkLib.mainloop(false)
        Thread.current[:status].value = interp.mainloop(false)
      rescue Exception=>e
        puts "ignore exception on interp: #{e.inspect}\n" if $DEBUG
      end
    end

  ensure
    # interp must be deleted before the thread for interp is dead.
    # If not, raise Tcl_Panic on Tcl_AsyncDelete because async handler
    # deleted by the wrong thread.
    interp.delete
  end
}
INTERP_THREAD_STATUS = 

      
        
INTERP_MUTEX =
          
        

        
Mutex.new


      
        
INTERP_ROOT_CHECK =
          
        

        
ConditionVariable.new


      
        
INTERP =
          
        

        

      
        
WITH_RUBY_VM =
          
        

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


      
        
WITH_ENCODING =
          
        

        
defined?(::Encoding.default_external) && true


      
        
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_nil, num_or_str, number, procedure, simplelist, slice_ary, 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_nil, #num_or_nil, num_or_str, #num_or_str, number, #number, string, #string, uninstall_cmd, untrust


  
  
  
  
  
  
  
  
  
Methods included from TkEvent

  
#install_bind, #install_bind_for_event_class



  

    
Class Method Details


    
      

  

  
    .callback(*arg)  ⇒ Object 
  

  

  




  

    
      


1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618

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

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 
  

  

  




  

    
      


2050
2051
2052
2053
2054
2055
2056
2057
2058

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

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

  

  




  

    
      


1662
1663
1664
1665
1666
1667
1668

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

def after(ms, cmd=nil, &block)
  cmd ||= block
  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 
  

  

  




  

    
      


1678
1679
1680
1681
1682
1683
1684
1685

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

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

  

  




  

    
      


1670
1671
1672
1673
1674
1675
1676

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

def after_idle(cmd=nil, &block)
  cmd ||= block
  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 
  

  

  




  

    
      


1719
1720
1721

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

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


    		
  





    
      

  

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

  

  




  

    
      


1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737

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

def appsend(interp, async, *args)
  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 
  

  

  




  

    
      


1723
1724
1725

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

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


    		
  





    
      

  

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

  

  




  

    
      


1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763

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

def appsend_displayof(interp, win, async, *args)
  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 
  

  

  




  

    
      


1564
1565
1566

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

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


    		
  





    
      

  

  
    #callback_continue  ⇒ Object 
  

  

  




  

    
      


1568
1569
1570

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

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


    		
  





    
      

  

  
    #callback_return  ⇒ Object 
  

  

  




  

    
      


1572
1573
1574

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

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


    		
  





    
      

  

  
    #chooseColor(keys = nil)  ⇒ Object 
  

  

  




  

    
      


1942
1943
1944

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

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


    		
  





    
      

  

  
    #chooseDirectory(keys = nil)  ⇒ Object 
  

  

  




  

    
      


1946
1947
1948

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

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


    		
  





    
      

  

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

  

  




  

    
      


1868
1869
1870

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

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


    		
  





    
      

  

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

  

  




  

    
      


1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922

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

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 
  

  

  




  

    
      


1876
1877
1878

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

def get_eventloop_tick()
  TclTkLib.get_eventloop_tick
end


    		
  





    
      

  

  
    #get_eventloop_weight  ⇒ Object 
  

  

  




  

    
      


1892
1893
1894

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

def get_eventloop_weight()
  TclTkLib.get_eventloop_weight
end


    		
  





    
      

  

  
    #get_no_event_wait  ⇒ Object 
  

  

  




  

    
      


1884
1885
1886

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

def get_no_event_wait()
  TclTkLib.get_no_eventloop_wait
end


    		
  





    
      

  

  
    #getMultipleOpenFile(keys = nil)  ⇒ Object 
  

  

  




  

    
      


1931
1932
1933

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

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


    		
  





    
      

  

  
    #getMultipleSaveFile(keys = nil)  ⇒ Object 
  

  

  




  

    
      


1938
1939
1940

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

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


    		
  





    
      

  

  
    #getOpenFile(keys = nil)  ⇒ Object 
  

  

  




  

    
      


1928
1929
1930

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

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


    		
  





    
      

  

  
    #getSaveFile(keys = nil)  ⇒ Object 
  

  

  




  

    
      


1935
1936
1937

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

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


    		
  





    
      

  

  
    #inactive  ⇒ Object 
  

  

  




  

    
      


1706
1707
1708

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

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


    		
  





    
      

  

  
    #inactive_displayof(win)  ⇒ Object 
  

  

  




  

    
      


1709
1710
1711

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

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


    		
  





    
      

  

  
    #info(*args)  ⇒ Object 
  

  

  




  

    
      


1779
1780
1781

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

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


    		
  





    
      

  

  
    #ip_eval(cmd_string)  ⇒ Object 
  

  

  




  

    
      


1966
1967
1968

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

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


    		
  





    
      

  

  
    #ip_eval_with_enc(cmd_string)  ⇒ Object 
  

  

  




  

    
      


1974
1975
1976

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

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


    		
  





    
      

  

  
    #ip_eval_without_enc(cmd_string)  ⇒ Object 
  

  

  




  

    
      


1970
1971
1972

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

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


    		
  





    
      

  

  
    #ip_invoke(*args)  ⇒ Object 
  

  

  




  

    
      


1994
1995
1996

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

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


    		
  





    
      

  

  
    #ip_invoke_with_enc(*args)  ⇒ Object 
  

  

  




  

    
      


2002
2003
2004

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

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


    		
  





    
      

  

  
    #ip_invoke_without_enc(*args)  ⇒ Object 
  

  

  




  

    
      


1998
1999
2000

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

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


    		
  





    
      

  

  
    #is_mainloop?  ⇒ Boolean 
  

  

  




  

    

  





  

Returns:


    
  
    
  • 
      
      
        (Boolean)
      
      
      
    
    • 
  





  

    
      


1859
1860
1861

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

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




  





  



  

    
      


1658
1659
1660

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

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


    		
  





    
      

  

  
    #mainloop(check_root = true)  ⇒ Object 
  

  

  




  

    
      


1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840

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

def mainloop(check_root = true)
  if !TkCore::WITH_RUBY_VM
    TclTkLib.mainloop(check_root)

  elsif TkCore::RUN_EVENTLOOP_ON_MAIN_THREAD
    # if TclTkLib::WINDOWING_SYSTEM == 'aqua' &&
    #if TkCore::INTERP._invoke_without_enc('tk','windowingsystem')=='aqua' &&
    #    Thread.current != Thread.main &&
    #    (TclTkLib.get_version <=> [8,4,TclTkLib::RELEASE_TYPE::FINAL,9]) > 0
    #  raise RuntimeError,
    #       "eventloop on TkAqua ( > Tk8.4.9 ) works on the main thread only"
    #end
    if Thread.current != Thread.main
      raise RuntimeError, "Tk.mainloop is allowed on the main thread only"
    end
    TclTkLib.mainloop(check_root)

  else ### Ruby 1.9 !!!!!
    unless TkCore::INTERP.default_master?
      # [MultiTkIp] slave interp ?
      return TkCore::INTERP._thread_tkwait('window', '.') if check_root
    end

    # like as 1.8, withdraw a root widget before calling Tk.mainloop
    TkCore::INTERP._eval_without_enc('catch {unset __initial_state_of_rubytk__}')
    INTERP_THREAD.run

    begin
      TclTkLib.set_eventloop_window_mode(true)

      # force run the eventloop
      TkCore::INTERP._eval_without_enc('update')
      TkCore::INTERP._eval_without_enc('catch {set __initial_state_of_rubytk__}')
      INTERP_THREAD.run
      if check_root
        INTERP_MUTEX.synchronize{
          INTERP_ROOT_CHECK.wait(INTERP_MUTEX)
          status = INTERP_THREAD_STATUS.value
          if status && TkCore::INTERP.default_master?
            INTERP_THREAD_STATUS.value = nil
            raise status if status.kind_of?(Exception)
          end
        }
      else
        # INTERP_THREAD.value
        begin
          INTERP_THREAD.value
        rescue Exception => e
          raise e
        end
      end
    rescue Exception => e
      raise e
    ensure
      TclTkLib.set_eventloop_window_mode(false)
    end
  end
end


    		
  





    
      

  

  
    #mainloop_exist?  ⇒ Boolean 
  

  

  




  

    

  





  

Returns:


    
  
    
  • 
      
      
        (Boolean)
      
      
      
    
    • 
  





  

    
      


1855
1856
1857

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

def mainloop_exist?
  TclTkLib.mainloop_thread? != nil
end


    		
  





    
      

  

  
    #mainloop_thread?  ⇒ Boolean 
  

  

  




  

    

  





  

Returns:


    
  
    
  • 
      
      
        (Boolean)
      
      
      
    
    • 
  





  

    
      


1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853

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

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 
  

  

  




  

    
      


1863
1864
1865
1866

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

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


    		
  





    
      

  

  
    #messageBox(keys)  ⇒ Object 
  

  

  




  

    
      


1924
1925
1926

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

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


    		
  





    
      

  

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

  

  




  

    
      


1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750

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

def rb_appsend(interp, async, *args)
  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 
  

  

  




  

    
      


1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777

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

def rb_appsend_displayof(interp, win, async, *args)
  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 
  

  

  




  

    
      


1712
1713
1714

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

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


    		
  





    
      

  

  
    #reset_inactive_displayof(win)  ⇒ Object 
  

  

  




  

    
      


1715
1716
1717

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

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


    		
  





    
      

  

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

  

  




  

    
      


1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907

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

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 
  

  

  




  

    
      


1691
1692
1693
1694
1695
1696
1697

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

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 
  

  

  




  

    
      


1698
1699
1700
1701
1702
1703
1704

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

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 
  

  

  




  

    
      


1872
1873
1874

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

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


    		
  





    
      

  

  
    #set_eventloop_weight(loop_max, no_event_tick)  ⇒ Object 
  

  

  




  

    
      


1888
1889
1890

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

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 
  

  

  




  

    
      


1880
1881
1882

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

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


    		
  





    
      

  

  
    #tk_call(*args)  ⇒ Object 
  

  

  




  

    
      


2038
2039
2040

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

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


    		
  





    
      

  

  
    #tk_call_to_list(*args)  ⇒ Object 
  

  

  




  

    

private :_tk_call_to_list_core



  





  



  

    
      


2061
2062
2063

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

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


    		
  





    
      

  

  
    #tk_call_to_list_with_enc(*args)  ⇒ Object 
  

  

  




  

    
      


2069
2070
2071

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

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 
  

  

  




  

    
      


2065
2066
2067

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

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


    		
  





    
      

  

  
    #tk_call_to_simplelist(*args)  ⇒ Object 
  

  

  




  

    
      


2073
2074
2075

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

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


    		
  





    
      

  

  
    #tk_call_to_simplelist_with_enc(*args)  ⇒ Object 
  

  

  




  

    
      


2081
2082
2083

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

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 
  

  

  




  

    
      


2077
2078
2079

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

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


    		
  





    
      

  

  
    #tk_call_with_enc(*args)  ⇒ Object 
  

  

  




  

    
      


2046
2047
2048

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

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


    		
  





    
      

  

  
    #tk_call_without_enc(*args)  ⇒ Object 
  

  

  




  

    
      


2042
2043
2044

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

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


    		
  





    
      

  

  
    #windowingsystem  ⇒ Object 
  

  

  




  

    
      


1687
1688
1689

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

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