tk 0.2.0 → 0.3.0

data/lib/tk/canvastag.rb

@@ -22,31 +22,23 @@ module TkcTagAccess
     @c.bbox(@id)
   end
 
-  #def bind(seq, cmd=Proc.new, *args)
-  #  @c.itembind(@id, seq, cmd, *args)
-  #  self
-  #end
-  def bind(seq, *args)
+  def bind(seq, *args, &block)
     # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
-    if TkComm._callback_entry?(args[0]) || !block_given?
+    if TkComm._callback_entry?(args[0]) || !block
       cmd = args.shift
     else
-      cmd = Proc.new
+      cmd = block
     end
     @c.itembind(@id, seq, cmd, *args)
     self
   end
 
-  #def bind_append(seq, cmd=Proc.new, *args)
-  #  @c.itembind_append(@id, seq, cmd, *args)
-  #  self
-  #end
-  def bind_append(seq, *args)
+  def bind_append(seq, *args, &block)
     # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
-    if TkComm._callback_entry?(args[0]) || !block_given?
+    if TkComm._callback_entry?(args[0]) || !block
       cmd = args.shift
     else
-      cmd = Proc.new
+      cmd = block
     end
     @c.itembind_append(@id, seq, cmd, *args)
     self
@@ -229,7 +221,7 @@ class TkcTag<TkObject
 
   CTagID_TBL = TkCore::INTERP.create_table
 
