tk 0.1.0 → 0.4.0

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
@@ -274,7 +210,6 @@ module TkOptionDB
     unless func.kind_of?(Array)
       fail ArgumentError, "method-list must be Array"
     end
-    func_str = func.join(' ')
 
     if parent.kind_of?(Class) && parent <= @@resource_proc_class
       cmd_klass = Class.new(parent)
@@ -289,12 +224,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/optionobj.rb

@@ -36,7 +36,7 @@ module Tk
 
     def _remove_win(win)
       if win.kind_of?(Array)
-        widget, method = win
+        widget, _ = win
         @observ.delete_if{|x|
           if x.kind_of?(Array)
             x[0] == widget

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)
@@ -102,7 +102,7 @@ class Tk::Scale<TkWindow
     get
   end
 
-  def value= (val)
+  def value=(val)
     set(val)
     val
   end

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

@@ -326,7 +326,7 @@ class Tk::Text<TkTextWin
     _fromUTF8(tk_send_without_enc('get', "1.0", "end - 1 char"))
   end
 
-  def value= (val)
+  def value=(val)
     tk_send_without_enc('delete', "1.0", 'end')
     tk_send_without_enc('insert', "1.0", _get_eval_enc_str(val))
     val
@@ -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

data/lib/tk/timer.rb

@@ -12,13 +12,13 @@ class TkTimer
 
   TkCommandNames = ['after'.freeze].freeze
 
