tk-win 0.2.0-x86-mingw32

data/lib/tk/toplevel.rb

@@ -0,0 +1,264 @@
+#
+# tk/toplevel.rb : treat toplevel widget
+#
+require 'tk'
+require 'tk/wm'
+require 'tk/menuspec'
+
+class Tk::Toplevel<TkWindow
+  include Wm
+  include TkMenuSpec
+
+  TkCommandNames = ['toplevel'.freeze].freeze
+  WidgetClassName = 'Toplevel'.freeze
+  WidgetClassNames[WidgetClassName] ||= self
+
+################# old version
+#  def initialize(parent=nil, screen=nil, classname=nil, keys=nil)
+#    if screen.kind_of? Hash
+#      keys = screen.dup
+#    else
+#      @screen = screen
+#    end
+#    @classname = classname
+#    if keys.kind_of? Hash
+#      keys = keys.dup
+#      @classname = keys.delete('classname') if keys.key?('classname')
+#      @colormap  = keys.delete('colormap')  if keys.key?('colormap')
+#      @container = keys.delete('container') if keys.key?('container')
+#      @screen    = keys.delete('screen')    if keys.key?('screen')
+#      @use       = keys.delete('use')       if keys.key?('use')
+#      @visual    = keys.delete('visual')    if keys.key?('visual')
+#    end
+#    super(parent, keys)
+#  end
+#
+#  def create_self
+#    s = []
+#    s << "-class"     << @classname if @classname
+#    s << "-colormap"  << @colormap  if @colormap
+#    s << "-container" << @container if @container
+#    s << "-screen"    << @screen    if @screen
+#    s << "-use"       << @use       if @use
+#    s << "-visual"    << @visual    if @visual
+#    tk_call 'toplevel', @path, *s
+#  end
+#################
+
+  def __boolval_optkeys
+    super() << 'container'
+  end
+  private :__boolval_optkeys
+
+  def __strval_optkeys
+    super() << 'screen'
+  end
+  private :__strval_optkeys
+
+  def __val2ruby_optkeys  # { key=>proc, ... }
+    super().update('menu'=>proc{|v| window(v)})
+  end
+  private :__val2ruby_optkeys
+
+  def __methodcall_optkeys  # { key=>method, ... }
+    TOPLEVEL_METHODCALL_OPTKEYS
+  end
+  private :__methodcall_optkeys
+
+  def _wm_command_option_chk(keys)
+    keys = {} unless keys
+    new_keys = {}
+    wm_cmds = {}
+
+    conf_methods = _symbolkey2str(__methodcall_optkeys())
+
+    keys.each{|k,v| # k is a String
+      if conf_methods.key?(k)
+        wm_cmds[conf_methods[k]] = v
+      elsif Wm.method_defined?(k)
+        case k
+        when 'screen','class','colormap','container','use','visual'
+          new_keys[k] = v
+        else
+          case self.method(k).arity
+          when -1,1
+            wm_cmds[k] = v
+          else
+            new_keys[k] = v
+          end
+        end
+      else
+        new_keys[k] = v
+      end
+    }
+    [new_keys, wm_cmds]
+  end
+  private :_wm_command_option_chk
+
+  def initialize(parent=nil, screen=nil, classname=nil, keys=nil)
+    my_class_name = nil
+    if self.class < WidgetClassNames[WidgetClassName]
+      my_class_name = self.class.name
+      my_class_name = nil if my_class_name == ''
+    end
+    if parent.kind_of? Hash
+      keys = _symbolkey2str(parent)
+      if keys.key?('classname')
+        keys['class'] = keys.delete('classname')
+      end
+      @classname = keys['class']
+      @colormap  = keys['colormap']
+      @container = keys['container']
+      @screen    = keys['screen']
+      @use       = keys['use']
+      @visual    = keys['visual']
+      if !@classname && my_class_name
+        keys['class'] = @classname = my_class_name
+      end
+      if @classname.kind_of? TkBindTag
+        @db_class = @classname
+        keys['class'] = @classname = @classname.id
+      elsif @classname
+        @db_class = TkDatabaseClass.new(@classname)
+        keys['class'] = @classname
+      else
+        @db_class = self.class
+        @classname = @db_class::WidgetClassName
+      end
+      keys, cmds = _wm_command_option_chk(keys)
+      super(keys)
+      cmds.each{|k,v|
+        if v.kind_of? Array
+          self.__send__(k,*v)
+        else
+          self.__send__(k,v)
+        end
+      }
+      return
+    end
+
+    if screen.kind_of? Hash
+      keys = screen
+    else
+      @screen = screen
+      if classname.kind_of? Hash
+        keys = classname
+      else
+        @classname = classname
+      end
+    end
+    if keys.kind_of? Hash
+      keys = _symbolkey2str(keys)
+      if keys.key?('classname')
+        keys['class'] = keys.delete('classname')
+      end
+      @classname = keys['class']  unless @classname
+      @colormap  = keys['colormap']
+      @container = keys['container']
+      @screen    = keys['screen'] unless @screen
+      @use       = keys['use']
+      @visual    = keys['visual']
+    else
+      keys = {}
+    end
+    if !@classname && my_class_name
+      keys['class'] = @classname = my_class_name
+    end
+    if @classname.kind_of? TkBindTag
+      @db_class = @classname
+      keys['class'] = @classname = @classname.id
+    elsif @classname
+      @db_class = TkDatabaseClass.new(@classname)
+      keys['class'] = @classname
+    else
+      @db_class = self.class
+      @classname = @db_class::WidgetClassName
+    end
+    keys, cmds = _wm_command_option_chk(keys)
+    super(parent, keys)
+    cmds.each{|k,v|
+      if v.kind_of? Array
+        self.send(k,*v)
+      else
+        self.send(k,v)
+      end
+    }
+  end
+
+  #def create_self(keys)
+  #  if keys and keys != None
+  #    tk_call_without_enc('toplevel', @path, *hash_kv(keys, true))
+  #  else
+  #    tk_call_without_enc('toplevel', @path)
+  #  end
+  #end
+  #private :create_self
+
+  def specific_class
+    @classname
+  end
+
+  def add_menu(menu_info, tearoff=false, opts=nil)
+    # See tk/menuspec.rb for menu_info.
+    # opts is a hash of default configs for all of cascade menus.
+    # Configs of menu_info can override it.
+    if tearoff.kind_of?(Hash)
+      opts = tearoff
+      tearoff = false
+    end
+    _create_menubutton(self, menu_info, tearoff, opts)
+  end
+
+  def add_menubar(menu_spec, tearoff=false, opts=nil)
+    # See tk/menuspec.rb for menu_spec.
+    # opts is a hash of default configs for all of cascade menus.
+    # Configs of menu_spec can override it.
+    menu_spec.each{|info| add_menu(info, tearoff, opts)}
+    self.menu
+  end
+
+  def self.database_class
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      self
+    else
+      TkDatabaseClass.new(self.name)
+    end
+  end
+  def self.database_classname
+    self.database_class.name
+  end
+
+  def self.bind(*args, &b)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args, &b)
+    else
+      TkDatabaseClass.new(self.name).bind(*args, &b)
+    end
+  end
+  def self.bind_append(*args, &b)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args, &b)
+    else
+      TkDatabaseClass.new(self.name).bind_append(*args, &b)
+    end
+  end
+  def self.bind_remove(*args)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args)
+    else
+      TkDatabaseClass.new(self.name).bind_remove(*args)
+    end
+  end
+  def self.bindinfo(*args)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args)
+    else
+      TkDatabaseClass.new(self.name).bindinfo(*args)
+    end
+  end
+end
+
+#TkToplevel = Tk::Toplevel unless Object.const_defined? :TkToplevel
+#Tk.__set_toplevel_aliases__(:Tk, Tk::Toplevel, :TkToplevel)
+Tk.__set_loaded_toplevel_aliases__('tk/toplevel.rb', :Tk, Tk::Toplevel,
+                                   :TkToplevel)

