# module TkCore

start Tk which depends on MultiTkIp

### Constants

EventFlag
INTERP

  #<RDoc::Comment:0x00000006021152d0>

  #<RDoc::Comment:0x0000000602b8d4b0>

  #<RDoc::Comment:0x0000000602bf2ef0>

  #<RDoc::Comment:0x0000000602c32168>

  #<RDoc::Comment:0x0000000602c66d00>

  #<RDoc::Comment:0x0000000602cb5518>

  #<RDoc::Comment:0x0000000601c80990>

  #<RDoc::Comment:0x00000006017a32d8>

  #<RDoc::Comment:0x000000060199ac80>

  #<RDoc::Comment:0x00000006014e83e0>

  #<RDoc::Comment:0x00000006020106f0>

  #<RDoc::Comment:0x0000000602890de8>

  #<RDoc::Comment:0x00000006024edad8>

  #<RDoc::Comment:0x0000000602443a60>

  #<RDoc::Comment:0x0000000602445e50>

  #<RDoc::Comment:0x000000060244b418>

INTERP_MUTEX
INTERP_ROOT_CHECK
INTERP_THREAD
INTERP_THREAD_STATUS
RUN_EVENTLOOP_ON_MAIN_THREAD

  *** KNOWN BUG ***

      Main event loop thread of TkAqua (> Tk8.4.9) must be the main
      application thread. So, ruby1.9 users must call Tk.mainloop on
      the main application thread.

  *** ADD (2009/05/10) ***

      In some cases (I don't know the description of conditions),
      TkAqua 8.4.7 has a same kind of hang-up trouble.
      So, if 8.4.7 or later, set RUN_EVENTLOOP_ON_MAIN_THREAD to true.
      When you want to control this mode, please call the following
      (set true/false as you want) before "require 'tk'".
      ----------------------------------------------------------
      module TkCore; RUN_EVENTLOOP_ON_MAIN_THREAD = true; end
      ----------------------------------------------------------

  *** ADD (2010/07/05) ***

      The value of TclTkLib::WINDOWING_SYSTEM is defined at compiling.
      If it is inconsistent with linked DLL, please call the following
      before "require 'tk'".
      ----------------------------------------------------------
      require 'tcltklib'
      module TclTkLib
        remove_const :WINDOWING_SYSTEM
        WINDOWING_SYSTEM = 'x11' # or 'aqua'
      end
      ----------------------------------------------------------

WIDGET_DESTROY_HOOK
WITH_ENCODING
WITH_RUBY_VM

### Public Class Methods

callback(*arg) click to toggle source

    # File lib/tk.rb, line 1599
    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

inspect() click to toggle source

    # File lib/tk.rb, line 1389
    def inspect
      sprintf("#<Class(TkCallbackEntry):%0x>", self.__id__)
    end

Also aliased as: to_s
new(ip, cmd) click to toggle source

    # File lib/tk.rb, line 1395
    def initialize(ip, cmd)
      @ip = ip
      @cmd = cmd
    end

to_s()
Alias for: inspect

### Public Instance Methods

_tk_call_to_list_core(depth, arg_enc, val_enc, *args) click to toggle source

    # File lib/tk.rb, line 2123
    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) click to toggle source

    # File lib/tk.rb, line 1685
    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) click to toggle source

# begin¶ ↑

    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

# end¶ ↑

    # File lib/tk.rb, line 1737
    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) click to toggle source

# begin¶ ↑

    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

# end¶ ↑

    # File lib/tk.rb, line 1717
    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) click to toggle source

    # File lib/tk.rb, line 1778
    def appname(name=None)
      tk_call('tk', 'appname', name)
    end

appsend(interp, async, *args) click to toggle source

    # File lib/tk.rb, line 1786
    def appsend(interp, async, *args)
      if $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() click to toggle source

    # File lib/tk.rb, line 1782
    def appsend_deny
      tk_call('rename', 'send', '')
    end