-  (Tk_CBID = ['a'.freeze, TkUtil.untrust('00000')]).instance_eval{
+  (Tk_CBID = ['a'.freeze, '00000']).instance_eval{
     @mutex = Mutex.new
     def mutex; @mutex; end
     freeze
   }
 
-  Tk_CBTBL = TkUtil.untrust({})
+  Tk_CBTBL = {}
 
   TkCore::INTERP.add_tk_procs('rb_after', 'id', <<-'EOL')
     if {[set st [catch {eval {ruby_cmd TkTimer callback} $id} ret]] != 0} {

data/lib/tk/tk_mac.rb

@@ -17,48 +17,48 @@ module Tk::Mac
   extend TkCore
 
   # event handler callbacks
-  def self.def_ShowPreferences(cmd=Proc.new)
-    ip_eval("proc ::tk::mac::ShowPreferences {} { #{install_cmd(cmd)} }")
+  def self.def_ShowPreferences(cmd=nil, &block)
+    ip_eval("proc ::tk::mac::ShowPreferences {} { #{install_cmd(cmd || block)} }")
     nil
   end
 
-  def self.def_OpenApplication(cmd=Proc.new)
-    ip_eval("proc ::tk::mac::OpenApplication {} { #{install_cmd(cmd)} }")
+  def self.def_OpenApplication(cmd=nil, &block)
+    ip_eval("proc ::tk::mac::OpenApplication {} { #{install_cmd(cmd || block)} }")
     nil
   end
 
-  def self.def_ReopenApplication(cmd=Proc.new)
-    ip_eval("proc ::tk::mac::ReopenApplication {} { #{install_cmd(cmd)} }")
+  def self.def_ReopenApplication(cmd=nil, &block)
+    ip_eval("proc ::tk::mac::ReopenApplication {} { #{install_cmd(cmd || block)} }")
     nil
   end
 
-  def self.def_OpenDocument(cmd=Proc.new)
-    ip_eval("proc ::tk::mac::OpenDocument {args} { eval #{install_cmd(cmd)} $args }")
+  def self.def_OpenDocument(cmd=nil, &block)
+    ip_eval("proc ::tk::mac::OpenDocument {args} { eval #{install_cmd(cmd || block)} $args }")
     nil
   end
 
-  def self.def_PrintDocument(cmd=Proc.new)
-    ip_eval("proc ::tk::mac::PrintDocument {args} { eval #{install_cmd(cmd)} $args }")
+  def self.def_PrintDocument(cmd=nil, &block)
+    ip_eval("proc ::tk::mac::PrintDocument {args} { eval #{install_cmd(cmd || block)} $args }")
     nil
   end
 
-  def self.def_Quit(cmd=Proc.new)
-    ip_eval("proc ::tk::mac::Quit {} { #{install_cmd(cmd)} }")
+  def self.def_Quit(cmd=nil, &block)
+    ip_eval("proc ::tk::mac::Quit {} { #{install_cmd(cmd || block)} }")
     nil
   end
 
-  def self.def_OnHide(cmd=Proc.new)
-    ip_eval("proc ::tk::mac::OnHide {} { #{install_cmd(cmd)} }")
+  def self.def_OnHide(cmd=nil, &block)
+    ip_eval("proc ::tk::mac::OnHide {} { #{install_cmd(cmd || block)} }")
     nil
   end
 
-  def self.def_OnShow(cmd=Proc.new)
-    ip_eval("proc ::tk::mac::OnShow {} { #{install_cmd(cmd)} }")
+  def self.def_OnShow(cmd=nil, &block)
+    ip_eval("proc ::tk::mac::OnShow {} { #{install_cmd(cmd || block)} }")
     nil
   end
 
-  def self.def_ShowHelp(cmd=Proc.new)
-    ip_eval("proc ::tk::mac::ShowHelp {} { #{install_cmd(cmd)} }")
+  def self.def_ShowHelp(cmd=nil, &block)
+    ip_eval("proc ::tk::mac::ShowHelp {} { #{install_cmd(cmd || block)} }")
     nil
   end
 

data/lib/tk/validation.rb

@@ -294,7 +294,8 @@ class TkValidateCommand
     ['vcmd', 'validatecommand', 'invcmd', 'invalidcommand']
   end
 
-  def _initialize_for_cb_class(klass, cmd = Proc.new, *args)
+  def _initialize_for_cb_class(klass, cmd = nil, *args, &block)
+    cmd ||= block
     extra_args_tbl = klass._get_extra_args_tbl
 
     if args.compact.size > 0
@@ -302,7 +303,7 @@ class TkValidateCommand
       args = args.join(' ')
       keys = klass._get_subst_key(args)
       if cmd.kind_of?(String)
-        id = cmd
+        @id = cmd
       elsif cmd.kind_of?(TkCallbackEntry)
         @id = install_cmd(cmd)
       else
@@ -317,7 +318,7 @@ class TkValidateCommand
     else
       keys, args = klass._get_all_subst_keys
       if cmd.kind_of?(String)
-        id = cmd
+        @id = cmd
       elsif cmd.kind_of?(TkCallbackEntry)
         @id = install_cmd(cmd)
       else
@@ -332,8 +333,8 @@ class TkValidateCommand
     end
   end
 
-  def initialize(cmd = Proc.new, *args)
-    _initialize_for_cb_class(self.class::ValidateArgs, cmd, *args)
+  def initialize(cmd = nil, *args, &block)
+    _initialize_for_cb_class(self.class::ValidateArgs, cmd || block, *args)
   end
 
   def to_eval
@@ -363,36 +364,4 @@ module TkValidation
   end
 
   Tk::ValidateConfigure.__def_validcmd(binding, ValidateCmd)
-
-=begin
-  def validatecommand(cmd = Proc.new, args = nil)
-    if cmd.kind_of?(ValidateCmd)
-      configure('validatecommand', cmd)
-    elsif args
-      configure('validatecommand', [cmd, args])
-    else
-      configure('validatecommand', cmd)
-    end
-  end
-=end
-#  def validatecommand(*args, &b)
-#    __validcmd_call(ValidateCmd, 'validatecommand', *args, &b)
-#  end
-#  alias vcmd validatecommand
-
-=begin
-  def invalidcommand(cmd = Proc.new, args = nil)
-    if cmd.kind_of?(ValidateCmd)
-      configure('invalidcommand', cmd)
-    elsif args
-      configure('invalidcommand', [cmd, args])
-    else
-      configure('invalidcommand', cmd)
-    end
-  end
-=end
-#  def invalidcommand(*args, &b)
-#    __validcmd_call(ValidateCmd, 'invalidcommand', *args, &b)
-#  end
-#  alias invcmd invalidcommand
 end