-  (Tk_CanvasTag_ID = ['ctag'.freeze, TkUtil.untrust('00000')]).instance_eval{
+  (Tk_CanvasTag_ID = ['ctag'.freeze, '00000']).instance_eval{
     @mutex = Mutex.new
     def mutex; @mutex; end
     freeze
@@ -415,7 +407,7 @@ class TkcTagCurrent<TkcTagString
 end
 
 class TkcGroup<TkcTag
-  (Tk_cGroup_ID = ['tkcg'.freeze, TkUtil.untrust('00000')]).instance_eval{
+  (Tk_cGroup_ID = ['tkcg'.freeze, '00000']).instance_eval{
     @mutex = Mutex.new
     def mutex; @mutex; end
     freeze

data/lib/tk/font.rb

@@ -12,7 +12,7 @@ class TkFont
 
   TkCommandNames = ['font'.freeze].freeze
 
-  (Tk_FontID = ["@font".freeze, TkUtil.untrust("00000")]).instance_eval{
+  (Tk_FontID = ["@font".freeze, "00000"]).instance_eval{
     @mutex = Mutex.new
     def mutex; @mutex; end
     freeze

data/lib/tk/fontchooser.rb

@@ -109,7 +109,7 @@ class << TkFont::Chooser
     if cmd
       configure_cmd('command', cmd)
     elsif b
-      configure_cmd('command', Proc.new(&b))
+      configure_cmd('command', b)
     else
       cget('command')
     end

data/lib/tk/image.rb

@@ -12,7 +12,7 @@ class TkImage<TkObject
 
   Tk_IMGTBL = TkCore::INTERP.create_table
 
-  (Tk_Image_ID = ['i'.freeze, TkUtil.untrust('00000')]).instance_eval{
+  (Tk_Image_ID = ['i'.freeze, '00000']).instance_eval{
     @mutex = Mutex.new
     def mutex; @mutex; end
     freeze

data/lib/tk/menu.rb

@@ -186,16 +186,16 @@ class Tk::Menu<TkWindow
     tk_send_without_enc('postcascade', _get_eval_enc_str(index))
     self
   end
-  def postcommand(cmd=Proc.new)
-    configure_cmd 'postcommand', cmd
+  def postcommand(cmd=nil, &block)
+    configure_cmd('postcommand', cmd || block)
     self
   end
   def set_focus
     tk_call_without_enc('tk_menuSetFocus', path)
     self
   end
-  def tearoffcommand(cmd=Proc.new)
-    configure_cmd 'tearoffcommand', cmd
+  def tearoffcommand(cmd=nil, &block)
+    configure_cmd('tearoffcommand', cmd || block)
     self
   end
   def menutype(index)

data/lib/tk/msgcat.rb

@@ -37,7 +37,7 @@ class TkMsgCatalog < TkObject
 
   MSGCAT_EXT = '.msg'
 
-  UNKNOWN_CBTBL = TkUtil.untrust(Hash.new{|hash,key| hash[key] = {}})
+  UNKNOWN_CBTBL = Hash.new{|hash,key| hash[key] = {}}
 
   TkCore::INTERP.add_tk_procs('::msgcat::mcunknown', 'args', <<-'EOL')
     if {[set st [catch {eval {ruby_cmd TkMsgCatalog callback} [namespace current] $args} ret]] != 0} {
@@ -289,11 +289,11 @@ class TkMsgCatalog < TkObject
            })
   end
 
-  def self.def_unknown_proc(cmd=Proc.new)
-    TkMsgCatalog::UNKNOWN_CBTBL[TkCore::INTERP.__getip]['::'] = cmd
+  def self.def_unknown_proc(cmd=nil, &block)
+    TkMsgCatalog::UNKNOWN_CBTBL[TkCore::INTERP.__getip]['::'] = cmd || block
   end
-  def def_unknown_proc(cmd=Proc.new)
-    TkMsgCatalog::UNKNOWN_CBTBL[TkCore::INTERP.__getip][@namespace.path] = cmd
+  def def_unknown_proc(cmd=nil, &block)
+    TkMsgCatalog::UNKNOWN_CBTBL[TkCore::INTERP.__getip][@namespace.path] = cmd || block
   end
 end
 

data/lib/tk/namespace.rb

@@ -14,7 +14,7 @@ class TkNamespace < TkObject
 
   Tk_Namespace_ID_TBL = TkCore::INTERP.create_table
 
-  (Tk_Namespace_ID = ["ns".freeze, TkUtil.untrust("00000")]).instance_eval{
+  (Tk_Namespace_ID = ["ns".freeze, "00000"]).instance_eval{
     @mutex = Mutex.new
     def mutex; @mutex; end
     freeze
@@ -307,23 +307,12 @@ class TkNamespace < TkObject
     TkNamespace.children(@fullname, pattern)
   end
 
-  def self.code(script = Proc.new)
-    TkNamespace.new('').code(script)
+  def self.code(script = nil, &block)
+    TkNamespace.new('').code(script || block)
   end
-=begin
-  def code(script = Proc.new)
-    if script.kind_of?(String)
-      cmd = proc{|*args| ScopeArgs.new(@fullname,*args).instance_eval(script)}
-    elsif script.kind_of?(Proc)
-      cmd = proc{|*args| ScopeArgs.new(@fullname,*args).instance_eval(&script)}
-    else
-      fail ArgumentError, "String or Proc is expected"
-    end
-    TkNamespace::NsCode.new(tk_call_without_enc('namespace', 'code',
-                                                _get_eval_string(cmd, false)))
-  end
-=end
-  def code(script = Proc.new)
+
+  def code(script = nil, &block)
+    script ||= block
     if script.kind_of?(String)
       cmd = proc{|*args|
         ret = ScopeArgs.new(@fullname,*args).instance_eval(script)
@@ -414,22 +403,13 @@ class TkNamespace < TkObject
     bool(tk_call('namespace', 'ensemble', 'exists', cmd))
   end
 
-  def self.eval(namespace, cmd = Proc.new, *args)
+  def self.eval(namespace, cmd = nil, *args, &block)
+    cmd ||= block
     #tk_call('namespace', 'eval', namespace, cmd, *args)
     TkNamespace.new(namespace).eval(cmd, *args)
   end
-=begin
-  def eval(cmd = Proc.new, *args)
-    #TkNamespace.eval(@fullname, cmd, *args)
-    #ns_tk_call(cmd, *args)
-    code_obj = code(cmd)
-    ret = code_obj.call(*args)
-    # uninstall_cmd(TkCore::INTERP._split_tklist(code_obj.path)[-1])
-    uninstall_cmd(_fromUTF8(TkCore::INTERP._split_tklist(_toUTF8(code_obj.path))[-1]))
-    tk_tcl2ruby(ret)
-  end
-=end
-  def eval(cmd = Proc.new, *args)
+  def eval(cmd = nil, *args, &block)
+    cmd ||= block
     code_obj = code(cmd)
     ret = code_obj.call(*args)
     uninstall_cmd(_fromUTF8(TkCore::INTERP._split_tklist(_toUTF8(code_obj.path))[-1]))
@@ -529,8 +509,8 @@ class TkNamespace < TkObject
   def self.get_unknown_handler
     tk_tcl2ruby(tk_call('namespace', 'unknown'))
   end
-  def self.set_unknown_handler(cmd = Proc.new)
-    tk_call('namespace', 'unknown', cmd)
+  def self.set_unknown_handler(cmd = nil, &block)
+    tk_call('namespace', 'unknown', cmd || block)
   end
 
   def self.which(name)

data/lib/tk/optiondb.rb

@@ -9,7 +9,7 @@ module TkOptionDB
   extend Tk
 
   TkCommandNames = ['option'.freeze].freeze
-  (CmdClassID = ['CMD_CLASS'.freeze, TkUtil.untrust('00000')]).instance_eval{
+  (CmdClassID = ['CMD_CLASS'.freeze, '00000']).instance_eval{
     @mutex = Mutex.new
     def mutex; @mutex; end
     freeze
@@ -139,31 +139,6 @@ module TkOptionDB
   class << @@resource_proc_class
     private :new
 
-=begin
-    CARRIER    = '.'.freeze
-    METHOD_TBL = TkCore::INTERP.create_table
-    ADD_METHOD = false
-    SAFE_MODE  = 4
-=end
-
-=begin
-    def __closed_block_check__(str)
-      depth = 0
-      str.scan(/[{}]/){|x|
-        if x == "{"
-          depth += 1
-        elsif x == "}"
-          depth -= 1
-        end
-        if depth <= 0 && !($' =~ /\A\s*\Z/)
-          fail RuntimeError, "bad string for procedure : #{str.inspect}"
-        end
-      }
-      str
-    end
-    private :__closed_block_check__
-=end
-
     def __check_proc_string__(str)
       # If you want to check the proc_string, do it in this method.
       # Please define this in the block given to 'new_proc_class' method.
@@ -185,13 +160,12 @@ module TkOptionDB
                 "not support resource-proc '#{id.id2name}' for #{self.name}"
         end
         proc_str = proc_source
-        proc_str = '{' + proc_str + '}' unless /\A\{.*\}\Z/ =~ proc_str
+        proc_str = '{' + proc_str + '}' unless /\A\{.*\}\Z/m =~ proc_str
         #proc_str = __closed_block_check__(proc_str)
         proc_str = __check_proc_string__(proc_str)
         res_proc = proc{
           begin
-            #eval("$SAFE = #{self::SAFE_MODE};\nProc.new" + proc_str)
-            eval("$SAFE = #{@safe_mode};\nProc.new" + proc_str)
+            eval("Proc.new" + proc_str)
           rescue SyntaxError=>err
             raise SyntaxError,
               TkCore::INTERP._toUTF8(err.message.gsub(/\(eval\):\d:/,
@@ -208,44 +182,6 @@ module TkOptionDB
   end
   @@resource_proc_class.freeze
 
-=begin
-  def __create_new_class(klass, func, safe = 4, add = false, parent = nil)
-    klass = klass.to_s if klass.kind_of? Symbol
-    unless (?A..?Z) === klass[0]
-      fail ArgumentError, "bad string '#{klass}' for class name"
-    end
-    unless func.kind_of? Array
-      fail ArgumentError, "method-list must be Array"
-    end
-    func_str = func.join(' ')
-    if parent == nil
-      install_win(parent)
-    elsif parent <= @@resource_proc_class
-      install_win(parent::CARRIER)
-    else
-      fail ArgumentError, "parent must be Resource-Proc class"
-    end
-    carrier = Tk.tk_call_without_enc('frame', @path, '-class', klass)
-
-    body = <<-"EOD"
-      class #{klass} < TkOptionDB.module_eval('@@resource_proc_class')
-        CARRIER    = '#{carrier}'.freeze
-        METHOD_TBL = TkCore::INTERP.create_table
-        ADD_METHOD = #{add}
-        SAFE_MODE  = #{safe}
-        %w(#{func_str}).each{|f| METHOD_TBL[f.intern] = nil }
-      end
-    EOD
-
-    if parent.kind_of?(Class) && parent <= @@resource_proc_class
-      parent.class_eval(body)
-      eval(parent.name + '::' + klass)
-    else
-      eval(body)
-      eval('TkOptionDB::' + klass)
-    end
-  end
-=end
   def __create_new_class(klass, func, safe = 4, add = false, parent = nil)
     if klass.kind_of?(TkWindow)
       carrier = klass.path
@@ -289,12 +225,6 @@ module TkOptionDB
     func.each{|f|
       cmd_klass.instance_variable_get('@method_tbl')[f.to_s.intern] = nil
     }
-=begin
-    cmd_klass.const_set(:METHOD_TBL, TkCore::INTERP.create_table)
-    cmd_klass.const_set(:ADD_METHOD, add)
-    cmd_klass.const_set(:SAFE_MODE, safe)
-    func.each{|f| cmd_klass::METHOD_TBL[f.to_s.intern] = nil }
-=end
 
     cmd_klass
   end

data/lib/tk/scale.rb

@@ -78,8 +78,8 @@ class Tk::Scale<TkWindow
     super(slot, value)
   end
 
-  def command(cmd=Proc.new)
-    configure('command'=>cmd)
+  def command(cmd=nil, &block)
+    configure('command'=>cmd || block)
   end
 
   def get(x=None, y=None)

data/lib/tk/scrollable.rb

@@ -6,7 +6,8 @@ require 'tk'
 
 module Tk
   module XScrollable
-    def xscrollcommand(cmd=Proc.new)
+    def xscrollcommand(cmd=nil, &block)
+      cmd ||= block
       configure_cmd 'xscrollcommand', cmd
       # Tk.update  # avoid scrollbar trouble
       self
@@ -40,7 +41,8 @@ module Tk
   end
 
   module YScrollable
-    def yscrollcommand(cmd=Proc.new)
+    def yscrollcommand(cmd = (use_block = true), &block)
+      cmd = block if use_block
       configure_cmd 'yscrollcommand', cmd
       # Tk.update  # avoid scrollbar trouble
       self

data/lib/tk/selection.rb

@@ -43,18 +43,19 @@ module TkSelection
     TkSelection.get_on_display(self, sel)
   end
 
-  def self.handle(win, func=Proc.new, keys=nil, &b)
+  def self.handle(win, func=nil, keys=nil, &b)
+    func ||= b
     if func.kind_of?(Hash) && keys == nil
       keys = func
-      func = Proc.new(&b)
+      func = b
     end
     args = ['selection', 'handle']
     args.concat(hash_kv(keys))
     args.concat([win, func])
     tk_call_without_enc(*args)
   end
-  def handle(func=Proc.new, keys=nil, &b)
-    TkSelection.handle(self, func, keys, &b)
+  def handle(func=nil, keys=nil, &b)
+    TkSelection.handle(self, func || b, keys, &b)
   end
 
   def self.get_owner(sel=nil)

data/lib/tk/text.rb

@@ -641,9 +641,9 @@ class Tk::Text<TkTextWin
     }
     args << _get_eval_enc_str(idx1) << _get_eval_enc_str(idx2)
     if cnt <= 1
-      number(tk_send_without_enc('count', *opts))
+      number(tk_send_without_enc('count', *args))
     else
-      list(tk_send_without_enc('count', *opts))
+      list(tk_send_without_enc('count', *args))
     end
   end
 
@@ -771,31 +771,23 @@ class Tk::Text<TkTextWin
   alias deltag tag_delete
   alias delete_tag tag_delete
 
-  #def tag_bind(tag, seq, cmd=Proc.new, *args)
-  #  _bind([@path, 'tag', 'bind', tag], seq, cmd, *args)
-  #  self
-  #end
-  def tag_bind(tag, seq, *args)
+  def tag_bind(tag, seq, *args, &block)
     # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
-    if TkComm._callback_entry?(args[0]) || !block_given?
+    if TkComm._callback_entry?(args[0]) || !block
       cmd = args.shift
     else
-      cmd = Proc.new
+      cmd = block
     end
     _bind([@path, 'tag', 'bind', tag], seq, cmd, *args)
     self
   end
 
-  #def tag_bind_append(tag, seq, cmd=Proc.new, *args)
-  #  _bind_append([@path, 'tag', 'bind', tag], seq, cmd, *args)
-  #  self
-  #end
-  def tag_bind_append(tag, seq, *args)
+  def tag_bind_append(tag, seq, *args, &block)
     # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
-    if TkComm._callback_entry?(args[0]) || !block_given?
+    if TkComm._callback_entry?(args[0]) || !block
       cmd = args.shift
     else
-      cmd = Proc.new
+      cmd = block
     end
     _bind_append([@path, 'tag', 'bind', tag], seq, cmd, *args)
     self

data/lib/tk/textmark.rb

@@ -10,7 +10,7 @@ class TkTextMark<TkObject
 
   TMarkID_TBL = TkCore::INTERP.create_table
 
-  (Tk_TextMark_ID = ['mark'.freeze, TkUtil.untrust('00000')]).instance_eval{
+  (Tk_TextMark_ID = ['mark'.freeze, '00000']).instance_eval{
     @mutex = Mutex.new
     def mutex; @mutex; end
     freeze

data/lib/tk/texttag.rb

@@ -12,7 +12,7 @@ class TkTextTag<TkObject
 
   TTagID_TBL = TkCore::INTERP.create_table
 
-  (Tk_TextTag_ID = ['tag'.freeze, TkUtil.untrust('00000')]).instance_eval{
+  (Tk_TextTag_ID = ['tag'.freeze, '00000']).instance_eval{
     @mutex = Mutex.new
     def mutex; @mutex; end
     freeze
@@ -191,31 +191,23 @@ class TkTextTag<TkObject
     @t.current_tag_configinfo @id, key
   end
 
-  #def bind(seq, cmd=Proc.new, *args)
-  #  _bind([@t.path, 'tag', 'bind', @id], seq, cmd, *args)
-  #  self
-  #end
-  def bind(seq, *args)
+  def bind(seq, *args, &block)
     # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
-    if TkComm._callback_entry?(args[0]) || !block_given?
+    if TkComm._callback_entry?(args[0]) || !block
       cmd = args.shift
     else
-      cmd = Proc.new
+      cmd = block
     end
     _bind([@t.path, 'tag', 'bind', @id], seq, cmd, *args)
     self
   end
 
-  #def bind_append(seq, cmd=Proc.new, *args)
-  #  _bind_append([@t.path, 'tag', 'bind', @id], seq, cmd, *args)
-  #  self
-  #end
-  def bind_append(seq, *args)
+  def bind_append(seq, *args, &block)
     # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
-    if TkComm._callback_entry?(args[0]) || !block_given?
+    if TkComm._callback_entry?(args[0]) || !block
       cmd = args.shift
     else
-      cmd = Proc.new
+      cmd = block
     end
     _bind_append([@t.path, 'tag', 'bind', @id], seq, cmd, *args)
     self