Ruby-Language API Docs and Resources

    # File tk/variable.rb, line 45
45:   def TkVariable.callback(id, name1, name2, op)
46:     #name1,name2,op = tk_split_list(args)
47:     #name1,name2,op = tk_split_simplelist(args)
48:     if TkVar_CB_TBL[id]
49:       #_get_eval_string(TkVar_CB_TBL[name1].trace_callback(name2,op))
50:       begin
51:         _get_eval_string(TkVar_CB_TBL[id].trace_callback(name2, op))
52:       rescue SystemExit
53:         exit(0)
54:       rescue Interrupt
55:         exit!(1)
56:       rescue Exception => e
57:         begin
58:           msg = _toUTF8(e.class.inspect) + ': ' + 
59:                 _toUTF8(e.message) + "\n" + 
60:                 "\n---< backtrace of Ruby side >-----\n" + 
61:                 _toUTF8(e.backtrace.join("\n")) + 
62:                 "\n---< backtrace of Tk side >-------"
63:           msg.instance_variable_set(:@encoding, 'utf-8')
64:         rescue Exception
65:           msg = e.class.inspect + ': ' + e.message + "\n" + 
66:                 "\n---< backtrace of Ruby side >-----\n" + 
67:                 e.backtrace.join("\n") + 
68:                 "\n---< backtrace of Tk side >-------"
69:         end
70:         fail(e, msg)
71:       end
72: ??
73:     else
74:       ''
75:     end
76:   end

     # File tk/variable.rb, line 268
268:   def initialize(val="", type=nil)
269:     # @id = Tk_VARIABLE_ID.join('')
270:     @id = Tk_VARIABLE_ID.join(TkCore::INTERP._ip_id_)
271:     Tk_VARIABLE_ID[1].succ!
272:     TkVar_ID_TBL[@id] = self
273: 
274:     @var  = @id
275:     @elem = nil
276: 
277:     @def_default = false
278:     @default_val = nil
279: 
280:     @trace_var  = nil
281:     @trace_elem = nil
282:     @trace_opts = nil
283: 
284:     @type = nil
285:     var = self
286:     @element_type = Hash.new{|k,v| var.default_value_type }
287: 
288:     self.default_value_type = type
289: 
290:     begin
291:       INTERP._unset_global_var(@id)
292:     rescue
293:     end
294: 
295:     # teach Tk-ip that @id is global var
296:     INTERP._invoke_without_enc('global', @id)
297:     #INTERP._invoke('global', @id)
298: 
299:     # create and init
300:     if val.kind_of?(Hash)
301:       # assoc-array variable
302:       self[''] = 0
303:       self.clear
304:     end
305:     self.value = val
306: 
307: ??
308: ??
309:   end

    # File tk/variable.rb, line 92
92:   def self.new_hash(val = {})
93:     if val.kind_of?(Hash)
94:       self.new(val)
95:     else
96:       fail ArgumentError, 'Hash is expected'
97:     end
98:   end

      # File tk/variable.rb, line 1187
1187:   def %(other)
1188:     num_or_str(self._value) % other.to_i
1189:     #begin
1190:     #  number(self._value) % other
1191:     #rescue
1192:     #  self._value % other
1193:     #end
1194:   end

      # File tk/variable.rb, line 1141
1141:   def &(other)
1142:     if other.kind_of?(Array)
1143:       self.to_a & other.to_a
1144:     else
1145:       self.to_i & other.to_i
1146:     end
1147:   end

      # File tk/variable.rb, line 1176
1176:   def *(other)
1177:     num_or_str(self._value) * other.to_i
1178:     #begin
1179:     #  number(self._value) * other
1180:     #rescue
1181:     #  self._value * other
1182:     #end
1183:   end

      # File tk/variable.rb, line 1195
1195:   def **(other)
1196:     number(self._value) ** other
1197:   end

      # File tk/variable.rb, line 1155
