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:
ext/lib/multi-tk.rb,
ext/lib/multi-tk.rb,
ext/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

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

  Thread.current[:status] = status
  #sleep

  begin
    Thread.current[:status].value = TclTkLib.mainloop(true)
  rescue Exception=>e
    Thread.current[:status].value = e
  ensure
    INTERP_MUTEX.synchronize{ INTERP_ROOT_CHECK.broadcast }
  end
  Thread.current[:status].value = TclTkLib.mainloop(false)
}
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_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










1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480




# File 'ext/lib/tk.rb', line 1438

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










1951
1952
1953
1954
1955
1956
1957
1958
1959




# File 'ext/lib/tk.rb', line 1951

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










1524
1525
1526
1527
1528
1529




# File 'ext/lib/tk.rb', line 1524

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
















1576
1577
1578
1579
1580
1581
1582
1583




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

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
















1556
1557
1558
1559
1560
1561




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

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










1617
1618
1619




# File 'ext/lib/tk.rb', line 1617

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












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










1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640




# File 'ext/lib/tk.rb', line 1625

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










1621
1622
1623




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

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












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










1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676




# File 'ext/lib/tk.rb', line 1660

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










1426
1427
1428




# File 'ext/lib/tk.rb', line 1426

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












#callback_continue ⇒ Object










1430
1431
1432




# File 'ext/lib/tk.rb', line 1430

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












#callback_return ⇒ Object










1434
1435
1436




# File 'ext/lib/tk.rb', line 1434

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












#chooseColor(keys = nil) ⇒ Object










1841
1842
1843




# File 'ext/lib/tk.rb', line 1841

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












#chooseDirectory(keys = nil) ⇒ Object










1845
1846
1847




# File 'ext/lib/tk.rb', line 1845

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












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










1767
1768
1769




# File 'ext/lib/tk.rb', line 1767

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












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










1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821




# File 'ext/lib/tk.rb', line 1808

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










1775
1776
1777




# File 'ext/lib/tk.rb', line 1775

def get_eventloop_tick()
  TclTkLib.get_eventloop_tick
end












#get_eventloop_weight ⇒ Object










1791
1792
1793




# File 'ext/lib/tk.rb', line 1791

def get_eventloop_weight()
  TclTkLib.get_eventloop_weight
end












#get_no_event_wait ⇒ Object










1783
1784
1785




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

def get_no_event_wait()
  TclTkLib.get_no_eventloop_wait
end












#getMultipleOpenFile(keys = nil) ⇒ Object










1830
1831
1832




# File 'ext/lib/tk.rb', line 1830

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












#getMultipleSaveFile(keys = nil) ⇒ Object










1837
1838
1839




# File 'ext/lib/tk.rb', line 1837

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












#getOpenFile(keys = nil) ⇒ Object










1827
1828
1829




# File 'ext/lib/tk.rb', line 1827

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












#getSaveFile(keys = nil) ⇒ Object










1834
1835
1836




# File 'ext/lib/tk.rb', line 1834

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












#inactive ⇒ Object










1604
1605
1606




# File 'ext/lib/tk.rb', line 1604

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












#inactive_displayof(win) ⇒ Object










1607
1608
1609




# File 'ext/lib/tk.rb', line 1607

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












#info(*args) ⇒ Object










1697
1698
1699




# File 'ext/lib/tk.rb', line 1697

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












#ip_eval(cmd_string) ⇒ Object










1865
1866
1867




# File 'ext/lib/tk.rb', line 1865

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












#ip_eval_with_enc(cmd_string) ⇒ Object










1873
1874
1875




# File 'ext/lib/tk.rb', line 1873

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












#ip_eval_without_enc(cmd_string) ⇒ Object










1869
1870
1871




# File 'ext/lib/tk.rb', line 1869

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












#ip_invoke(*args) ⇒ Object










1893
1894
1895




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

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












#ip_invoke_with_enc(*args) ⇒ Object










1901
1902
1903




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

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












#ip_invoke_without_enc(*args) ⇒ Object










1897
1898
1899




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

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












#is_mainloop? ⇒ Boolean













Returns:


    

  • 
(Boolean)

    • 










1758
1759
1760




# File 'ext/lib/tk.rb', line 1758

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
















1520
1521
1522




# File 'ext/lib/tk.rb', line 1520

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












#mainloop(check_root = true) ⇒ Object










1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739




# File 'ext/lib/tk.rb', line 1701

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
    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

    begin
      TclTkLib.set_eventloop_window_mode(true)
      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
      end
    ensure
      TclTkLib.set_eventloop_window_mode(false)
    end
  end
end












#mainloop_exist? ⇒ Boolean













Returns:


    

  • 
(Boolean)

    • 










1754
1755
1756




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

def mainloop_exist?
  TclTkLib.mainloop_thread? != nil
end












#mainloop_thread? ⇒ Boolean













Returns:


    

  • 
(Boolean)

    • 










1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752




# File 'ext/lib/tk.rb', line 1741

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










1762
1763
1764
1765




# File 'ext/lib/tk.rb', line 1762

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












#messageBox(keys) ⇒ Object










1823
1824
1825




# File 'ext/lib/tk.rb', line 1823

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












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










1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658




# File 'ext/lib/tk.rb', line 1642

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










1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695




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

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










1610
1611
1612




# File 'ext/lib/tk.rb', line 1610

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












#reset_inactive_displayof(win) ⇒ Object










1613
1614
1615




# File 'ext/lib/tk.rb', line 1613

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












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










1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806




# File 'ext/lib/tk.rb', line 1795

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










1589
1590
1591
1592
1593
1594
1595




# File 'ext/lib/tk.rb', line 1589

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










1596
1597
1598
1599
1600
1601
1602




# File 'ext/lib/tk.rb', line 1596

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










1771
1772
1773




# File 'ext/lib/tk.rb', line 1771

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












#set_eventloop_weight(loop_max, no_event_tick) ⇒ Object










1787
1788
1789




# File 'ext/lib/tk.rb', line 1787

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










1779
1780
1781




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

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












#tk_call(*args) ⇒ Object










1939
1940
1941




# File 'ext/lib/tk.rb', line 1939

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












#tk_call_to_list(*args) ⇒ Object







private :_tk_call_to_list_core















1962
1963
1964




# File 'ext/lib/tk.rb', line 1962

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












#tk_call_to_list_with_enc(*args) ⇒ Object










1970
1971
1972




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

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










1966
1967
1968




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

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












#tk_call_to_simplelist(*args) ⇒ Object










1974
1975
1976




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

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












#tk_call_to_simplelist_with_enc(*args) ⇒ Object










1982
1983
1984




# File 'ext/lib/tk.rb', line 1982

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










1978
1979
1980




# File 'ext/lib/tk.rb', line 1978

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












#tk_call_with_enc(*args) ⇒ Object










1947
1948
1949




# File 'ext/lib/tk.rb', line 1947

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












#tk_call_without_enc(*args) ⇒ Object










1943
1944
1945




# File 'ext/lib/tk.rb', line 1943

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












#windowingsystem ⇒ Object










1585
1586
1587




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

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