data/lib/tk/ttk_selector.rb

@@ -0,0 +1,98 @@
+#
+#  ttk_selector
+#
+######################################
+#  toplevel classes/modules
+module Tk
+  @TOPLEVEL_ALIAS_TABLE[:Ttk] = {
+    :TkButton       => 'tkextlib/tile/tbutton',
+
+    :TkCheckbutton  => 'tkextlib/tile/tcheckbutton',
+    :TkCheckButton  => 'tkextlib/tile/tcheckbutton',
+
+    # :TkDialog       => 'tkextlib/tile/dialog',
+
+    :TkEntry        => 'tkextlib/tile/tentry',
+
+    :TkCombobox     => 'tkextlib/tile/tcombobox',
+
+    :TkFrame        => 'tkextlib/tile/tframe',
+
+    :TkLabel        => 'tkextlib/tile/tlabel',
+
+    :TkLabelframe   => 'tkextlib/tile/tlabelframe',
+    :TkLabelFrame   => 'tkextlib/tile/tlabelframe',
+
+    :TkMenubutton   => 'tkextlib/tile/tmenubutton',
+    :TkMenuButton   => 'tkextlib/tile/tmenubutton',
+
+    :TkNotebook     => 'tkextlib/tile/tnotebook',
+
+    # :TkPaned        => 'tkextlib/tile/tpaned',
+    :TkPanedwindow  => 'tkextlib/tile/tpaned',
+    :TkPanedWindow  => 'tkextlib/tile/tpaned',
+
+    :TkProgressbar  => 'tkextlib/tile/tprogressbar',
+
+    :TkRadiobutton  => 'tkextlib/tile/tradiobutton',
+    :TkRadioButton  => 'tkextlib/tile/tradiobutton',
+
+    :TkScale        => 'tkextlib/tile/tscale',
+    # :TkProgress     => 'tkextlib/tile/tscale',
+
+    :TkScrollbar    => 'tkextlib/tile/tscrollbar',
+    :TkXScrollbar   => 'tkextlib/tile/tscrollbar',
+    :TkYScrollbar   => 'tkextlib/tile/tscrollbar',
+
+    :TkSeparator    => 'tkextlib/tile/tseparator',
+
+    :TkSizeGrip     => 'tkextlib/tile/sizegrip',
+    :TkSizegrip     => 'tkextlib/tile/sizegrip',
+
+    # :TkSquare       => 'tkextlib/tile/tsquare',
+
+    :TkTreeview     => 'tkextlib/tile/treeview',
+  }
+
+  # @TOPLEVEL_ALIAS_TABLE[:Tile] = @TOPLEVEL_ALIAS_TABLE[:Ttk]
+  Tk.__create_widget_set__(:Tile, :Ttk)
+
+  ############################################
+  #  depend on the version of Tcl/Tk
+  major, minor, type, patchlevel = TclTkLib.get_version
+
+  #  ttk::spinbox is supported on Tcl/Tk8.6b1 or later
+  if ([major,minor,type,patchlevel] <=> 
+        [8,6,TclTkLib::RELEASE_TYPE::BETA,1]) >= 0
+    @TOPLEVEL_ALIAS_TABLE[:Ttk].update(
+      :TkSpinbox => 'tkextlib/tile/tspinbox'
+    )
+  end
+
+  ################################################
+  # register some Ttk widgets as default
+  # (Ttk is a standard library on Tcl/Tk8.5+)
+  @TOPLEVEL_ALIAS_TABLE[:Ttk].each{|sym, file|
+    #unless Tk::TOPLEVEL_ALIASES.autoload?(sym) || Tk::TOPLEVEL_ALIASES.const_defined?(sym)
+    #   @TOPLEVEL_ALIAS_OWNER[sym] = :Ttk
+    #   Tk::TOPLEVEL_ALIASES.autoload(sym, file)
+    #end
+    Tk.__regist_toplevel_aliases__(:Ttk, file, sym)
+  }
+
+  ################################################
+
+  # @TOPLEVEL_ALIAS_SETUP_PROC[:Tile] =
+  #   @TOPLEVEL_ALIAS_SETUP_PROC[:Ttk] = proc{|mod|
+  #   unless Tk.autoload?(:Tile) || Tk.const_defined?(:Tile)
+  #     Object.autoload :Ttk, 'tkextlib/tile'
+  #     Tk.autoload :Tile, 'tkextlib/tile'
+  #   end
+  # }
+  Tk.__toplevel_alias_setup_proc__(:Ttk, :Tile){|mod|
+    unless Tk.autoload?(:Tile) || Tk.const_defined?(:Tile)
+      Object.autoload :Ttk, 'tkextlib/tile'
+      Tk.autoload :Tile, 'tkextlib/tile'
+    end
+  }
+end