1155:   def +(other)
1156:     case other
1157:     when Array
1158:       self.to_a + other
1159:     when String
1160:       self._value + other
1161:     else
1162:       begin
1163:         number(self._value) + other
1164:       rescue
1165:         self._value + other.to_s
1166:       end
1167:     end
1168:   end

      # File tk/variable.rb, line 1169
1169:   def -(other)
1170:     if other.kind_of?(Array)
1171:       self.to_a - other
1172:     else
1173:       number(self._value) - other
1174:     end
1175:   end

      # File tk/variable.rb, line 1184
1184:   def /(other)
1185:     number(self._value) / other
1186:   end

      # File tk/variable.rb, line 1233
1233:   def <=>(other)
1234:     if other.kind_of?(TkVariable)
1235:       begin
1236:         val = other.numeric
1237:         other = val
1238:       rescue
1239:         other = other._value
1240:       end
1241:     elsif other.kind_of?(Numeric)
1242:       begin
1243:         return self.numeric <=> other
1244:       rescue
1245:         return self._value <=> other.to_s
1246:       end
1247:     elsif other.kind_of?(Array)
1248:       return self.list <=> other
1249:     else
1250:       return self._value <=> other
1251:     end
1252:   end

      # File tk/variable.rb, line 1202
1202:   def ==(other)
1203:     case other
1204:     when TkVariable
1205:       #self.equal?(other)
1206:       self._value == other._value
1207:     when String
1208:       self.to_s == other
1209:     when Symbol
1210:       self.to_sym == other
1211:     when Integer
1212:       self.to_i == other
1213:     when Float
1214:       self.to_f == other
1215:     when Array
1216:       self.to_a == other
1217:     when Hash
1218:       # false if self is not an assoc array
1219:       self._value == other
1220:     else
1221:       # false
1222:       self._value == _get_eval_string(other)
1223:     end
1224:   end

      # File tk/variable.rb, line 1198
1198:   def =~(other)
1199:     self._value =~ other
1200:   end

     # File tk/variable.rb, line 672
672:   def [](*idxs)
673:     _to_default_element_type(idxs, _element_value(*idxs))
674:   end

     # File tk/variable.rb, line 516
516:   def []=(*args)
517:     val = args.pop
518:     type = default_element_value_type(args)
519:     val = val._value if !type && type != :variable && val.kind_of?(TkVariable)
520:     index = args.collect{|idx| _get_eval_string(idx, true)}.join(',')
521:     _fromUTF8(INTERP._set_global_var2(@id, index, _get_eval_string(val, true)))
522:     #_fromUTF8(INTERP._set_global_var2(@id, _toUTF8(_get_eval_string(index)), 
523:     #                                 _toUTF8(_get_eval_string(val))))
524:     #_fromUTF8(INTERP._set_global_var2(@id, _get_eval_string(index, true), 
525:     #                                 _get_eval_string(val, true)))
526:   end

     # File tk/variable.rb, line 633
633:   def []=(*args)
634:     val = args.pop
635:     type = default_element_value_type(args)
636:     val = val._value if !type && type != :variable && val.kind_of?(TkVariable)
637:     index = args.collect{|idx| _get_eval_string(idx)}.join(',')
638:     INTERP._eval(Kernel.format('global %s; set %s(%s) %s', @id, @id, 
639:                               index, _get_eval_string(val)))
640:     #INTERP._eval(Kernel.format('global %s; set %s(%s) %s', @id, @id, 
641:     #                          _get_eval_string(index), _get_eval_string(val)))
642:     #INTERP._eval(Kernel.format('set %s(%s) %s', @id, 
643:     #                          _get_eval_string(index), _get_eval_string(val)))
644:     #INTERP._eval('set ' + @id + '(' + _get_eval_string(index) + ') ' + 
645:     #            _get_eval_string(val))
646:   end

      # File tk/variable.rb, line 1385
