TkOptionDB ^(Module)

# File tk/lib/tk/optiondb.rb, line 194
  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 = "class \#{klass} < TkOptionDB.module_eval('@@resource_proc_class')\nCARRIER    = '\#{carrier}'.freeze\nMETHOD_TBL = TkCore::INTERP.create_table\nADD_METHOD = \#{add}\nSAFE_MODE  = \#{safe}\n%w(\#{func_str}).each{|f| METHOD_TBL[f.intern] = nil }\nend\n"

    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

# File tk/lib/tk/optiondb.rb, line 254
  def __get_random_basename
    name = '%s%03d' % [RAND_BASE_HEAD[rand(RAND_BASE_HEAD.size),1], 
                       RAND_BASE_CNT[0]]
    len = RAND_BASE_CHAR.size
    (6+rand(10)).times{
      name << RAND_BASE_CHAR[rand(len),1]
    }
    RAND_BASE_CNT[0] = RAND_BASE_CNT[0] + 1
    name
  end

# File tk/lib/tk/optiondb.rb, line 234
  def __remove_methods_of_proc_class(klass)
    # for security, make these methods invalid

    class << klass
      attr_reader :class_eval, :name, :superclass, 
        :ancestors, :const_defined?, :const_get, :const_set, 
        :constants, :included_modules, :instance_methods, 
        :method_defined?, :module_eval, :private_instance_methods, 
        :protected_instance_methods, :public_instance_methods, 
        :remove_const, :remove_method, :undef_method, 
        :to_s, :inspect, :display, :method, :methods, 
        :instance_eval, :instance_variables, :kind_of?, :is_a?,
        :private_methods, :protected_methods, :public_methods
    end
  end

# File tk/lib/tk/optiondb.rb, line 19
  def add(pat, value, pri=None)
    if $SAFE >= 4
      fail SecurityError, "can't call 'TkOptionDB.add' at $SAFE >= 4"
    end
    tk_call('option', 'add', pat, value, pri)
  end

# File tk/lib/tk/optiondb.rb, line 25
  def clear
    if $SAFE >= 4
      fail SecurityError, "can't call 'TkOptionDB.crear' at $SAFE >= 4"
    end
    tk_call_without_enc('option', 'clear')
  end

# File tk/lib/tk/optiondb.rb, line 280
  def eval_under_random_base(parent = nil, &b)
    new_klass = __create_new_class(__get_random_basename(), 
                                   [], 4, false, parent)
    ret = new_klass.class_eval(&b) if block_given?
    __remove_methods_of_proc_class(new_klass)
    new_klass.freeze
    ret
  end

# File tk/lib/tk/optiondb.rb, line 31
  def get(win, name, klass)
    tk_call('option', 'get', win ,name, klass)
  end

# File tk/lib/tk/optiondb.rb, line 271
  def new_proc_class(klass, func, safe = 4, add = false, parent = nil, &b)
    new_klass = __create_new_class(klass, func, safe, add, parent)
    new_klass.class_eval(&b) if block_given?
    __remove_methods_of_proc_class(new_klass)
    new_klass.freeze
    new_klass
  end

# File tk/lib/tk/optiondb.rb, line 290
  def new_proc_class_random(klass, func, safe = 4, add = false, &b)
    eval_under_random_base(){
      TkOption.new_proc_class(klass, func, safe, add, self, &b)
    }
  end

# File tk/lib/tk/optiondb.rb, line 39
  def read_entries(file, f_enc=nil)
    if TkCore::INTERP.safe?
      fail SecurityError, 
        "can't call 'TkOptionDB.read_entries' on a safe interpreter"
    end

    i_enc = Tk.encoding()

    unless f_enc
      f_enc = i_enc
    end

    ent = []
    cline = ''
    open(file, 'r') {|f|
      while line = f.gets
        cline += line.chomp!
        case cline
        when /\\$/    # continue

          cline.chop!
          next
        when /^\s*(!|#)/     # coment

          cline = ''
          next
        when /^([^:]+):(.*)$/
          pat = $1.strip
          val = $2.lstrip
          p "ResourceDB: #{[pat, val].inspect}" if $DEBUG
          pat = TkCore::INTERP._toUTF8(pat, f_enc)
          pat = TkCore::INTERP._fromUTF8(pat, i_enc)
          val = TkCore::INTERP._toUTF8(val, f_enc)
          val = TkCore::INTERP._fromUTF8(val, i_enc)
          ent << [pat, val]
          cline = ''
        else          # unknown --> ignore

          cline = ''
          next
        end
      end
    }
    ent
  end

# File tk/lib/tk/optiondb.rb, line 83
  def read_with_encoding(file, f_enc=nil, pri=None)
    # try to read the file as an OptionDB file

    read_entries(file, f_enc).each{|pat, val|
      add(pat, val, pri)
    }

??
  end

# File tk/lib/tk/optiondb.rb, line 34
  def readfile(file, pri=None)
    tk_call('option', 'readfile', file, pri)
  end