appsend_displayof(interp, win, async, *args) click to toggle source

    # File lib/tk.rb, line 1817
    def appsend_displayof(interp, win, async, *args)
      if $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

call(*args) click to toggle source

    # File lib/tk.rb, line 1400
    def call(*args)
      @ip.cb_eval(@cmd, *args)
    end

callback_break() click to toggle source

    # File lib/tk.rb, line 1587
    def callback_break
      fail TkCallbackBreak, "Tk callback returns 'break' status"
    end

callback_continue() click to toggle source

    # File lib/tk.rb, line 1591
    def callback_continue
      fail TkCallbackContinue, "Tk callback returns 'continue' status"
    end

callback_return() click to toggle source

    # File lib/tk.rb, line 1595
    def callback_return
      fail TkCallbackReturn, "Tk callback returns 'return' status"
    end

chooseColor(keys = nil) click to toggle source

    # File lib/tk.rb, line 2013
    def chooseColor(keys = nil)
      tk_call('tk_chooseColor', *hash_kv(keys))
    end

chooseDirectory(keys = nil) click to toggle source

    # File lib/tk.rb, line 2017
    def chooseDirectory(keys = nil)
      tk_call('tk_chooseDirectory', *hash_kv(keys))
    end

do_one_event(flag = TclTkLib::EventFlag::ALL) click to toggle source

    # File lib/tk.rb, line 1939
    def do_one_event(flag = TclTkLib::EventFlag::ALL)
      TclTkLib.do_one_event(flag)
    end

event_generate(win, context, keys=nil) click to toggle source

    # File lib/tk.rb, line 1980
    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

getMultipleOpenFile(keys = nil) click to toggle source

    # File lib/tk.rb, line 2002
    def getMultipleOpenFile(keys = nil)
      simplelist(tk_call('tk_getOpenFile', '-multiple', '1', *hash_kv(keys)))
    end

getMultipleSaveFile(keys = nil) click to toggle source

    # File lib/tk.rb, line 2009
    def getMultipleSaveFile(keys = nil)
      simplelist(tk_call('tk_getSaveFile', '-multiple', '1', *hash_kv(keys)))
    end

getOpenFile(keys = nil) click to toggle source

    # File lib/tk.rb, line 1999
    def getOpenFile(keys = nil)
      tk_call('tk_getOpenFile', *hash_kv(keys))
    end

getSaveFile(keys = nil) click to toggle source

    # File lib/tk.rb, line 2006
    def getSaveFile(keys = nil)
      tk_call('tk_getSaveFile', *hash_kv(keys))
    end

get_eventloop_tick() click to toggle source

    # File lib/tk.rb, line 1947
    def get_eventloop_tick()
      TclTkLib.get_eventloop_tick
    end

get_eventloop_weight() click to toggle source

    # File lib/tk.rb, line 1963
    def get_eventloop_weight()
      TclTkLib.get_eventloop_weight
    end

get_no_event_wait() click to toggle source

    # File lib/tk.rb, line 1955
    def get_no_event_wait()
      TclTkLib.get_no_eventloop_wait
    end

inactive() click to toggle source

    # File lib/tk.rb, line 1765
    def inactive
      Integer(tk_call_without_enc('tk', 'inactive'))
    end

inactive_displayof(win) click to toggle source

    # File lib/tk.rb, line 1768
    def inactive_displayof(win)
      Integer(tk_call_without_enc('tk', 'inactive', '-displayof', win))
    end

inspect() click to toggle source

    # File lib/tk.rb, line 1403
    def inspect
      sprintf("#<cb_entry:%0x>", self.__id__)
    end

Also aliased as: to_s
ip_eval(cmd_string) click to toggle source

    # File lib/tk.rb, line 2037
    def ip_eval(cmd_string)
      _ip_eval_core(nil, cmd_string)
    end

ip_eval_with_enc(cmd_string) click to toggle source

    # File lib/tk.rb, line 2045
    def ip_eval_with_enc(cmd_string)
      _ip_eval_core(true, cmd_string)
    end