1385:   def _trace_vinfo_for_element(elem)
1386:     if @elem
1387:       fail(RuntimeError, 
1388:            "invalid for a TkVariable which denotes an element of Tcl's array")
1389:     end
1390:     return [] unless @trace_elem
1391:     return [] unless @trace_elem[elem]
1392:     @trace_elem[elem].dup
1393:   end

     # File tk/variable.rb, line 753
753:   def bool
754:     TkComm.bool(_value)
755: ??
756:   end

     # File tk/variable.rb, line 765
765:   def bool_element(*idxs)
766:     TkComm.bool(_element_value(*idxs))
767:   end

     # File tk/variable.rb, line 429
429:   def clear
430:     if (is_scalar?)
431:       fail RuntimeError, 'cannot clear a scalar variable'
432:     end
433:     keys.each{|k| unset(k)}
434:     self
435:   end

      # File tk/variable.rb, line 1122
1122:   def coerce(other)
1123:     case other
1124:     when TkVariable
1125:       [other._value, self._value]
1126:     when String
1127:       [other, self.to_s]
1128:     when Symbol
1129:       [other, self.to_sym]
1130:     when Integer
1131:       [other, self.to_i]
1132:     when Float
1133:       [other, self.to_f]
1134:     when Array
1135:       [other, self.to_a]
1136:     else
1137:       [other, self._value]
1138:     end
1139:   end

     # File tk/variable.rb, line 134
134:   def default_element_value_type(idxs)
135:     if idxs.kind_of?(Array)
136:       index = idxs.collect{|idx| _get_eval_string(idx, true)}.join(',')
137:     else
138:       index = _get_eval_string(idxs, true)
139:     end
140:     @element_type[index]
141:   end

     # File tk/variable.rb, line 119
119:   def default_proc(cmd = Proc.new)
120:     @def_default = :proc
121:     @default_val = cmd
122:     self
123:   end

     # File tk/variable.rb, line 103
103:   def default_value(val=nil, &b)
104:     if b
105:       @def_default = :proc
106:       @default_val = proc(&b)
107:     else
108:       @def_default = :val
109:       @default_val = val
110:     end
111:     self
112:   end

     # File tk/variable.rb, line 131
131:   def default_value_type
132:     @type
133:   end

      # File tk/variable.rb, line 1069
1069:   def element_lappend(idxs, *elems)
1070:     if idxs.kind_of?(Array)
1071:       idxs = idxs.collect{|idx| _get_eval_string(idx, true)}.join(',')
1072:     end
1073:     tk_call('lappend', "#{@id}(#{idxs})", *elems)
1074:     self
1075:   end

      # File tk/variable.rb, line 1101
1101:   def element_lget_f(elem_idxs, idx)
1102:     number(element_lget(elem_idxs, idx)).to_f
1103:   end

      # File tk/variable.rb, line 1094
1094:   def element_lget_i(elem_idxs, idx)
1095:     number(element_lget(elem_idxs, idx)).to_i
1096:   end

      # File tk/variable.rb, line 1081
1081:   def element_lindex(elem_idxs, idx)
1082:     if elem_idxs.kind_of?(Array)
1083:       val = _element_value(*elem_idxs)
1084:     else
1085:       val = _element_value(elem_idxs)
1086:     end
1087:     tk_call('lindex', val, idx)
1088:   end

      # File tk/variable.rb, line 1109
1109:   def element_lset(elem_idxs, idx, val)
1110:     if elem_idxs.kind_of?(Array)
1111:       idxs = elem_idxs.collect{|i| _get_eval_string(i, true)}.join(',')
1112:     end
1113:     tk_call('lset', "#{@id}(#{idxs})", idx, val)
1114:     self
1115:   end

     # File tk/variable.rb, line 918
918:   def element_to_f(*idxs)
919:     number(_element_value(*idxs)).to_f
920:   end

     # File tk/variable.rb, line 911
911:   def element_to_i(*idxs)
912:     number(_element_value(*idxs)).to_i
913:   end

     # File tk/variable.rb, line 927
