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/thread_tk.rb,
lib/tk.rb

Overview

start Tk which depends on MultiTkIp

Defined Under Namespace

Classes: Tk_OBJECT_TABLE

Constant Summary

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 =

RUN_EVENTLOOP_ON_MAIN_THREAD =

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

false

WITH_RUBY_VM =

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

WITH_ENCODING =

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

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

• .callback(*arg) ⇒ Object

Instance Method Summary

• #_tk_call_to_list_core(depth, arg_enc, val_enc, *args) ⇒ Object
• #after(ms, cmd = nil, &block) ⇒ Object
• #after_cancel(afterId) ⇒ Object
• #after_idle(cmd = nil, &block) ⇒ Object
• #appname(name = None) ⇒ Object
• #appsend(interp, async, *args) ⇒ Object
• #appsend_deny ⇒ Object
• #appsend_displayof(interp, win, async, *args) ⇒ Object
• #callback_break ⇒ Object
• #callback_continue ⇒ Object
• #callback_return ⇒ Object
• #chooseColor(keys = nil) ⇒ Object
• #chooseDirectory(keys = nil) ⇒ Object
• #do_one_event(flag = TclTkLib::EventFlag::ALL) ⇒ Object
• #event_generate(win, context, keys = nil) ⇒ Object
• #get_eventloop_tick ⇒ Object
• #get_eventloop_weight ⇒ Object
• #get_no_event_wait ⇒ Object
• #getMultipleOpenFile(keys = nil) ⇒ Object
• #getOpenFile(keys = nil) ⇒ Object
• #getSaveFile(keys = nil) ⇒ Object
• #inactive ⇒ Object
• #inactive_displayof(win) ⇒ Object
• #info(*args) ⇒ Object
• #ip_eval(cmd_string) ⇒ Object
• #ip_eval_with_enc(cmd_string) ⇒ Object
• #ip_eval_without_enc(cmd_string) ⇒ Object
• #ip_invoke(*args) ⇒ Object
• #ip_invoke_with_enc(*args) ⇒ Object
• #ip_invoke_without_enc(*args) ⇒ Object
• #is_mainloop? ⇒ Boolean
• #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)) #_get_eval_string(TkUtil.eval_cmd(TkCore::INTERP.tk_cmd_tbl, # *arg)) # TkCore::INTERP.tk_cmd_tbl.call(*arg) begin TkCore::INTERP.tk_cmd_tbl.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: #$!$!.message (#$!$!.class)n” + # “tfrom #.join(”ntfrom “)” # end # end #=end end.

• #mainloop(check_root = true) ⇒ Object
• #mainloop_exist? ⇒ Boolean
• #mainloop_thread? ⇒ Boolean
• #mainloop_watchdog(check_root = true) ⇒ Object
• #messageBox(keys) ⇒ Object
• #rb_appsend(interp, async, *args) ⇒ Object
• #rb_appsend_displayof(interp, win, async, *args) ⇒ Object
• #reset_inactive ⇒ Object
• #reset_inactive_displayof(win) ⇒ Object
• #restart(app_name = nil, keys = {}) ⇒ Object
• #scaling(scale = nil) ⇒ Object
• #scaling_displayof(win, scale = nil) ⇒ Object
• #set_eventloop_tick(timer_tick) ⇒ Object
• #set_eventloop_weight(loop_max, no_event_tick) ⇒ Object
• #set_no_event_wait(wait) ⇒ Object
• #tk_call(*args) ⇒ Object
• #tk_call_to_list(*args) ⇒ Object

  private :_tk_call_to_list_core.

• #tk_call_to_list_with_enc(*args) ⇒ Object
• #tk_call_to_list_without_enc(*args) ⇒ Object
• #tk_call_to_simplelist(*args) ⇒ Object
• #tk_call_to_simplelist_with_enc(*args) ⇒ Object
• #tk_call_to_simplelist_without_enc(*args) ⇒ Object
• #tk_call_with_enc(*args) ⇒ Object
• #tk_call_without_enc(*args) ⇒ Object
• #windowingsystem ⇒ Object

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#callback_continue ⇒ Object

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

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

#callback_return ⇒ Object

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

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

#chooseColor(keys = nil) ⇒ Object

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

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

#chooseDirectory(keys = nil) ⇒ Object

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

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

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

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

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

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

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

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

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

def get_eventloop_tick()
  TclTkLib.get_eventloop_tick
end

#get_eventloop_weight ⇒ Object

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

def get_eventloop_weight()
  TclTkLib.get_eventloop_weight
end

#get_no_event_wait ⇒ Object

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

def get_no_event_wait()
  TclTkLib.get_no_eventloop_wait
end

#getMultipleOpenFile(keys = nil) ⇒ Object

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

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

#getOpenFile(keys = nil) ⇒ Object

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

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

#getSaveFile(keys = nil) ⇒ Object

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

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

#inactive ⇒ Object

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

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

#inactive_displayof(win) ⇒ Object

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

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

#info(*args) ⇒ Object

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

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

#ip_eval(cmd_string) ⇒ Object

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

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

#ip_eval_with_enc(cmd_string) ⇒ Object

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

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

#ip_eval_without_enc(cmd_string) ⇒ Object

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

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

#ip_invoke(*args) ⇒ Object

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

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

#ip_invoke_with_enc(*args) ⇒ Object

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

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

#ip_invoke_without_enc(*args) ⇒ Object

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

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

#is_mainloop? ⇒ Boolean

Returns:

• (Boolean)

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

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

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

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

#mainloop(check_root = true) ⇒ Object

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

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)

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

def mainloop_exist?
  TclTkLib.mainloop_thread? != nil
end

#mainloop_thread? ⇒ Boolean

Returns:

• (Boolean)

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

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

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

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

#messageBox(keys) ⇒ Object

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

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

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

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

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

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

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

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

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

#reset_inactive_displayof(win) ⇒ Object

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

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

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

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

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

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

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

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

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

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

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

#set_eventloop_weight(loop_max, no_event_tick) ⇒ Object

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

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

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

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

#tk_call(*args) ⇒ Object

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

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

#tk_call_to_list(*args) ⇒ Object

private :_tk_call_to_list_core

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

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

#tk_call_to_list_with_enc(*args) ⇒ Object

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

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

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

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

#tk_call_to_simplelist(*args) ⇒ Object

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

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

#tk_call_to_simplelist_with_enc(*args) ⇒ Object

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

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

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

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

#tk_call_with_enc(*args) ⇒ Object

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

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

#tk_call_without_enc(*args) ⇒ Object

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

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

#windowingsystem ⇒ Object

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

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