ip_eval_without_enc(cmd_string) click to toggle source

    # File lib/tk.rb, line 2041
    def ip_eval_without_enc(cmd_string)
      _ip_eval_core(false, cmd_string)
    end

ip_invoke(*args) click to toggle source

    # File lib/tk.rb, line 2065
    def ip_invoke(*args)
      _ip_invoke_core(nil, *args)
    end

ip_invoke_with_enc(*args) click to toggle source

    # File lib/tk.rb, line 2073
    def ip_invoke_with_enc(*args)
      _ip_invoke_core(true, *args)
    end

ip_invoke_without_enc(*args) click to toggle source

    # File lib/tk.rb, line 2069
    def ip_invoke_without_enc(*args)
      _ip_invoke_core(false, *args)
    end

is_mainloop?() click to toggle source

    # File lib/tk.rb, line 1930
    def is_mainloop?
      TclTkLib.mainloop_thread? == true
    end

load_cmd_on_ip(tk_cmd) click to toggle source

# begin¶ ↑

    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 = MultiTkIp.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#{trace}: #{$!.message} (#{$!.class})n” + # “tfrom #{trace.join(”ntfrom “)}” # end # end #=end

    end

# end¶ ↑

    # File lib/tk.rb, line 1681
    def load_cmd_on_ip(tk_cmd)
      bool(tk_call('auto_load', tk_cmd))
    end

mainloop(check_root = true) click to toggle source

    # File lib/tk.rb, line 1854
    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?() click to toggle source

    # File lib/tk.rb, line 1926
    def mainloop_exist?
      TclTkLib.mainloop_thread? != nil
    end

mainloop_thread?() click to toggle source

    # File lib/tk.rb, line 1913
    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) click to toggle source

    # File lib/tk.rb, line 1934
    def mainloop_watchdog(check_root = true)
      # watchdog restarts mainloop when mainloop is dead
      TclTkLib.mainloop_watchdog(check_root)
    end

messageBox(keys) click to toggle source

    # File lib/tk.rb, line 1995
    def messageBox(keys)
      tk_call('tk_messageBox', *hash_kv(keys))
    end

rb_appsend(interp, async, *args) click to toggle source

    # File lib/tk.rb, line 1801
    def rb_appsend(interp, async, *args)
      if $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) click to toggle source

    # File lib/tk.rb, line 1833
    def rb_appsend_displayof(interp, win, async, *args)
      if $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() click to toggle source

    # File lib/tk.rb, line 1771
    def reset_inactive
      tk_call_without_enc('tk', 'inactive', 'reset')
    end

reset_inactive_displayof(win) click to toggle source

    # File lib/tk.rb, line 1774
    def reset_inactive_displayof(win)
      tk_call_without_enc('tk', 'inactive', '-displayof', win, 'reset')
    end

restart(app_name = nil, keys = {}) click to toggle source

    # File lib/tk.rb, line 1967
    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) click to toggle source

    # File lib/tk.rb, line 1750
    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) click to toggle source

    # File lib/tk.rb, line 1757
    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) click to toggle source

    # File lib/tk.rb, line 1943
    def set_eventloop_tick(timer_tick)
      TclTkLib.set_eventloop_tick(timer_tick)
    end

set_eventloop_weight(loop_max, no_event_tick) click to toggle source

    # File lib/tk.rb, line 1959
    def set_eventloop_weight(loop_max, no_event_tick)
      TclTkLib.set_eventloop_weight(loop_max, no_event_tick)
    end

set_no_event_wait(wait) click to toggle source

    # File lib/tk.rb, line 1951
    def set_no_event_wait(wait)
      TclTkLib.set_no_even_wait(wait)
    end

tk_call(*args) click to toggle source

    # File lib/tk.rb, line 2111
    def tk_call(*args)
      _tk_call_core(nil, *args)
    end

tk_call_to_list(*args) click to toggle source

private :_tk_call_to_list_core

    # File lib/tk.rb, line 2134
    def tk_call_to_list(*args)
      _tk_call_to_list_core(-1, nil, true, *args)
    end