927:   def element_to_s(*idxs)
928:     _element_value(*idxs)
929:   end

     # File tk/variable.rb, line 963
963:   def element_to_sym(*idxs)
964:     _element_value(*idxs).intern
965:   end

     # File tk/variable.rb, line 374
374:   def eventloop_tkwait
375:     wait(false, true)
376:   end

     # File tk/variable.rb, line 365
365:   def eventloop_wait(check_root = false)
366:     wait(false, check_root)
367:   end

     # File tk/variable.rb, line 401
401:   def exist?(*elems)
402:     INTERP._invoke_without_enc('global', @id)
403:     if elems.empty?
404:       TkComm.bool(tk_call('info', 'exist', @id))
405:     else
406:       # array
407:       index = elems.collect{|idx| _get_eval_string(idx, true)}.join(',')
408:       TkComm.bool(tk_call('info', 'exist', "#{@id}")) && 
409:         TkComm.bool(tk_call('info', 'exist', "#{@id}(#{index})"))
410:     end
411:   end

     # File tk/variable.rb, line 381
381:   def id
382:     @id
383:   end

      # File tk/variable.rb, line 1117
1117:   def inspect
1118:     #Kernel.format "#<TkVariable: %s>", @id
1119:     '#<TkVariable: ' + @id + '>'
1120:   end

     # File tk/variable.rb, line 390
390:   def is_hash?
391:     #ITNERP._eval("global #{@id}; array exist #{@id}") == '1'
392:     INTERP._invoke_without_enc('global', @id)
393:     # INTERP._invoke_without_enc('array', 'exist', @id) == '1'
394:     TkComm.bool(INTERP._invoke_without_enc('array', 'exist', @id))
395:   end

     # File tk/variable.rb, line 397
397:   def is_scalar?
398:     ! is_hash?
399:   end

     # File tk/variable.rb, line 413
413:   def keys
414:     if (is_scalar?)
415:       fail RuntimeError, 'cannot get keys from a scalar variable'
416:     end
417:     #tk_split_simplelist(INTERP._eval("global #{@id}; array get #{@id}"))
418:     INTERP._invoke_without_enc('global', @id)
419:     #tk_split_simplelist(INTERP._fromUTF8(INTERP._invoke_without_enc('array', 'names', @id)))
420:     tk_split_simplelist(INTERP._invoke_without_enc('array', 'names', @id), 
421:                         false, true)
422:   end

      # File tk/variable.rb, line 1065
1065:   def lappend(*elems)
1066:     tk_call('lappend', @id, *elems)
1067:     self
1068:   end

      # File tk/variable.rb, line 1098
1098:   def lget_f(idx)
1099:     number(lget(idx)).to_f
1100:   end

      # File tk/variable.rb, line 1091
1091:   def lget_i(idx)
1092:     number(lget(idx)).to_i
1093:   end

      # File tk/variable.rb, line 1077
1077:   def lindex(idx)
1078:     tk_call('lindex', self._value, idx)
1079:   end

     # File tk/variable.rb, line 993
993:   def list
994:     #tk_split_list(value)
995:     tk_split_simplelist(_value)
996:   end

      # File tk/variable.rb, line 998
 998:   def list_element(*idxs)
 999:     tk_split_simplelist(_element_value(*idxs))
1000:   end

      # File tk/variable.rb, line 1105
1105:   def lset(idx, val)
1106:     tk_call('lset', @id, idx, val)
1107:     self
1108:   end

      # File tk/variable.rb, line 1229
1229:   def nonzero?
1230:     !(numeric.zero?)
1231:   end

     # File tk/variable.rb, line 708
708:   def numeric
709:     number(_value)
710:   end

     # File tk/variable.rb, line 711
711:   def numeric_element(*idxs)
712:     number(_element_value(*idxs))
713:   end

      # File tk/variable.rb, line 1003
1003:   def numlist
1004:     list.collect!{|val| number(val)}
1005:   end

      # File tk/variable.rb, line 1006