data/lib/tk/txtwin_abst.rb

@@ -0,0 +1,39 @@
+#
+# tk/txtwin_abst.rb : TkTextWin abstruct class
+#
+require 'tk'
+
+class TkTextWin<TkWindow
+  TkCommandNames = [].freeze
+  #def create_self
+  #  fail RuntimeError, "TkTextWin is an abstract class"
+  #end
+  #private :create_self
+
+  def bbox(index)
+    list(tk_send_without_enc('bbox', index))
+  end
+  def delete(first, last=None)
+    tk_send_without_enc('delete', first, last)
+    self
+  end
+  def get(*index)
+    _fromUTF8(tk_send_without_enc('get', *index))
+  end
+  def insert(index, *args)
+    tk_send('insert', index, *args)
+    self
+  end
+  def scan_mark(x, y)
+    tk_send_without_enc('scan', 'mark', x, y)
+    self
+  end
+  def scan_dragto(x, y)
+    tk_send_without_enc('scan', 'dragto', x, y)
+    self
+  end
+  def see(index)
+    tk_send_without_enc('see', index)
+    self
+  end
+end

data/lib/tk/validation.rb

@@ -0,0 +1,397 @@
+#
+#  tk/validation.rb - validation support module for entry, spinbox, and so on
+#
+require 'tk'
+
+module Tk
+  module ValidateConfigure
+    def self.__def_validcmd(scope, klass, keys=nil)
+      keys = klass._config_keys unless keys
+      keys.each{|key|
+        eval("def #{key}(*args, &b)
+                 __validcmd_call(#{klass.name}, '#{key}', *args, &b)
+              end", scope)
+      }
+    end
+
+    def __validcmd_call(klass, key, *args, &b)
+      return cget(key) if args.empty? && !b
+
+      cmd = (b)? proc(&b) : args.shift
+
+      if cmd.kind_of?(klass)
+        configure(key, cmd)
+      elsif !args.empty?
+        configure(key, [cmd, args])
+      else
+        configure(key, cmd)
+      end
+    end
+
+    def __validation_class_list
+      # maybe need to override
+      []
+    end
+
+    def __get_validate_key2class
+      k2c = {}
+      __validation_class_list.each{|klass|
+        klass._config_keys.each{|key|
+          k2c[key.to_s] = klass
+        }
+      }
+      k2c
+    end
+
+    def __conv_vcmd_on_hash_kv(keys)
+      key2class = __get_validate_key2class
+
+      keys = _symbolkey2str(keys)
+      key2class.each{|key, klass|
+        if keys[key].kind_of?(Array)
+          cmd, *args = keys[key]
+          #keys[key] = klass.new(cmd, args.join(' '))
+          keys[key] = klass.new(cmd, *args)
+        # elsif keys[key].kind_of?(Proc) ||  keys[key].kind_of?(Method)
+        elsif TkComm._callback_entry?(keys[key])
+          keys[key] = klass.new(keys[key])
+        end
+      }
+      keys
+    end
+
+    def create_self(keys)
+      super(__conv_vcmd_on_hash_kv(keys))
+    end
+    private :create_self
+
+    def configure(slot, value=TkComm::None)
+      if slot.kind_of?(Hash)
+        super(__conv_vcmd_on_hash_kv(slot))
+      else
+        super(__conv_vcmd_on_hash_kv(slot=>value))
+      end
+      self
+    end
+=begin
+    def configure(slot, value=TkComm::None)
+      key2class = __get_validate_key2class
+
+      if slot.kind_of?(Hash)
+        slot = _symbolkey2str(slot)
+        key2class.each{|key, klass|
+          if slot[key].kind_of?(Array)
+            cmd, *args = slot[key]
+            slot[key] = klass.new(cmd, args.join(' '))
+          elsif slot[key].kind_of?(Proc) || slot[key].kind_of?(Method)
+            slot[key] = klass.new(slot[key])
+          end
+        }
+        super(slot)
+
+      else
+        slot = slot.to_s
+        if (klass = key2class[slot])
+          if value.kind_of?(Array)
+            cmd, *args = value
+            value = klass.new(cmd, args.join(' '))
+          elsif value.kind_of?(Proc) || value.kind_of?(Method)
+            value = klass.new(value)
+          end
+        end
+        super(slot, value)
+      end
+
+      self
+    end
+=end
+  end
+
+  module ItemValidateConfigure
+    def self.__def_validcmd(scope, klass, keys=nil)
+      keys = klass._config_keys unless keys
+      keys.each{|key|
+        eval("def item_#{key}(id, *args, &b)
+                 __item_validcmd_call(#{klass.name}, '#{key}', id, *args, &b)
+              end", scope)
+      }
+    end
+
+    def __item_validcmd_call(tagOrId, klass, key, *args, &b)
+      return itemcget(tagid(tagOrId), key) if args.empty? && !b
+
+      cmd = (b)? proc(&b) : args.shift
+
+      if cmd.kind_of?(klass)
+        itemconfigure(tagid(tagOrId), key, cmd)
+      elsif !args.empty?
+        itemconfigure(tagid(tagOrId), key, [cmd, args])
+      else
+        itemconfigure(tagid(tagOrId), key, cmd)
+      end
+    end
+
+    def __item_validation_class_list(id)
+      # maybe need to override
+      []
+    end
+
+    def __get_item_validate_key2class(id)
+      k2c = {}
+      __item_validation_class_list(id).each{|klass|
+        klass._config_keys.each{|key|
+          k2c[key.to_s] = klass
+        }
+      }
+    end
+
+    def __conv_item_vcmd_on_hash_kv(keys)
+      key2class = __get_item_validate_key2class(tagid(tagOrId))
+
+      keys = _symbolkey2str(keys)
+      key2class.each{|key, klass|
+        if keys[key].kind_of?(Array)
+          cmd, *args = keys[key]
+          #keys[key] = klass.new(cmd, args.join(' '))
+          keys[key] = klass.new(cmd, *args)
+        # elsif keys[key].kind_of?(Proc) || keys[key].kind_of?(Method)
+        elsif TkComm._callback_entry?(keys[key])
+          keys[key] = klass.new(keys[key])
+        end
+      }
+      keys
+    end
+
+    def itemconfigure(tagOrId, slot, value=TkComm::None)
+      if slot.kind_of?(Hash)
+        super(__conv_item_vcmd_on_hash_kv(slot))
+      else
+        super(__conv_item_vcmd_on_hash_kv(slot=>value))
+      end
+      self
+    end
+=begin
+    def itemconfigure(tagOrId, slot, value=TkComm::None)
+      key2class = __get_item_validate_key2class(tagid(tagOrId))
+
+      if slot.kind_of?(Hash)
+        slot = _symbolkey2str(slot)
+        key2class.each{|key, klass|
+          if slot[key].kind_of?(Array)
+            cmd, *args = slot[key]
+            slot[key] = klass.new(cmd, args.join(' '))
+          elsif slot[key].kind_of?(Proc) ||  slot[key].kind_of?(Method)
+            slot[key] = klass.new(slot[key])
+          end
+        }
+        super(slot)
+
+      else
+        slot = slot.to_s
+        if (klass = key2class[slot])
+          if value.kind_of?(Array)
+            cmd, *args = value
+            value = klass.new(cmd, args.join(' '))
+          elsif value.kind_of?(Proc) || value.kind_of?(Method)
+            value = klass.new(value)
+          end
+        end
+        super(slot, value)
+      end
+
+      self
+    end
+=end
+  end
+end
+
+class TkValidateCommand
+  include TkComm
+  extend  TkComm
+
+  class ValidateArgs < TkUtil::CallbackSubst
+    KEY_TBL = [
+      [ ?d, ?n, :action ],
+      [ ?i, ?x, :index ],
+      [ ?s, ?e, :current ],
+      [ ?v, ?s, :type ],
+      [ ?P, ?e, :value ],
+      [ ?S, ?e, :string ],
+      [ ?V, ?s, :triggered ],
+      [ ?W, ?w, :widget ],
+      nil
+    ]
+
+    PROC_TBL = [
+      [ ?n, TkComm.method(:number) ],
+      [ ?s, TkComm.method(:string) ],
+      [ ?w, TkComm.method(:window) ],
+
+      [ ?e, proc{|val|
+          #enc = Tk.encoding
+          enc = ((Tk.encoding)? Tk.encoding : Tk.encoding_system)
+          if enc
+            Tk.fromUTF8(TkComm::string(val), enc)
+          else
+            TkComm::string(val)
+          end
+        }
+      ],
+
+      [ ?x, proc{|val|
+          idx = TkComm::number(val)
+          if idx < 0
+            nil
+          else
+            idx
+          end
+        }
+      ],
+
+      nil
+    ]
+
+=begin
+    # for Ruby m17n :: ?x --> String --> char-code ( getbyte(0) )
+    KEY_TBL.map!{|inf|
+      if inf.kind_of?(Array)
+        inf[0] = inf[0].getbyte(0) if inf[0].kind_of?(String)
+        inf[1] = inf[1].getbyte(0) if inf[1].kind_of?(String)
+      end
+      inf
+    }
+
+    PROC_TBL.map!{|inf|
+      if inf.kind_of?(Array)
+        inf[0] = inf[0].getbyte(0) if inf[0].kind_of?(String)
+      end
+      inf
+    }
+=end
+
+    _setup_subst_table(KEY_TBL, PROC_TBL);
+
+    #
+    # NOTE: The order of parameters which passed to callback procedure is
+    #        <extra_arg>, <extra_arg>, ... , <subst_arg>, <subst_arg>, ...
+    #
+
+    #def self._get_extra_args_tbl
+    #  # return an array of convert procs
+    #  []
+    #end
+
+    def self.ret_val(val)
+      (val)? '1': '0'
+    end
+  end
+
+  ###############################################
+
+  def self._config_keys
+    # array of config-option key (string or symbol)
+    ['vcmd', 'validatecommand', 'invcmd', 'invalidcommand']
+  end
+
+  def _initialize_for_cb_class(klass, cmd = Proc.new, *args)
+    extra_args_tbl = klass._get_extra_args_tbl
+
+    if args.compact.size > 0
+      args.map!{|arg| klass._sym2subst(arg)}
+      args = args.join(' ')
+      keys = klass._get_subst_key(args)
+      if cmd.kind_of?(String)
+        id = cmd
+      elsif cmd.kind_of?(TkCallbackEntry)
+        @id = install_cmd(cmd)
+      else
+        @id = install_cmd(proc{|*arg|
+             ex_args = []
+             extra_args_tbl.reverse_each{|conv| ex_args << conv.call(arg.pop)}
+             klass.ret_val(cmd.call(
+               *(ex_args.concat(klass.scan_args(keys, arg)))
+             ))
+        }) + ' ' + args
+      end
+    else
+      keys, args = klass._get_all_subst_keys
+      if cmd.kind_of?(String)
+        id = cmd
+      elsif cmd.kind_of?(TkCallbackEntry)
+        @id = install_cmd(cmd)
+      else
+        @id = install_cmd(proc{|*arg|
+             ex_args = []
+             extra_args_tbl.reverse_each{|conv| ex_args << conv.call(arg.pop)}
+             klass.ret_val(cmd.call(
+               *(ex_args << klass.new(*klass.scan_args(keys, arg)))
+             ))
+        }) + ' ' + args
+      end
+    end
+  end
+
+  def initialize(cmd = Proc.new, *args)
+    _initialize_for_cb_class(self.class::ValidateArgs, cmd, *args)
+  end
+
+  def to_eval
+    @id
+  end
+end
+
+module TkValidation
+  include Tk::ValidateConfigure
+
+  class ValidateCmd < TkValidateCommand
+    module Action
+      Insert = 1
+      Delete = 0
+      Others = -1
+      Focus  = -1
+      Forced = -1
+      Textvariable = -1
+      TextVariable = -1
+    end
+  end
+
+  #####################################
+
+  def __validation_class_list
+    super() << ValidateCmd
+  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