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 <<EOS
wm withdraw .
rename wm __wm_orig__
proc wm {subcmd win args} {
  set val [eval [list __wm_orig__ $subcmd $win] $args]
  if {[string equal $subcmd withdraw] && [string equal $win .]} {
    rename wm {}
    rename __wm_orig__ wm
  }
  return $val
}
proc __startup_rbtk_mainloop__ {args} {
  rename __startup_rbtk_mainloop__ {}
  if {[info command __wm_orig__] == "__wm_orig__"} {
    rename wm {}
    rename __wm_orig__ wm
    if [string equal [wm state .] withdrawn] {
wm deiconify .
    }
  }
}
set __initial_state_of_rubytk__ 1
trace add variable __initial_state_of_rubytk__ unset __startup_rbtk_mainloop__

# complete initializing
ruby {TkCore::INTERP_THREAD[:interp] = TkCore::INTERP_THREAD.instance_variable_get('@interp')}
EOS

  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_THREAD[:status]
INTERP_MUTEX = 
Mutex.new
INTERP_ROOT_CHECK = 
ConditionVariable.new
INTERP = 
INTERP_THREAD[: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 TkEvent

#install_bind, #install_bind_for_event_class

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

Class Method Details

.callback(*arg) ⇒ Object 



1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
 
# File 'lib/tk.rb', line 1600

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 



2132
2133
2134
2135
2136
2137
2138
2139
2140
 
# File 'lib/tk.rb', line 2132

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 



1686
1687
1688
1689
1690
1691
 
# File 'lib/tk.rb', line 1686

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



1738
1739
1740
1741
1742
1743
1744
1745
 
# File 'lib/tk.rb', line 1738

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



1718
1719
1720
1721
1722
1723
 
# File 'lib/tk.rb', line 1718

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 



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

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

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



1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
 
# File 'lib/tk.rb', line 1787

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 



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

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

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



1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
 
# File 'lib/tk.rb', line 1822

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 



1588
1589
1590
 
# File 'lib/tk.rb', line 1588

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

#callback_continue ⇒ Object 



1592
1593
1594
 
# File 'lib/tk.rb', line 1592

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

#callback_return ⇒ Object 



1596
1597
1598
 
# File 'lib/tk.rb', line 1596

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

#chooseColor(keys = nil) ⇒ Object 



2022
2023
2024
 
# File 'lib/tk.rb', line 2022

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

#chooseDirectory(keys = nil) ⇒ Object 



2026
2027
2028
 
# File 'lib/tk.rb', line 2026

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

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



1948
1949
1950
 
# File 'lib/tk.rb', line 1948

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

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



1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
 
# File 'lib/tk.rb', line 1989

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 



1956
1957
1958
 
# File 'lib/tk.rb', line 1956

def get_eventloop_tick()
  TclTkLib.get_eventloop_tick
end

#get_eventloop_weight ⇒ Object 



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

def get_eventloop_weight()
  TclTkLib.get_eventloop_weight
end

#get_no_event_wait ⇒ Object 



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

def get_no_event_wait()
  TclTkLib.get_no_eventloop_wait
end

#getMultipleOpenFile(keys = nil) ⇒ Object 



2011
2012
2013
 
# File 'lib/tk.rb', line 2011

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

#getMultipleSaveFile(keys = nil) ⇒ Object 



2018
2019
2020
 
# File 'lib/tk.rb', line 2018

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

#getOpenFile(keys = nil) ⇒ Object 



2008
2009
2010
 
# File 'lib/tk.rb', line 2008

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

#getSaveFile(keys = nil) ⇒ Object 



2015
2016
2017
 
# File 'lib/tk.rb', line 2015

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

#inactive ⇒ Object 



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

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

#inactive_displayof(win) ⇒ Object 



1769
1770
1771
 
# File 'lib/tk.rb', line 1769

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

#info(*args) ⇒ Object 



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

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

#ip_eval(cmd_string) ⇒ Object 



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

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

#ip_eval_with_enc(cmd_string) ⇒ Object 



2054
2055
2056
 
# File 'lib/tk.rb', line 2054

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

#ip_eval_without_enc(cmd_string) ⇒ Object 



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

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

#ip_invoke(*args) ⇒ Object 



2074
2075
2076
 
# File 'lib/tk.rb', line 2074

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

#ip_invoke_with_enc(*args) ⇒ Object 



2082
2083
2084
 
# File 'lib/tk.rb', line 2082

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

#ip_invoke_without_enc(*args) ⇒ Object 



2078
2079
2080
 
# File 'lib/tk.rb', line 2078

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

#is_mainloop? ⇒ Boolean

Returns:

  • (Boolean) 


1939
1940
1941
 
# File 'lib/tk.rb', line 1939

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



1682
1683
1684
 
# File 'lib/tk.rb', line 1682

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

#mainloop(check_root = true) ⇒ Object 



1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
 
# File 'lib/tk.rb', line 1863

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 if $SAFE < 4
            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) 


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

def mainloop_exist?
  TclTkLib.mainloop_thread? != nil
end

#mainloop_thread? ⇒ Boolean

Returns:

  • (Boolean) 


1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
 
# File 'lib/tk.rb', line 1922

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 



1943
1944
1945
1946
 
# File 'lib/tk.rb', line 1943

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

#messageBox(keys) ⇒ Object 



2004
2005
2006
 
# File 'lib/tk.rb', line 2004

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

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



1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
 
# File 'lib/tk.rb', line 1804

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 



1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
 
# File 'lib/tk.rb', line 1840

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 



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

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

#reset_inactive_displayof(win) ⇒ Object 



1775
1776
1777
 
# File 'lib/tk.rb', line 1775

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

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



1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
 
# File 'lib/tk.rb', line 1976

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 



1751
1752
1753
1754
1755
1756
1757
 
# File 'lib/tk.rb', line 1751

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 



1758
1759
1760
1761
1762
1763
1764
 
# File 'lib/tk.rb', line 1758

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 



1952
1953
1954
 
# File 'lib/tk.rb', line 1952

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

#set_eventloop_weight(loop_max, no_event_tick) ⇒ Object 



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

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 



1960
1961
1962
 
# File 'lib/tk.rb', line 1960

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

#tk_call(*args) ⇒ Object 



2120
2121
2122
 
# File 'lib/tk.rb', line 2120

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

#tk_call_to_list(*args) ⇒ Object

private :_tk_call_to_list_core



2143
2144
2145
 
# File 'lib/tk.rb', line 2143

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

#tk_call_to_list_with_enc(*args) ⇒ Object 



2151
2152
2153
 
# File 'lib/tk.rb', line 2151

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 



2147
2148
2149
 
# File 'lib/tk.rb', line 2147

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

#tk_call_to_simplelist(*args) ⇒ Object 



2155
2156
2157
 
# File 'lib/tk.rb', line 2155

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

#tk_call_to_simplelist_with_enc(*args) ⇒ Object 



2163
2164
2165
 
# File 'lib/tk.rb', line 2163

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 



2159
2160
2161
 
# File 'lib/tk.rb', line 2159

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

#tk_call_with_enc(*args) ⇒ Object 



2128
2129
2130
 
# File 'lib/tk.rb', line 2128

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

#tk_call_without_enc(*args) ⇒ Object 



2124
2125
2126
 
# File 'lib/tk.rb', line 2124

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

#windowingsystem ⇒ Object 



1747
1748
1749
 
# File 'lib/tk.rb', line 1747

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