1006:   def numlist_element(*idxs)
1007:     list_element(*idxs).collect!{|val| number(val)}
1008:   end

     # File tk/variable.rb, line 877
877:   def procedure
878:     TkComm.procedure(self._value)
879:   end

     # File tk/variable.rb, line 880
880:   def procedure_element(*idxs)
881:     TkComm.procedure(_element_value(*idxs))
882:   end

     # File tk/variable.rb, line 385
385:   def ref(*idxs)
386:     # "#{@id}(#{idxs.collect{|idx| _get_eval_string(idx)}.join(',')})"
387:     TkVarAccess.new("#{@id}(#{idxs.collect{|idx| _get_eval_string(idx)}.join(',')})")
388:   end

     # File tk/variable.rb, line 768
768:   def set_bool(val)
769:     if ! val
770:       self.value = '0'
771:     else
772:       case val.to_s.downcase
773:       when 'false', '0', 'no', 'off'
774:         self.value = '0'
775:       else
776:         self.value = '1'
777:       end
778:     end
779:     self
780:   end

     # File tk/variable.rb, line 782
782:   def set_bool_element(idxs, val)
783:     if ! val
784:       val = '0'
785:     else
786:       case val.to_s.downcase
787:       when 'false', '0', 'no', 'off'
788:         val = '0'
789:       else
790:         val = '1'
791:       end
792:     end
793:     if idxs.kind_of?(Array)
794:       self[*idxs]=val
795:     else
796:       self[idxs]=val
797:     end
798:     self
799:   end

     # File tk/variable.rb, line 806
806:   def set_bool_element_type(idxs, val)
807:     self.set_default_element_value_type(idxs, :bool)
808:     self.set_bool_element(idxs, val)
809:   end

     # File tk/variable.rb, line 800
800:   def set_bool_type(val)
801:     @type = :bool
802:     self.bool=(val)
803:     self
804:   end

     # File tk/variable.rb, line 212
212:   def set_default_element_value_type(idxs, type)
213:     _set_default_value_type_core(type, idxs)
214:     self
215:   end

     # File tk/variable.rb, line 113
113:   def set_default_value(val)
114:     @def_default = :val
115:     @default_val = val
116:     self
117:   end

     # File tk/variable.rb, line 206
206:   def set_default_value_type(type)
207:     _set_default_value_type_core(type, nil)
208:     self
209:   end

     # File tk/variable.rb, line 681
681:   def set_element_value(idxs, val)
682:     if idxs.kind_of?(Array)
683:       self[*idxs]=val
684:     else
685:       self[idxs]=val
686:     end
687:     self
688:   end

     # File tk/variable.rb, line 698
698:   def set_element_value_type(idxs, val)
699:     self.set_default_element_value_type(idxs, val.class)
700:     if idxs.kind_of?(Array)
701:       self[*idxs]=val
702:     else
703:       self[idxs]=val
704:     end
705:     self
706:   end

      # File tk/variable.rb, line 1010
1010:   def set_list(val)
1011:     case val
1012:     when Array
1013:       self.value=(val)
1014:     when TkVariable
1015:       self.value=(val.list)
1016:     else
1017:       raise ArgumentError, "Array is expected"
1018:     end
1019:     self
1020:   end

      # File tk/variable.rb, line 1026
1026:   def set_list_element(idxs, val)
1027:     case val
1028:     when Array
1029:       val
1030:     when TkVariable
1031:       val = val.list
1032:     else
1033:       raise ArgumentError, "Array is expected"
1034:     end
1035:     if idxs.kind_of?(Array)
1036:       self[*idxs]=val
1037:     else
1038:       self[idxs]=val
1039:     end
1040:     self
1041:   end

      # File tk/variable.rb, line 1050
1050:   def set_list_element_type(idxs, val)
1051:     self.set_default_element_value_type(idxs, :list)
1052:     self.set_list_element(idxs, val)
1053:   end