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::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::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?
      #Thread.current[:status].value = TclTkLib.mainloop(false)
      Thread.current[:status].value = interp.mainloop(false)
    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 



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
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
 
# File 'lib/tk.rb', line 1588

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 



2120
2121
2122
2123
2124
2125
2126
2127
2128
 
# File 'lib/tk.rb', line 2120

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 



1674
1675
1676
1677
1678
1679
 
# File 'lib/tk.rb', line 1674

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



1726
1727
1728
1729
1730
1731
1732
1733
 
# File 'lib/tk.rb', line 1726

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



1706
1707
1708
1709
1710
1711
 
# File 'lib/tk.rb', line 1706

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 



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

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

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



1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
 
# File 'lib/tk.rb', line 1775

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 



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

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

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



1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
 
# File 'lib/tk.rb', line 1810

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 



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

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

#callback_continue ⇒ Object 



1580
1581
1582
 
# File 'lib/tk.rb', line 1580

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

#callback_return ⇒ Object 



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

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

#chooseColor(keys = nil) ⇒ Object 



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

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

#chooseDirectory(keys = nil) ⇒ Object 



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

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

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



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

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

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



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

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 



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

def get_eventloop_tick()
  TclTkLib.get_eventloop_tick
end

#get_eventloop_weight ⇒ Object 



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

def get_eventloop_weight()
  TclTkLib.get_eventloop_weight
end

#get_no_event_wait ⇒ Object 



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

def get_no_event_wait()
  TclTkLib.get_no_eventloop_wait
end

#getMultipleOpenFile(keys = nil) ⇒ Object 



1999
2000
2001
 
# File 'lib/tk.rb', line 1999

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

#getMultipleSaveFile(keys = nil) ⇒ Object 



2006
2007
2008
 
# File 'lib/tk.rb', line 2006

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

#getOpenFile(keys = nil) ⇒ Object 



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

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

#getSaveFile(keys = nil) ⇒ Object 



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

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

#inactive ⇒ Object 



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

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

#inactive_displayof(win) ⇒ Object 



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

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

#info(*args) ⇒ Object 



1847
1848
1849
 
# File 'lib/tk.rb', line 1847

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

#ip_eval(cmd_string) ⇒ Object 



2034
2035
2036
 
# File 'lib/tk.rb', line 2034

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

#ip_eval_with_enc(cmd_string) ⇒ Object 



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

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

#ip_eval_without_enc(cmd_string) ⇒ Object 



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

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

#ip_invoke(*args) ⇒ Object 



2062
2063
2064
 
# File 'lib/tk.rb', line 2062

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

#ip_invoke_with_enc(*args) ⇒ Object 



2070
2071
2072
 
# File 'lib/tk.rb', line 2070

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

#ip_invoke_without_enc(*args) ⇒ Object 



2066
2067
2068
 
# File 'lib/tk.rb', line 2066

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

#is_mainloop? ⇒ Boolean

Returns:

  • (Boolean) 


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

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



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

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

#mainloop(check_root = true) ⇒ Object 



1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
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
 
# File 'lib/tk.rb', line 1851

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) 


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

def mainloop_exist?
  TclTkLib.mainloop_thread? != nil
end

#mainloop_thread? ⇒ Boolean

Returns:

  • (Boolean) 


1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
 
# File 'lib/tk.rb', line 1910

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 



1931
1932
1933
1934
 
# File 'lib/tk.rb', line 1931

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

#messageBox(keys) ⇒ Object 



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

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

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



1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
 
# File 'lib/tk.rb', line 1792

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 



1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
 
# File 'lib/tk.rb', line 1828

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 



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

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

#reset_inactive_displayof(win) ⇒ Object 



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

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

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



1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
 
# File 'lib/tk.rb', line 1964

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 



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

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 



1746
1747
1748
1749
1750
1751
1752
 
# File 'lib/tk.rb', line 1746

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 



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

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

#set_eventloop_weight(loop_max, no_event_tick) ⇒ Object 



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

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 



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

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

#tk_call(*args) ⇒ Object 



2108
2109
2110
 
# File 'lib/tk.rb', line 2108

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

#tk_call_to_list(*args) ⇒ Object

private :_tk_call_to_list_core



2131
2132
2133
 
# File 'lib/tk.rb', line 2131

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

#tk_call_to_list_with_enc(*args) ⇒ Object 



2139
2140
2141
 
# File 'lib/tk.rb', line 2139

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 



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

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

#tk_call_to_simplelist(*args) ⇒ Object 



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

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

#tk_call_to_simplelist_with_enc(*args) ⇒ Object 



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

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 



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

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

#tk_call_with_enc(*args) ⇒ Object 



2116
2117
2118
 
# File 'lib/tk.rb', line 2116

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

#tk_call_without_enc(*args) ⇒ Object 



2112
2113
2114
 
# File 'lib/tk.rb', line 2112

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

#windowingsystem ⇒ Object 



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

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