Module | TkOptionDB
In: | tk/lib/tk/optiondb.rb

### Methods

__create_new_class __get_random_basename __remove_methods_of_proc_class add clear eval_under_random_base get new_proc_class new_proc_class_random read_entries read_file read_with_encoding readfile

### Included Modules

Tk

### Classes and Modules

Module TkOptionDB::Priority

### Constants

TkCommandNames | = | ['option'.freeze].freeze
CmdClassID | = | ['CMD_CLASS'.freeze, '00000'.taint].freeze
RAND_BASE_CNT | = | [0]
RAND_BASE_HEAD | = | 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
RAND_BASE_CHAR | = | RAND_BASE_HEAD + 'abcdefghijklmnopqrstuvwxyz0123456789_'

### Public Instance methods

__create_new_class(klass, func, safe = 4, add = false, parent = nil)

[Source]

    # File tk/lib/tk/optiondb.rb, line 250
      def __create_new_class(klass, func, safe = 4, add = false, parent = nil)
        if klass.kind_of?(TkWindow)
          carrier = klass.path
          klass = CmdClassID.join(TkCore::INTERP._ip_id_)
          CmdClassID[1].succ!
          parent = nil # ignore parent
        else
          klass = klass.to_s if klass.kind_of?(Symbol)
          unless (?A..?Z) === klass[0]
            fail ArgumentError, "bad string '#{klass}' for class name"
          end
          if parent == nil
            install_win(nil)
          elsif parent.kind_of?(TkWindow)
            install_win(parent.path)
          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)
        end

        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)
        else
          cmd_klass = Class.new(TkOptionDB.module_eval('@@resource_proc_class'))
        end
        cmd_klass.const_set(:CARRIER, carrier.dup.freeze)

        cmd_klass.instance_variable_set('@method_tbl', TkCore::INTERP.create_table)
        cmd_klass.instance_variable_set('@add_method', add)
        cmd_klass.instance_variable_set('@safe_mode', safe)
        func.each{|f|
          cmd_klass.instance_variable_get('@method_tbl')[f.to_s.intern] = nil
        }
    ??

        cmd_klass
      end

__get_random_basename()

[Source]

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

__remove_methods_of_proc_class(klass)

[Source]

    # File tk/lib/tk/optiondb.rb, line 303
      def __remove_methods_of_proc_class(klass)
        # for security, make these methods invalid
        class << klass
          def __null_method(*args); nil; end
          [ :class_eval, :name, :superclass, :clone, :dup, :autoload, :autoload?,
            :ancestors, :const_defined?, :const_get, :const_set, :const_missing,
            :class_variables, :constants, :included_modules, :instance_methods,
            :method_defined?, :module_eval, :private_instance_methods,
            :protected_instance_methods, :public_instance_methods,
            :singleton_methods, :remove_const, :remove_method, :undef_method,
            :to_s, :inspect, :display, :method, :methods, :respond_to?,
            :instance_variable_get, :instance_variable_set, :instance_method,
            :instance_eval, :instance_variables, :kind_of?, :is_a?,
            :private_methods, :protected_methods, :public_methods ].each{|m|
            alias_method(m, :__null_method)
          }
        end
      end

add(pat, value, pri=None)

[Source]

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

clear()

[Source]

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

eval_under_random_base(parent = nil, &b)

[Source]

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

get(win, name, klass)

[Source]

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

new_proc_class(klass, func, safe = 4, add = false, parent = nil, &b)

define new proc class : If you want to modify the new class or create a new subclass, you must do such operation in the block parameter. Because the created class is flozen after evaluating the block.

[Source]

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

new_proc_class_random(klass, func, safe = 4, add = false, &b)

[Source]

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

read_entries(file, f_enc=nil)

[Source]

    # File tk/lib/tk/optiondb.rb, line 41
      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)? Tk.encoding : Tk.encoding_system)

        unless f_enc
          f_enc = i_enc
        end

        ent = []
        cline = ''
        open(file, 'r') {|f|
          while line = f.gets
            #cline += line.chomp!
            cline.concat(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

read_file(file, pri=None)

Alias for readfile

read_with_encoding(file, f_enc=nil, pri=None)

[Source]

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

readfile(file, pri=None)

[Source]

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

[Validate]