tk_call_to_list_with_enc(*args) click to toggle source

    # File lib/tk.rb, line 2142
    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) click to toggle source

    # File lib/tk.rb, line 2138
    def tk_call_to_list_without_enc(*args)
      _tk_call_to_list_core(-1, false, false, *args)
    end

tk_call_to_simplelist(*args) click to toggle source

    # File lib/tk.rb, line 2146
    def tk_call_to_simplelist(*args)
      _tk_call_to_list_core(0, nil, true, *args)
    end

tk_call_to_simplelist_with_enc(*args) click to toggle source

    # File lib/tk.rb, line 2154
    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) click to toggle source

    # File lib/tk.rb, line 2150
    def tk_call_to_simplelist_without_enc(*args)
      _tk_call_to_list_core(0, false, false, *args)
    end

tk_call_with_enc(*args) click to toggle source

    # File lib/tk.rb, line 2119
    def tk_call_with_enc(*args)
      _tk_call_core(true, *args)
    end

tk_call_without_enc(*args) click to toggle source

    # File lib/tk.rb, line 2115
    def tk_call_without_enc(*args)
      _tk_call_core(false, *args)
    end

to_s()
Alias for: inspect
windowingsystem() click to toggle source

    # File lib/tk.rb, line 1746
    def windowingsystem
      tk_call_without_enc('tk', 'windowingsystem')
    end

### Private Instance Methods

_ip_eval_core(enc_mode, cmd_string) click to toggle source

    # File lib/tk.rb, line 2021
    def _ip_eval_core(enc_mode, cmd_string)
      case enc_mode
      when nil
        res = INTERP._eval(cmd_string)
      when false
        res = INTERP._eval_without_enc(cmd_string)
      when true
        res = INTERP._eval_with_enc(cmd_string)
      end
      if  INTERP._return_value() != 0
        fail RuntimeError, res, error_at
      end
      return res
    end

_ip_invoke_core(enc_mode, *args) click to toggle source

    # File lib/tk.rb, line 2049
    def _ip_invoke_core(enc_mode, *args)
      case enc_mode
      when false
        res = INTERP._invoke_without_enc(*args)
      when nil
        res = INTERP._invoke(*args)
      when true
        res = INTERP._invoke_with_enc(*args)
      end
      if  INTERP._return_value() != 0
        fail RuntimeError, res, error_at
      end
      return res
    end

_tk_call_core(enc_mode, *args) click to toggle source

    # File lib/tk.rb, line 2077
    def _tk_call_core(enc_mode, *args)
      ### puts args.inspect if $DEBUG
      #args.collect! {|x|ruby2tcl(x, enc_mode)}
      #args.compact!
      #args.flatten!
      args = _conv_args([], enc_mode, *args)
      puts 'invoke args => ' + args.inspect if $DEBUG
      ### print "=> ", args.join(" ").inspect, "\n" if $DEBUG
      begin
        # res = TkUtil.untrust(INTERP._invoke(*args))
        # res = INTERP._invoke(enc_mode, *args)
        res = _ip_invoke_core(enc_mode, *args)
        # >>>>>  _invoke returns a TAINTED string  <<<<<
      rescue NameError => err
        # err = $!
        begin
          args.unshift "unknown"
          #res = TkUtil.untrust(INTERP._invoke(*args))
          #res = INTERP._invoke(enc_mode, *args)
          res = _ip_invoke_core(enc_mode, *args)
          # >>>>>  _invoke returns a TAINTED string  <<<<<
        rescue StandardError => err2
          fail err2 unless /^invalid command/ =~ err2.message
          fail err
        end
      end
      if  INTERP._return_value() != 0
        fail RuntimeError, res, error_at
      end
      ### print "==> ", res.inspect, "\n" if $DEBUG
      return res
    end

info(*args) click to toggle source

    # File lib/tk.rb, line 1850
    def info(*args)
      tk_call('info', *args)
    end