2003-08-02 01:04:30 -04:00
|
|
|
#
|
2004-10-11 00:51:21 -04:00
|
|
|
# tk.rb - Tk interface module using tcltklib
|
|
|
|
# $Date$
|
|
|
|
# by Yukihiro Matsumoto <matz@netlab.jp>
|
1999-08-13 01:37:52 -04:00
|
|
|
|
|
|
|
# use Shigehiro's tcltklib
|
2004-05-01 12:09:54 -04:00
|
|
|
require 'tcltklib'
|
|
|
|
require 'tkutil'
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
# autoload
|
|
|
|
require 'tk/autoload'
|
|
|
|
|
|
|
|
class TclTkIp
|
|
|
|
# backup original (without encoding) _eval and _invoke
|
|
|
|
alias _eval_without_enc _eval
|
|
|
|
alias _invoke_without_enc _invoke
|
2004-05-21 16:45:27 -04:00
|
|
|
|
|
|
|
def _ip_id_
|
|
|
|
''
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
# define TkComm module (step 1: basic functions)
|
1999-08-13 01:37:52 -04:00
|
|
|
module TkComm
|
2004-05-01 12:09:54 -04:00
|
|
|
include TkUtil
|
|
|
|
extend TkUtil
|
|
|
|
|
2003-09-07 03:10:44 -04:00
|
|
|
WidgetClassNames = {}.taint
|
2004-07-14 21:18:57 -04:00
|
|
|
TkExtlibAutoloadModule = [].taint
|
1999-08-24 04:21:56 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
# None = Object.new ### --> definition is moved to TkUtil module
|
|
|
|
# def None.to_s
|
|
|
|
# 'None'
|
|
|
|
# end
|
|
|
|
# None.freeze
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2003-07-23 12:07:35 -04:00
|
|
|
#Tk_CMDTBL = {}
|
|
|
|
#Tk_WINDOWS = {}
|
2003-09-07 03:10:44 -04:00
|
|
|
Tk_IDs = ["00000".taint, "00000".taint].freeze # [0]-cmdid, [1]-winid
|
2003-06-18 15:46:20 -04:00
|
|
|
|
2003-07-23 12:07:35 -04:00
|
|
|
# for backward compatibility
|
|
|
|
Tk_CMDTBL = Object.new
|
|
|
|
def Tk_CMDTBL.method_missing(id, *args)
|
2004-05-21 16:45:27 -04:00
|
|
|
TkCore::INTERP.tk_cmd_tbl.__send__(id, *args)
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2003-08-29 04:34:14 -04:00
|
|
|
Tk_CMDTBL.freeze
|
2003-07-23 12:07:35 -04:00
|
|
|
Tk_WINDOWS = Object.new
|
|
|
|
def Tk_WINDOWS.method_missing(id, *args)
|
2004-05-21 16:45:27 -04:00
|
|
|
TkCore::INTERP.tk_windows.__send__(id, *args)
|
2003-06-21 04:47:22 -04:00
|
|
|
end
|
2003-08-29 04:34:14 -04:00
|
|
|
Tk_WINDOWS.freeze
|
|
|
|
|
|
|
|
self.instance_eval{
|
2003-09-07 03:10:44 -04:00
|
|
|
@cmdtbl = [].taint
|
2003-08-29 04:34:14 -04:00
|
|
|
}
|
2003-06-21 04:47:22 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
unless const_defined?(:GET_CONFIGINFO_AS_ARRAY)
|
|
|
|
# GET_CONFIGINFO_AS_ARRAY = false => returns a Hash { opt =>val, ... }
|
|
|
|
# true => returns an Array [[opt,val], ... ]
|
|
|
|
# val is a list which includes resource info.
|
|
|
|
GET_CONFIGINFO_AS_ARRAY = true
|
|
|
|
end
|
|
|
|
unless const_defined?(:GET_CONFIGINFOwoRES_AS_ARRAY)
|
|
|
|
# for configinfo without resource info; list of [opt, value] pair
|
|
|
|
# false => returns a Hash { opt=>val, ... }
|
|
|
|
# true => returns an Array [[opt,val], ... ]
|
|
|
|
GET_CONFIGINFOwoRES_AS_ARRAY = true
|
|
|
|
end
|
|
|
|
# *** ATTENTION ***
|
|
|
|
# 'current_configinfo' method always returns a Hash under all cases of above.
|
|
|
|
|
1999-08-13 01:37:52 -04:00
|
|
|
def error_at
|
|
|
|
frames = caller()
|
|
|
|
frames.delete_if do |c|
|
|
|
|
c =~ %r!/tk(|core|thcore|canvas|text|entry|scrollbox)\.rb:\d+!
|
|
|
|
end
|
|
|
|
frames
|
|
|
|
end
|
|
|
|
private :error_at
|
|
|
|
|
|
|
|
def _genobj_for_tkwidget(path)
|
|
|
|
return TkRoot.new if path == '.'
|
|
|
|
|
|
|
|
begin
|
2003-06-18 15:46:20 -04:00
|
|
|
#tk_class = TkCore::INTERP._invoke('winfo', 'class', path)
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_class = Tk.ip_invoke_without_enc('winfo', 'class', path)
|
1999-08-13 01:37:52 -04:00
|
|
|
rescue
|
|
|
|
return path
|
|
|
|
end
|
|
|
|
|
2003-07-01 18:08:19 -04:00
|
|
|
if ruby_class = WidgetClassNames[tk_class]
|
|
|
|
ruby_class_name = ruby_class.name
|
2003-07-31 03:59:18 -04:00
|
|
|
# gen_class_name = ruby_class_name + 'GeneratedOnTk'
|
|
|
|
gen_class_name = ruby_class_name
|
2003-07-01 18:08:19 -04:00
|
|
|
classname_def = ''
|
2004-07-14 21:18:57 -04:00
|
|
|
else # ruby_class == nil
|
|
|
|
mods = TkExtlibAutoloadModule.find_all{|m| m.const_defined?(tk_class)}
|
|
|
|
mods.each{|mod|
|
2004-10-11 00:51:21 -04:00
|
|
|
begin
|
|
|
|
mod.const_get(tk_class) # auto_load
|
|
|
|
break if (ruby_class = WidgetClassNames[tk_class])
|
|
|
|
rescue LoadError
|
|
|
|
# ignore load error
|
|
|
|
end
|
2004-07-14 21:18:57 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
unless ruby_class
|
2004-10-11 00:51:21 -04:00
|
|
|
std_class = 'Tk' << tk_class
|
|
|
|
if Object.const_defined?(std_class)
|
|
|
|
Object.const_get(std_class) # auto_load
|
|
|
|
ruby_class = WidgetClassNames[tk_class]
|
|
|
|
end
|
2004-07-14 21:18:57 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
if ruby_class
|
2004-10-11 00:51:21 -04:00
|
|
|
# found
|
|
|
|
ruby_class_name = ruby_class.name
|
|
|
|
gen_class_name = ruby_class_name
|
|
|
|
classname_def = ''
|
2004-07-14 21:18:57 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
# unknown
|
|
|
|
ruby_class_name = 'TkWindow'
|
|
|
|
gen_class_name = 'TkWidget_' + tk_class
|
|
|
|
classname_def = "WidgetClassName = '#{tk_class}'.freeze"
|
2004-07-14 21:18:57 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
###################################
|
|
|
|
=begin
|
|
|
|
if ruby_class = WidgetClassNames[tk_class]
|
|
|
|
ruby_class_name = ruby_class.name
|
2003-07-31 03:59:18 -04:00
|
|
|
# gen_class_name = ruby_class_name + 'GeneratedOnTk'
|
|
|
|
gen_class_name = ruby_class_name
|
2003-07-01 18:08:19 -04:00
|
|
|
classname_def = ''
|
|
|
|
else
|
2004-07-14 21:18:57 -04:00
|
|
|
mod = TkExtlibAutoloadModule.find{|m| m.const_defined?(tk_class)}
|
|
|
|
if mod
|
2004-10-11 00:51:21 -04:00
|
|
|
ruby_class_name = mod.name + '::' + tk_class
|
|
|
|
gen_class_name = ruby_class_name
|
|
|
|
classname_def = ''
|
2004-07-14 21:18:57 -04:00
|
|
|
elsif Object.const_defined?('Tk' + tk_class)
|
2004-10-11 00:51:21 -04:00
|
|
|
ruby_class_name = 'Tk' + tk_class
|
|
|
|
# gen_class_name = ruby_class_name + 'GeneratedOnTk'
|
|
|
|
gen_class_name = ruby_class_name
|
|
|
|
classname_def = ''
|
2004-07-14 21:18:57 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
ruby_class_name = 'TkWindow'
|
|
|
|
# gen_class_name = ruby_class_name + tk_class + 'GeneratedOnTk'
|
|
|
|
gen_class_name = 'TkWidget_' + tk_class
|
|
|
|
classname_def = "WidgetClassName = '#{tk_class}'.freeze"
|
2004-07-14 21:18:57 -04:00
|
|
|
end
|
2003-07-01 18:08:19 -04:00
|
|
|
end
|
2004-07-14 21:18:57 -04:00
|
|
|
=end
|
2004-07-01 05:38:48 -04:00
|
|
|
|
|
|
|
=begin
|
1999-08-13 01:37:52 -04:00
|
|
|
unless Object.const_defined? gen_class_name
|
2003-07-01 18:08:19 -04:00
|
|
|
Object.class_eval "class #{gen_class_name}<#{ruby_class_name}
|
|
|
|
#{classname_def}
|
|
|
|
end"
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2003-07-31 03:59:18 -04:00
|
|
|
Object.class_eval "#{gen_class_name}.new('widgetname'=>'#{path}',
|
|
|
|
'without_creating'=>true)"
|
2004-07-01 05:38:48 -04:00
|
|
|
=end
|
|
|
|
base = Object
|
|
|
|
gen_class_name.split('::').each{|klass|
|
|
|
|
next if klass == ''
|
|
|
|
if base.const_defined?(klass)
|
2004-10-11 00:51:21 -04:00
|
|
|
base = base.class_eval klass
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
base = base.class_eval "class #{klass}<#{ruby_class_name}
|
2004-07-01 05:38:48 -04:00
|
|
|
#{classname_def}
|
|
|
|
end
|
|
|
|
#{klass}"
|
|
|
|
end
|
|
|
|
}
|
|
|
|
base.class_eval "#{gen_class_name}.new('widgetname'=>'#{path}',
|
|
|
|
'without_creating'=>true)"
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
private :_genobj_for_tkwidget
|
2003-07-01 18:08:19 -04:00
|
|
|
module_function :_genobj_for_tkwidget
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-11-05 02:07:39 -05:00
|
|
|
def _at(x,y=nil)
|
|
|
|
if y
|
|
|
|
"@#{Integer(x)},#{Integer(y)}"
|
|
|
|
else
|
|
|
|
"@#{Integer(x)}"
|
|
|
|
end
|
2004-07-14 21:18:57 -04:00
|
|
|
end
|
|
|
|
module_function :_at
|
|
|
|
|
|
|
|
def tk_tcl2ruby(val, enc_mode = false, listobj = true)
|
2004-05-21 16:45:27 -04:00
|
|
|
if val =~ /^rb_out\S* (c(_\d+_)?\d+)/
|
2003-07-23 12:07:35 -04:00
|
|
|
#return Tk_CMDTBL[$1]
|
|
|
|
return TkCore::INTERP.tk_cmd_tbl[$1]
|
2004-05-01 12:09:54 -04:00
|
|
|
#cmd_obj = TkCore::INTERP.tk_cmd_tbl[$1]
|
|
|
|
#if cmd_obj.kind_of?(Proc) || cmd_obj.kind_of?(Method)
|
|
|
|
# cmd_obj
|
|
|
|
#else
|
|
|
|
# cmd_obj.cmd
|
|
|
|
#end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-02-11 09:31:33 -05:00
|
|
|
#if val.include? ?\s
|
|
|
|
# return val.split.collect{|v| tk_tcl2ruby(v)}
|
|
|
|
#end
|
1999-08-13 01:37:52 -04:00
|
|
|
case val
|
|
|
|
when /^@font/
|
|
|
|
TkFont.get_obj(val)
|
|
|
|
when /^-?\d+$/
|
|
|
|
val.to_i
|
|
|
|
when /^\./
|
2003-07-23 12:07:35 -04:00
|
|
|
#Tk_WINDOWS[val] ? Tk_WINDOWS[val] : _genobj_for_tkwidget(val)
|
|
|
|
TkCore::INTERP.tk_windows[val]?
|
|
|
|
TkCore::INTERP.tk_windows[val] : _genobj_for_tkwidget(val)
|
2004-05-21 16:45:27 -04:00
|
|
|
when /^i(_\d+_)?\d+$/
|
2003-06-18 15:46:20 -04:00
|
|
|
TkImage::Tk_IMGTBL[val]? TkImage::Tk_IMGTBL[val] : val
|
2004-02-11 09:31:33 -05:00
|
|
|
when /^-?\d+\.?\d*(e[-+]?\d+)?$/
|
|
|
|
val.to_f
|
|
|
|
when /\\ /
|
|
|
|
val.gsub(/\\ /, ' ')
|
2004-06-12 11:25:49 -04:00
|
|
|
when /[^\\] /
|
|
|
|
if listobj
|
2005-05-25 07:09:59 -04:00
|
|
|
#tk_split_escstr(val).collect{|elt|
|
|
|
|
# tk_tcl2ruby(elt, enc_mode, listobj)
|
|
|
|
#}
|
|
|
|
val = _toUTF8(val) unless enc_mode
|
|
|
|
tk_split_escstr(val, false, false).collect{|elt|
|
|
|
|
tk_tcl2ruby(elt, true, listobj)
|
2004-10-11 00:51:21 -04:00
|
|
|
}
|
2004-06-12 11:25:49 -04:00
|
|
|
elsif enc_mode
|
2004-10-11 00:51:21 -04:00
|
|
|
_fromUTF8(val)
|
2004-06-12 11:25:49 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
val
|
2004-06-12 11:25:49 -04:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
if enc_mode
|
2004-10-11 00:51:21 -04:00
|
|
|
_fromUTF8(val)
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
val
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
private :tk_tcl2ruby
|
2004-06-12 11:25:49 -04:00
|
|
|
module_function :tk_tcl2ruby
|
2004-07-14 21:18:57 -04:00
|
|
|
#private_class_method :tk_tcl2ruby
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
unless const_defined?(:USE_TCLs_LIST_FUNCTIONS)
|
|
|
|
USE_TCLs_LIST_FUNCTIONS = true
|
|
|
|
end
|
|
|
|
|
|
|
|
if USE_TCLs_LIST_FUNCTIONS
|
|
|
|
###########################################################################
|
|
|
|
# use Tcl function version of split_list
|
|
|
|
###########################################################################
|
|
|
|
|
2005-05-25 07:09:59 -04:00
|
|
|
def tk_split_escstr(str, src_enc=true, dst_enc=true)
|
|
|
|
str = _toUTF8(str) if src_enc
|
|
|
|
if dst_enc
|
|
|
|
TkCore::INTERP._split_tklist(str).map!{|s| _fromUTF8(s)}
|
|
|
|
else
|
|
|
|
TkCore::INTERP._split_tklist(str)
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
|
2005-05-25 07:09:59 -04:00
|
|
|
def tk_split_sublist(str, depth=-1, src_enc=true, dst_enc=true)
|
2004-06-12 11:25:49 -04:00
|
|
|
# return [] if str == ""
|
|
|
|
# list = TkCore::INTERP._split_tklist(str)
|
2005-05-25 07:09:59 -04:00
|
|
|
str = _toUTF8(str) if src_enc
|
|
|
|
|
2004-06-12 11:25:49 -04:00
|
|
|
if depth == 0
|
|
|
|
return "" if str == ""
|
|
|
|
list = [str]
|
|
|
|
else
|
|
|
|
return [] if str == ""
|
|
|
|
list = TkCore::INTERP._split_tklist(str)
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
if list.size == 1
|
2005-05-25 07:09:59 -04:00
|
|
|
# tk_tcl2ruby(list[0], nil, false)
|
|
|
|
tk_tcl2ruby(list[0], dst_enc, false)
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2005-05-25 07:09:59 -04:00
|
|
|
list.collect{|token| tk_split_sublist(token, depth - 1, false, dst_enc)}
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2005-05-25 07:09:59 -04:00
|
|
|
def tk_split_list(str, depth=0, src_enc=true, dst_enc=true)
|
2004-05-01 12:09:54 -04:00
|
|
|
return [] if str == ""
|
2005-05-25 07:09:59 -04:00
|
|
|
str = _toUTF8(str) if src_enc
|
|
|
|
TkCore::INTERP._split_tklist(str).map!{|token|
|
|
|
|
tk_split_sublist(token, depth - 1, false, dst_enc)
|
2004-06-12 11:25:49 -04:00
|
|
|
}
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
|
2005-05-25 07:09:59 -04:00
|
|
|
def tk_split_simplelist(str, src_enc=true, dst_enc=true)
|
2004-05-01 12:09:54 -04:00
|
|
|
#lst = TkCore::INTERP._split_tklist(str)
|
|
|
|
#if (lst.size == 1 && lst =~ /^\{.*\}$/)
|
|
|
|
# TkCore::INTERP._split_tklist(str[1..-2])
|
|
|
|
#else
|
|
|
|
# lst
|
|
|
|
#end
|
2005-05-25 07:09:59 -04:00
|
|
|
|
|
|
|
str = _toUTF8(str) if src_enc
|
|
|
|
if dst_enc
|
|
|
|
TkCore::INTERP._split_tklist(str).map!{|s| _fromUTF8(s)}
|
|
|
|
else
|
|
|
|
TkCore::INTERP._split_tklist(str)
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
|
2005-04-04 10:21:24 -04:00
|
|
|
def array2tk_list(ary, enc=nil)
|
2004-05-01 12:09:54 -04:00
|
|
|
return "" if ary.size == 0
|
|
|
|
|
|
|
|
dst = ary.collect{|e|
|
|
|
|
if e.kind_of? Array
|
2005-04-04 10:21:24 -04:00
|
|
|
array2tk_list(e, enc)
|
2004-05-01 12:09:54 -04:00
|
|
|
elsif e.kind_of? Hash
|
2004-10-11 00:51:21 -04:00
|
|
|
tmp_ary = []
|
|
|
|
#e.each{|k,v| tmp_ary << k << v }
|
|
|
|
e.each{|k,v| tmp_ary << "-#{_get_eval_string(k)}" << v }
|
2005-04-04 10:21:24 -04:00
|
|
|
array2tk_list(tmp_ary, enc)
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2005-04-04 10:21:24 -04:00
|
|
|
_get_eval_string(e, enc)
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
}
|
|
|
|
TkCore::INTERP._merge_tklist(*dst)
|
|
|
|
end
|
|
|
|
|
|
|
|
else
|
|
|
|
###########################################################################
|
|
|
|
# use Ruby script version of split_list (traditional methods)
|
|
|
|
###########################################################################
|
|
|
|
|
2005-05-25 07:09:59 -04:00
|
|
|
def tk_split_escstr(str, src_enc=true, dst_enc=true)
|
2004-02-11 09:31:33 -05:00
|
|
|
return [] if str == ""
|
|
|
|
list = []
|
|
|
|
token = nil
|
|
|
|
escape = false
|
|
|
|
brace = 0
|
|
|
|
str.split('').each {|c|
|
|
|
|
brace += 1 if c == '{' && !escape
|
|
|
|
brace -= 1 if c == '}' && !escape
|
|
|
|
if brace == 0 && c == ' ' && !escape
|
|
|
|
list << token.gsub(/^\{(.*)\}$/, '\1') if token
|
|
|
|
token = nil
|
|
|
|
else
|
|
|
|
token = (token || "") << c
|
|
|
|
end
|
2004-02-13 00:46:49 -05:00
|
|
|
escape = (c == '\\' && !escape)
|
2004-02-11 09:31:33 -05:00
|
|
|
}
|
|
|
|
list << token.gsub(/^\{(.*)\}$/, '\1') if token
|
2004-02-13 00:46:49 -05:00
|
|
|
list
|
|
|
|
end
|
2004-02-11 09:31:33 -05:00
|
|
|
|
2005-05-25 07:09:59 -04:00
|
|
|
def tk_split_sublist(str, depth=-1, src_enc=true, dst_enc=true)
|
2004-06-12 11:25:49 -04:00
|
|
|
#return [] if str == ""
|
|
|
|
#return [tk_split_sublist(str[1..-2])] if str =~ /^\{.*\}$/
|
|
|
|
#list = tk_split_escstr(str)
|
|
|
|
if depth == 0
|
|
|
|
return "" if str == ""
|
|
|
|
str = str[1..-2] if str =~ /^\{.*\}$/
|
|
|
|
list = [str]
|
|
|
|
else
|
|
|
|
return [] if str == []
|
|
|
|
return [tk_split_sublist(str[1..-2], depth - 1)] if str =~ /^\{.*\}$/
|
|
|
|
list = tk_split_escstr(str)
|
|
|
|
end
|
2004-02-11 09:31:33 -05:00
|
|
|
if list.size == 1
|
2004-06-12 11:25:49 -04:00
|
|
|
tk_tcl2ruby(list[0], nil, false)
|
2004-02-11 09:31:33 -05:00
|
|
|
else
|
2004-06-12 11:25:49 -04:00
|
|
|
list.collect{|token| tk_split_sublist(token, depth - 1)}
|
2004-02-11 09:31:33 -05:00
|
|
|
end
|
|
|
|
end
|
2004-02-13 00:46:49 -05:00
|
|
|
|
2005-05-25 07:09:59 -04:00
|
|
|
def tk_split_list(str, depth=0, src_enc=true, dst_enc=true)
|
2004-02-13 00:46:49 -05:00
|
|
|
return [] if str == ""
|
2005-05-25 07:09:59 -04:00
|
|
|
tk_split_escstr(str).collect{|token|
|
|
|
|
tk_split_sublist(token, depth - 1)
|
|
|
|
}
|
2004-02-13 00:46:49 -05:00
|
|
|
end
|
2004-02-11 09:31:33 -05:00
|
|
|
=begin
|
1999-08-13 01:37:52 -04:00
|
|
|
def tk_split_list(str)
|
|
|
|
return [] if str == ""
|
|
|
|
idx = str.index('{')
|
2001-10-29 00:07:26 -05:00
|
|
|
while idx and idx > 0 and str[idx-1] == ?\\
|
|
|
|
idx = str.index('{', idx+1)
|
|
|
|
end
|
2003-05-26 04:22:33 -04:00
|
|
|
unless idx
|
|
|
|
list = tk_tcl2ruby(str)
|
|
|
|
unless Array === list
|
|
|
|
list = [list]
|
|
|
|
end
|
|
|
|
return list
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
|
|
|
|
list = tk_tcl2ruby(str[0,idx])
|
|
|
|
list = [] if list == ""
|
|
|
|
str = str[idx+1..-1]
|
|
|
|
i = -1
|
2004-02-11 09:31:33 -05:00
|
|
|
escape = false
|
1999-08-13 01:37:52 -04:00
|
|
|
brace = 1
|
|
|
|
str.each_byte {|c|
|
|
|
|
i += 1
|
2004-02-11 09:31:33 -05:00
|
|
|
brace += 1 if c == ?{ && !escape
|
|
|
|
brace -= 1 if c == ?} && !escape
|
|
|
|
escape = (c == ?\\)
|
1999-08-13 01:37:52 -04:00
|
|
|
break if brace == 0
|
|
|
|
}
|
2003-05-26 04:22:33 -04:00
|
|
|
if str.size == i + 1
|
|
|
|
return tk_split_list(str[0, i])
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
if str[0, i] == ' '
|
|
|
|
list.push ' '
|
|
|
|
else
|
|
|
|
list.push tk_split_list(str[0, i])
|
|
|
|
end
|
|
|
|
list += tk_split_list(str[i+1..-1])
|
|
|
|
list
|
|
|
|
end
|
2004-02-11 09:31:33 -05:00
|
|
|
=end
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2005-05-25 07:09:59 -04:00
|
|
|
def tk_split_simplelist(str, src_enc=true, dst_enc=true)
|
2004-02-11 09:31:33 -05:00
|
|
|
return [] if str == ""
|
|
|
|
list = []
|
|
|
|
token = nil
|
|
|
|
escape = false
|
|
|
|
brace = 0
|
|
|
|
str.split('').each {|c|
|
|
|
|
if c == '\\' && !escape
|
|
|
|
escape = true
|
2004-02-13 00:46:49 -05:00
|
|
|
token = (token || "") << c if brace > 0
|
2004-10-11 00:51:21 -04:00
|
|
|
next
|
2004-02-11 09:31:33 -05:00
|
|
|
end
|
|
|
|
brace += 1 if c == '{' && !escape
|
|
|
|
brace -= 1 if c == '}' && !escape
|
|
|
|
if brace == 0 && c == ' ' && !escape
|
|
|
|
list << token.gsub(/^\{(.*)\}$/, '\1') if token
|
|
|
|
token = nil
|
|
|
|
else
|
|
|
|
token = (token || "") << c
|
|
|
|
end
|
|
|
|
escape = false
|
|
|
|
}
|
|
|
|
list << token.gsub(/^\{(.*)\}$/, '\1') if token
|
|
|
|
list
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2005-04-04 10:21:24 -04:00
|
|
|
def array2tk_list(ary, enc=nil)
|
2004-05-01 12:09:54 -04:00
|
|
|
ary.collect{|e|
|
|
|
|
if e.kind_of? Array
|
2005-04-04 10:21:24 -04:00
|
|
|
"{#{array2tk_list(e, enc)}}"
|
2004-05-01 12:09:54 -04:00
|
|
|
elsif e.kind_of? Hash
|
2004-10-11 00:51:21 -04:00
|
|
|
# "{#{e.to_a.collect{|ee| array2tk_list(ee)}.join(' ')}}"
|
|
|
|
e.each{|k,v| tmp_ary << "-#{_get_eval_string(k)}" << v }
|
2005-04-04 10:21:24 -04:00
|
|
|
array2tk_list(tmp_ary, enc)
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2005-04-04 10:21:24 -04:00
|
|
|
s = _get_eval_string(e, enc)
|
2004-10-11 00:51:21 -04:00
|
|
|
(s.index(/\s/) || s.size == 0)? "{#{s}}": s
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
}.join(" ")
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
private :tk_split_escstr, :tk_split_sublist
|
|
|
|
private :tk_split_list, :tk_split_simplelist
|
|
|
|
private :array2tk_list
|
|
|
|
|
|
|
|
module_function :tk_split_escstr, :tk_split_sublist
|
|
|
|
module_function :tk_split_list, :tk_split_simplelist
|
|
|
|
module_function :array2tk_list
|
2004-02-11 09:31:33 -05:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
private_class_method :tk_split_escstr, :tk_split_sublist
|
|
|
|
private_class_method :tk_split_list, :tk_split_simplelist
|
2005-03-26 08:58:11 -05:00
|
|
|
# private_class_method :array2tk_list
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
=begin
|
|
|
|
### --> definition is moved to TkUtil module
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
def _symbolkey2str(keys)
|
|
|
|
h = {}
|
|
|
|
keys.each{|key,value| h[key.to_s] = value}
|
|
|
|
h
|
|
|
|
end
|
|
|
|
private :_symbolkey2str
|
2004-05-01 12:09:54 -04:00
|
|
|
module_function :_symbolkey2str
|
|
|
|
=end
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
=begin
|
|
|
|
### --> definition is moved to TkUtil module
|
|
|
|
# def hash_kv(keys, enc_mode = nil, conf = [], flat = false)
|
|
|
|
def hash_kv(keys, enc_mode = nil, conf = nil)
|
|
|
|
# Hash {key=>val, key=>val, ... } or Array [ [key, val], [key, val], ... ]
|
|
|
|
# ==> Array ['-key', val, '-key', val, ... ]
|
|
|
|
dst = []
|
1999-08-13 01:37:52 -04:00
|
|
|
if keys and keys != None
|
2004-05-01 12:09:54 -04:00
|
|
|
keys.each{|k, v|
|
2004-10-11 00:51:21 -04:00
|
|
|
#dst.push("-#{k}")
|
|
|
|
dst.push('-' + k.to_s)
|
|
|
|
if v != None
|
|
|
|
# v = _get_eval_string(v, enc_mode) if (enc_mode || flat)
|
|
|
|
v = _get_eval_string(v, enc_mode) if enc_mode
|
|
|
|
dst.push(v)
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
}
|
|
|
|
end
|
|
|
|
if conf
|
|
|
|
conf + dst
|
|
|
|
else
|
|
|
|
dst
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
private :hash_kv
|
2003-07-29 04:05:30 -04:00
|
|
|
module_function :hash_kv
|
2004-05-01 12:09:54 -04:00
|
|
|
=end
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
=begin
|
|
|
|
### --> definition is moved to TkUtil module
|
1999-08-13 01:37:52 -04:00
|
|
|
def bool(val)
|
|
|
|
case val
|
|
|
|
when "1", 1, 'yes', 'true'
|
2003-06-18 15:46:20 -04:00
|
|
|
true
|
1999-08-13 01:37:52 -04:00
|
|
|
else
|
2003-06-18 15:46:20 -04:00
|
|
|
false
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
1999-08-13 01:37:52 -04:00
|
|
|
def number(val)
|
|
|
|
case val
|
|
|
|
when /^-?\d+$/
|
|
|
|
val.to_i
|
2003-06-18 15:46:20 -04:00
|
|
|
when /^-?\d+\.?\d*(e[-+]?\d+)?$/
|
1999-08-13 01:37:52 -04:00
|
|
|
val.to_f
|
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
fail(ArgumentError, "invalid value for Number:'#{val}'")
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
def string(val)
|
|
|
|
if val == "{}"
|
|
|
|
''
|
2004-02-11 09:31:33 -05:00
|
|
|
elsif val[0] == ?{ && val[-1] == ?}
|
1999-08-13 01:37:52 -04:00
|
|
|
val[1..-2]
|
|
|
|
else
|
|
|
|
val
|
|
|
|
end
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
def num_or_str(val)
|
|
|
|
begin
|
|
|
|
number(val)
|
|
|
|
rescue ArgumentError
|
|
|
|
string(val)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
=end
|
|
|
|
|
2005-05-25 07:09:59 -04:00
|
|
|
def list(val, depth=0, enc=true)
|
|
|
|
tk_split_list(val, depth, enc, enc)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2005-05-25 07:09:59 -04:00
|
|
|
def simplelist(val, src_enc=true, dst_enc=true)
|
|
|
|
tk_split_simplelist(val, src_enc, dst_enc)
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
def window(val)
|
2003-06-18 15:46:20 -04:00
|
|
|
if val =~ /^\./
|
2003-07-23 12:07:35 -04:00
|
|
|
#Tk_WINDOWS[val]? Tk_WINDOWS[val] : _genobj_for_tkwidget(val)
|
|
|
|
TkCore::INTERP.tk_windows[val]?
|
|
|
|
TkCore::INTERP.tk_windows[val] : _genobj_for_tkwidget(val)
|
2003-06-18 15:46:20 -04:00
|
|
|
else
|
|
|
|
nil
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
def image_obj(val)
|
2004-05-21 16:45:27 -04:00
|
|
|
if val =~ /^i(_\d+_)?\d+$/
|
2004-05-01 12:09:54 -04:00
|
|
|
TkImage::Tk_IMGTBL[val]? TkImage::Tk_IMGTBL[val] : val
|
|
|
|
else
|
|
|
|
val
|
|
|
|
end
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
def procedure(val)
|
2004-05-21 16:45:27 -04:00
|
|
|
if val =~ /^rb_out\S* (c(_\d+_)?\d+)/
|
2003-07-23 12:07:35 -04:00
|
|
|
#Tk_CMDTBL[$1]
|
2003-07-25 12:43:03 -04:00
|
|
|
#TkCore::INTERP.tk_cmd_tbl[$1]
|
|
|
|
TkCore::INTERP.tk_cmd_tbl[$1].cmd
|
1999-08-13 01:37:52 -04:00
|
|
|
else
|
2003-06-18 15:46:20 -04:00
|
|
|
#nil
|
|
|
|
val
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
end
|
2004-06-12 11:25:49 -04:00
|
|
|
private :bool, :number, :string, :num_or_str
|
|
|
|
private :list, :simplelist, :window, :procedure
|
|
|
|
module_function :bool, :number, :num_or_str, :string
|
|
|
|
module_function :list, :simplelist, :window, :image_obj, :procedure
|
2004-05-01 12:09:54 -04:00
|
|
|
|
2005-03-02 02:06:52 -05:00
|
|
|
def subst(str, *opts)
|
|
|
|
# opts := :nobackslashes | :nocommands | novariables
|
|
|
|
tk_call('subst',
|
|
|
|
*(opts.collect{|opt|
|
|
|
|
opt = opt.to_s
|
|
|
|
(opt[0] == ?-)? opt: '-' << opt
|
|
|
|
} << str))
|
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def _toUTF8(str, encoding = nil)
|
|
|
|
TkCore::INTERP._toUTF8(str, encoding)
|
|
|
|
end
|
|
|
|
def _fromUTF8(str, encoding = nil)
|
|
|
|
TkCore::INTERP._fromUTF8(str, encoding)
|
|
|
|
end
|
|
|
|
private :_toUTF8, :_fromUTF8
|
|
|
|
module_function :_toUTF8, :_fromUTF8
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2005-03-26 08:58:11 -05:00
|
|
|
def _callback_entry_class?(cls)
|
|
|
|
cls <= Proc || cls <= Method || cls <= TkCallbackEntry
|
|
|
|
end
|
|
|
|
private :_callback_entry_class?
|
|
|
|
module_function :_callback_entry_class?
|
|
|
|
|
2004-12-16 02:13:14 -05:00
|
|
|
def _callback_entry?(obj)
|
|
|
|
obj.kind_of?(Proc) || obj.kind_of?(Method) || obj.kind_of?(TkCallbackEntry)
|
|
|
|
end
|
|
|
|
private :_callback_entry?
|
|
|
|
module_function :_callback_entry?
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
=begin
|
|
|
|
### --> definition is moved to TkUtil module
|
|
|
|
def _get_eval_string(str, enc_mode = nil)
|
1999-08-13 01:37:52 -04:00
|
|
|
return nil if str == None
|
2004-05-01 12:09:54 -04:00
|
|
|
if str.kind_of?(TkObject)
|
|
|
|
str = str.path
|
|
|
|
elsif str.kind_of?(String)
|
|
|
|
str = _toUTF8(str) if enc_mode
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
elsif str.kind_of?(Symbol)
|
|
|
|
str = str.id2name
|
2004-05-01 12:09:54 -04:00
|
|
|
str = _toUTF8(str) if enc_mode
|
2000-01-31 22:12:21 -05:00
|
|
|
elsif str.kind_of?(Hash)
|
2004-05-01 12:09:54 -04:00
|
|
|
str = hash_kv(str, enc_mode).join(" ")
|
1999-08-13 01:37:52 -04:00
|
|
|
elsif str.kind_of?(Array)
|
|
|
|
str = array2tk_list(str)
|
2004-05-01 12:09:54 -04:00
|
|
|
str = _toUTF8(str) if enc_mode
|
1999-08-13 01:37:52 -04:00
|
|
|
elsif str.kind_of?(Proc)
|
|
|
|
str = install_cmd(str)
|
|
|
|
elsif str == nil
|
|
|
|
str = ""
|
|
|
|
elsif str == false
|
|
|
|
str = "0"
|
|
|
|
elsif str == true
|
|
|
|
str = "1"
|
|
|
|
elsif (str.respond_to?(:to_eval))
|
|
|
|
str = str.to_eval()
|
2004-05-01 12:09:54 -04:00
|
|
|
str = _toUTF8(str) if enc_mode
|
1999-08-13 01:37:52 -04:00
|
|
|
else
|
2003-06-18 15:46:20 -04:00
|
|
|
str = str.to_s() || ''
|
|
|
|
unless str.kind_of? String
|
2004-10-11 00:51:21 -04:00
|
|
|
fail RuntimeError, "fail to convert the object to a string"
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
str = _toUTF8(str) if enc_mode
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
return str
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
=end
|
|
|
|
=begin
|
|
|
|
def _get_eval_string(obj, enc_mode = nil)
|
|
|
|
case obj
|
|
|
|
when Numeric
|
|
|
|
obj.to_s
|
|
|
|
when String
|
|
|
|
(enc_mode)? _toUTF8(obj): obj
|
|
|
|
when Symbol
|
|
|
|
(enc_mode)? _toUTF8(obj.id2name): obj.id2name
|
|
|
|
when TkObject
|
|
|
|
obj.path
|
|
|
|
when Hash
|
|
|
|
hash_kv(obj, enc_mode).join(' ')
|
|
|
|
when Array
|
|
|
|
(enc_mode)? _toUTF8(array2tk_list(obj)): array2tk_list(obj)
|
|
|
|
when Proc, Method, TkCallbackEntry
|
|
|
|
install_cmd(obj)
|
|
|
|
when false
|
|
|
|
'0'
|
|
|
|
when true
|
|
|
|
'1'
|
|
|
|
when nil
|
|
|
|
''
|
|
|
|
when None
|
|
|
|
nil
|
|
|
|
else
|
|
|
|
if (obj.respond_to?(:to_eval))
|
2004-10-11 00:51:21 -04:00
|
|
|
(enc_mode)? _toUTF8(obj.to_eval): obj.to_eval
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
begin
|
|
|
|
obj = obj.to_s || ''
|
|
|
|
rescue
|
|
|
|
fail RuntimeError, "fail to convert object '#{obj}' to string"
|
|
|
|
end
|
|
|
|
(enc_mode)? _toUTF8(obj): obj
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
private :_get_eval_string
|
2003-07-25 12:43:03 -04:00
|
|
|
module_function :_get_eval_string
|
2004-05-01 12:09:54 -04:00
|
|
|
=end
|
|
|
|
|
|
|
|
=begin
|
|
|
|
### --> definition is moved to TkUtil module
|
|
|
|
def _get_eval_enc_str(obj)
|
|
|
|
return obj if obj == None
|
|
|
|
_get_eval_string(obj, true)
|
|
|
|
end
|
|
|
|
private :_get_eval_enc_str
|
|
|
|
module_function :_get_eval_enc_str
|
|
|
|
=end
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
=begin
|
|
|
|
### --> obsolete
|
|
|
|
def ruby2tcl(v, enc_mode = nil)
|
2000-07-14 00:34:43 -04:00
|
|
|
if v.kind_of?(Hash)
|
|
|
|
v = hash_kv(v)
|
|
|
|
v.flatten!
|
2004-05-01 12:09:54 -04:00
|
|
|
v.collect{|e|ruby2tcl(e, enc_mode)}
|
2000-07-14 00:34:43 -04:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
_get_eval_string(v, enc_mode)
|
2000-07-14 00:34:43 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
private :ruby2tcl
|
2004-05-01 12:09:54 -04:00
|
|
|
=end
|
|
|
|
|
|
|
|
=begin
|
|
|
|
### --> definition is moved to TkUtil module
|
|
|
|
def _conv_args(args, enc_mode, *src_args)
|
|
|
|
conv_args = []
|
|
|
|
src_args.each{|arg|
|
|
|
|
conv_args << _get_eval_string(arg, enc_mode) unless arg == None
|
|
|
|
# if arg.kind_of?(Hash)
|
|
|
|
# arg.each{|k, v|
|
|
|
|
# args << '-' + k.to_s
|
|
|
|
# args << _get_eval_string(v, enc_mode)
|
|
|
|
# }
|
|
|
|
# elsif arg != None
|
|
|
|
# args << _get_eval_string(arg, enc_mode)
|
|
|
|
# end
|
|
|
|
}
|
|
|
|
args + conv_args
|
|
|
|
end
|
|
|
|
private :_conv_args
|
|
|
|
=end
|
2000-07-14 00:34:43 -04:00
|
|
|
|
1999-08-13 01:37:52 -04:00
|
|
|
def _curr_cmd_id
|
2003-07-23 12:07:35 -04:00
|
|
|
#id = format("c%.4d", Tk_IDs[0])
|
2004-05-21 16:45:27 -04:00
|
|
|
id = "c" + TkCore::INTERP._ip_id_ + TkComm::Tk_IDs[0]
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
def _next_cmd_id
|
|
|
|
id = _curr_cmd_id
|
2003-07-23 12:07:35 -04:00
|
|
|
#Tk_IDs[0] += 1
|
2003-07-29 04:05:30 -04:00
|
|
|
TkComm::Tk_IDs[0].succ!
|
1999-08-13 01:37:52 -04:00
|
|
|
id
|
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
private :_curr_cmd_id, :_next_cmd_id
|
2003-07-29 04:05:30 -04:00
|
|
|
module_function :_curr_cmd_id, :_next_cmd_id
|
2003-06-18 15:46:20 -04:00
|
|
|
|
1999-08-13 01:37:52 -04:00
|
|
|
def install_cmd(cmd)
|
|
|
|
return '' if cmd == ''
|
|
|
|
id = _next_cmd_id
|
2003-07-23 12:07:35 -04:00
|
|
|
#Tk_CMDTBL[id] = cmd
|
2004-05-01 12:09:54 -04:00
|
|
|
if cmd.kind_of?(TkCallbackEntry)
|
|
|
|
TkCore::INTERP.tk_cmd_tbl[id] = cmd
|
|
|
|
else
|
|
|
|
TkCore::INTERP.tk_cmd_tbl[id] = TkCore::INTERP.get_cb_entry(cmd)
|
|
|
|
end
|
2003-07-17 01:23:54 -04:00
|
|
|
@cmdtbl = [] unless defined? @cmdtbl
|
2003-09-07 03:10:44 -04:00
|
|
|
@cmdtbl.taint unless @cmdtbl.tainted?
|
1999-08-13 01:37:52 -04:00
|
|
|
@cmdtbl.push id
|
2004-05-01 12:09:54 -04:00
|
|
|
#return Kernel.format("rb_out %s", id);
|
2004-05-21 16:45:27 -04:00
|
|
|
return 'rb_out' + TkCore::INTERP._ip_id_ + ' ' + id
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
def uninstall_cmd(id)
|
2004-05-21 16:45:27 -04:00
|
|
|
id = $1 if /rb_out\S* (c(_\d+_)?\d+)/ =~ id
|
2003-07-23 12:07:35 -04:00
|
|
|
#Tk_CMDTBL.delete(id)
|
|
|
|
TkCore::INTERP.tk_cmd_tbl.delete(id)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
# private :install_cmd, :uninstall_cmd
|
|
|
|
module_function :install_cmd, :uninstall_cmd
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
=begin
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
def install_win(ppath,name=nil)
|
|
|
|
if !name or name == ''
|
2003-07-23 12:07:35 -04:00
|
|
|
#name = format("w%.4d", Tk_IDs[1])
|
|
|
|
#Tk_IDs[1] += 1
|
|
|
|
name = "w" + Tk_IDs[1]
|
|
|
|
Tk_IDs[1].succ!
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
end
|
2003-06-12 18:13:13 -04:00
|
|
|
if name[0] == ?.
|
|
|
|
@path = name.dup
|
|
|
|
elsif !ppath or ppath == "."
|
2003-12-02 23:55:07 -05:00
|
|
|
@path = Kernel.format(".%s", name);
|
1999-08-13 01:37:52 -04:00
|
|
|
else
|
2003-12-02 23:55:07 -05:00
|
|
|
@path = Kernel.format("%s.%s", ppath, name)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2003-07-23 12:07:35 -04:00
|
|
|
#Tk_WINDOWS[@path] = self
|
|
|
|
TkCore::INTERP.tk_windows[@path] = self
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
=end
|
|
|
|
def install_win(ppath,name=nil)
|
|
|
|
if name
|
|
|
|
if name == ''
|
2004-10-11 00:51:21 -04:00
|
|
|
raise ArgumentError, "invalid wiget-name '#{name}'"
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
if name[0] == ?.
|
2004-10-11 00:51:21 -04:00
|
|
|
@path = '' + name
|
|
|
|
@path.freeze
|
|
|
|
return TkCore::INTERP.tk_windows[@path] = self
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
else
|
2004-05-21 16:45:27 -04:00
|
|
|
name = "w" + TkCore::INTERP._ip_id_ + Tk_IDs[1]
|
2004-05-01 12:09:54 -04:00
|
|
|
Tk_IDs[1].succ!
|
|
|
|
end
|
|
|
|
if !ppath or ppath == '.'
|
|
|
|
@path = '.' + name
|
|
|
|
else
|
|
|
|
@path = ppath + '.' + name
|
|
|
|
end
|
|
|
|
@path.freeze
|
|
|
|
TkCore::INTERP.tk_windows[@path] = self
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
|
|
|
|
def uninstall_win()
|
2003-07-23 12:07:35 -04:00
|
|
|
#Tk_WINDOWS.delete(@path)
|
|
|
|
TkCore::INTERP.tk_windows.delete(@path)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
private :install_win, :uninstall_win
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def _epath(win)
|
|
|
|
if win.kind_of?(TkObject)
|
|
|
|
win.epath
|
|
|
|
elsif win.respond_to?(:epath)
|
|
|
|
win.epath
|
1999-08-13 01:37:52 -04:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
win
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
private :_epath
|
|
|
|
end
|
|
|
|
|
|
|
|
# define TkComm module (step 2: event binding)
|
|
|
|
module TkComm
|
|
|
|
include TkEvent
|
|
|
|
extend TkEvent
|
1999-08-13 01:37:52 -04:00
|
|
|
|
|
|
|
def tk_event_sequence(context)
|
|
|
|
if context.kind_of? TkVirtualEvent
|
|
|
|
context = context.path
|
|
|
|
end
|
|
|
|
if context.kind_of? Array
|
|
|
|
context = context.collect{|ev|
|
2004-10-11 00:51:21 -04:00
|
|
|
if ev.kind_of? TkVirtualEvent
|
|
|
|
ev.path
|
|
|
|
else
|
|
|
|
ev
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
}.join("><")
|
|
|
|
end
|
|
|
|
if /,/ =~ context
|
|
|
|
context = context.split(/\s*,\s*/).join("><")
|
|
|
|
else
|
|
|
|
context
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2004-11-07 09:53:02 -05:00
|
|
|
def _bind_core(mode, what, context, cmd, *args)
|
|
|
|
id = install_bind(cmd, *args) if cmd
|
1999-08-13 01:37:52 -04:00
|
|
|
begin
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call_without_enc(*(what + ["<#{tk_event_sequence(context)}>",
|
2004-10-11 00:51:21 -04:00
|
|
|
mode + id]))
|
1999-08-13 01:37:52 -04:00
|
|
|
rescue
|
1999-08-24 04:21:56 -04:00
|
|
|
uninstall_cmd(id) if cmd
|
1999-08-13 01:37:52 -04:00
|
|
|
fail
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2004-11-07 09:53:02 -05:00
|
|
|
def _bind(what, context, cmd, *args)
|
|
|
|
_bind_core('', what, context, cmd, *args)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2004-11-07 09:53:02 -05:00
|
|
|
def _bind_append(what, context, cmd, *args)
|
|
|
|
_bind_core('+', what, context, cmd, *args)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2000-04-10 01:57:37 -04:00
|
|
|
def _bind_remove(what, context)
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call_without_enc(*(what + ["<#{tk_event_sequence(context)}>", '']))
|
2000-04-10 01:57:37 -04:00
|
|
|
end
|
|
|
|
|
1999-08-24 04:21:56 -04:00
|
|
|
def _bindinfo(what, context=nil)
|
1999-08-13 01:37:52 -04:00
|
|
|
if context
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call_without_enc(*what+["<#{tk_event_sequence(context)}>"]) .collect {|cmdline|
|
2004-10-11 00:51:21 -04:00
|
|
|
if cmdline =~ /^rb_out\S* (c(?:_\d+_)?\d+)\s+(.*)$/
|
|
|
|
#[Tk_CMDTBL[$1], $2]
|
|
|
|
[TkCore::INTERP.tk_cmd_tbl[$1], $2]
|
|
|
|
else
|
|
|
|
cmdline
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
}
|
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_split_simplelist(tk_call_without_enc(*what)).collect!{|seq|
|
2004-10-11 00:51:21 -04:00
|
|
|
l = seq.scan(/<*[^<>]+>*/).collect!{|subseq|
|
|
|
|
case (subseq)
|
|
|
|
when /^<<[^<>]+>>$/
|
|
|
|
TkVirtualEvent.getobj(subseq[1..-2])
|
|
|
|
when /^<[^<>]+>$/
|
|
|
|
subseq[1..-2]
|
|
|
|
else
|
|
|
|
subseq.split('')
|
|
|
|
end
|
|
|
|
}.flatten
|
|
|
|
(l.size == 1) ? l[0] : l
|
1999-08-13 01:37:52 -04:00
|
|
|
}
|
|
|
|
end
|
|
|
|
end
|
2004-07-06 05:42:12 -04:00
|
|
|
|
2004-11-07 09:53:02 -05:00
|
|
|
def _bind_core_for_event_class(klass, mode, what, context, cmd, *args)
|
|
|
|
id = install_bind_for_event_class(klass, cmd, *args) if cmd
|
2004-07-06 05:42:12 -04:00
|
|
|
begin
|
|
|
|
tk_call_without_enc(*(what + ["<#{tk_event_sequence(context)}>",
|
2004-10-11 00:51:21 -04:00
|
|
|
mode + id]))
|
2004-07-06 05:42:12 -04:00
|
|
|
rescue
|
|
|
|
uninstall_cmd(id) if cmd
|
|
|
|
fail
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2004-11-07 09:53:02 -05:00
|
|
|
def _bind_for_event_class(klass, what, context, cmd, *args)
|
|
|
|
_bind_core_for_event_class(klass, '', what, context, cmd, *args)
|
2004-07-06 05:42:12 -04:00
|
|
|
end
|
|
|
|
|
2004-11-07 09:53:02 -05:00
|
|
|
def _bind_append_for_event_class(klass, what, context, cmd, *args)
|
|
|
|
_bind_core_for_event_class(klass, '+', what, context, cmd, *args)
|
2004-07-06 05:42:12 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def _bind_remove_for_event_class(klass, what, context)
|
|
|
|
_bind_remove(what, context)
|
|
|
|
end
|
|
|
|
|
|
|
|
def _bindinfo_for_event_class(klass, what, context=nil)
|
|
|
|
_bindinfo(what, context)
|
|
|
|
end
|
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
private :tk_event_sequence
|
|
|
|
private :_bind_core, :_bind, :_bind_append, :_bind_remove, :_bindinfo
|
2004-07-06 05:42:12 -04:00
|
|
|
private :_bind_core_for_event_class, :_bind_for_event_class,
|
|
|
|
:_bind_append_for_event_class, :_bind_remove_for_event_class,
|
|
|
|
:_bindinfo_for_event_class
|
2000-01-17 03:37:53 -05:00
|
|
|
|
2004-12-08 13:14:15 -05:00
|
|
|
#def bind(tagOrClass, context, cmd=Proc.new, *args)
|
|
|
|
# _bind(["bind", tagOrClass], context, cmd, *args)
|
|
|
|
# tagOrClass
|
|
|
|
#end
|
|
|
|
def bind(tagOrClass, context, *args)
|
2004-12-16 02:13:14 -05:00
|
|
|
# if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
|
2005-01-25 00:09:22 -05:00
|
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
2004-12-08 13:14:15 -05:00
|
|
|
cmd = args.shift
|
|
|
|
else
|
|
|
|
cmd = Proc.new
|
|
|
|
end
|
2004-11-07 09:53:02 -05:00
|
|
|
_bind(["bind", tagOrClass], context, cmd, *args)
|
2003-06-18 15:46:20 -04:00
|
|
|
tagOrClass
|
2000-01-17 03:37:53 -05:00
|
|
|
end
|
|
|
|
|
2004-12-08 13:14:15 -05:00
|
|
|
#def bind_append(tagOrClass, context, cmd=Proc.new, *args)
|
|
|
|
# _bind_append(["bind", tagOrClass], context, cmd, *args)
|
|
|
|
# tagOrClass
|
|
|
|
#end
|
|
|
|
def bind_append(tagOrClass, context, *args)
|
2004-12-16 02:13:14 -05:00
|
|
|
# if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
|
2005-01-25 00:09:22 -05:00
|
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
2004-12-08 13:14:15 -05:00
|
|
|
cmd = args.shift
|
|
|
|
else
|
|
|
|
cmd = Proc.new
|
|
|
|
end
|
2004-11-07 09:53:02 -05:00
|
|
|
_bind_append(["bind", tagOrClass], context, cmd, *args)
|
2003-06-18 15:46:20 -04:00
|
|
|
tagOrClass
|
2000-01-17 03:37:53 -05:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2000-04-10 01:57:37 -04:00
|
|
|
def bind_remove(tagOrClass, context)
|
|
|
|
_bind_remove(['bind', tagOrClass], context)
|
2003-06-18 15:46:20 -04:00
|
|
|
tagOrClass
|
2000-04-10 01:57:37 -04:00
|
|
|
end
|
|
|
|
|
1999-08-13 01:37:52 -04:00
|
|
|
def bindinfo(tagOrClass, context=nil)
|
1999-08-24 04:21:56 -04:00
|
|
|
_bindinfo(['bind', tagOrClass], context)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2004-12-08 13:14:15 -05:00
|
|
|
#def bind_all(context, cmd=Proc.new, *args)
|
|
|
|
# _bind(['bind', 'all'], context, cmd, *args)
|
|
|
|
# TkBindTag::ALL
|
|
|
|
#end
|
|
|
|
def bind_all(context, *args)
|
2004-12-16 02:13:14 -05:00
|
|
|
# if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
|
2005-01-25 00:09:22 -05:00
|
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
2004-12-08 13:14:15 -05:00
|
|
|
cmd = args.shift
|
|
|
|
else
|
|
|
|
cmd = Proc.new
|
|
|
|
end
|
2004-11-07 09:53:02 -05:00
|
|
|
_bind(['bind', 'all'], context, cmd, *args)
|
2003-06-18 15:46:20 -04:00
|
|
|
TkBindTag::ALL
|
2000-01-17 03:37:53 -05:00
|
|
|
end
|
|
|
|
|
2004-12-08 13:14:15 -05:00
|
|
|
#def bind_append_all(context, cmd=Proc.new, *args)
|
|
|
|
# _bind_append(['bind', 'all'], context, cmd, *args)
|
|
|
|
# TkBindTag::ALL
|
|
|
|
#end
|
|
|
|
def bind_append_all(context, *args)
|
2004-12-16 02:13:14 -05:00
|
|
|
# if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
|
2005-01-25 00:09:22 -05:00
|
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
2004-12-08 13:14:15 -05:00
|
|
|
cmd = args.shift
|
|
|
|
else
|
|
|
|
cmd = Proc.new
|
|
|
|
end
|
2004-11-07 09:53:02 -05:00
|
|
|
_bind_append(['bind', 'all'], context, cmd, *args)
|
2003-06-18 15:46:20 -04:00
|
|
|
TkBindTag::ALL
|
|
|
|
end
|
|
|
|
|
|
|
|
def bind_remove_all(context)
|
|
|
|
_bind_remove(['bind', 'all'], context)
|
|
|
|
TkBindTag::ALL
|
2000-01-17 03:37:53 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def bindinfo_all(context=nil)
|
|
|
|
_bindinfo(['bind', 'all'], context)
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
|
1999-08-13 01:37:52 -04:00
|
|
|
module TkCore
|
|
|
|
include TkComm
|
|
|
|
extend TkComm
|
|
|
|
|
2003-07-23 12:07:35 -04:00
|
|
|
unless self.const_defined? :INTERP
|
|
|
|
if self.const_defined? :IP_NAME
|
|
|
|
name = IP_NAME.to_s
|
|
|
|
else
|
2004-01-13 02:52:03 -05:00
|
|
|
#name = nil
|
|
|
|
name = $0
|
2003-07-23 12:07:35 -04:00
|
|
|
end
|
|
|
|
if self.const_defined? :IP_OPTS
|
|
|
|
if IP_OPTS.kind_of?(Hash)
|
2004-10-11 00:51:21 -04:00
|
|
|
opts = hash_kv(IP_OPTS).join(' ')
|
2003-07-23 12:07:35 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
opts = IP_OPTS.to_s
|
2003-07-23 12:07:35 -04:00
|
|
|
end
|
|
|
|
else
|
|
|
|
opts = ''
|
|
|
|
end
|
|
|
|
|
|
|
|
INTERP = TclTkIp.new(name, opts)
|
|
|
|
|
2003-07-25 12:43:03 -04:00
|
|
|
def INTERP.__getip
|
|
|
|
self
|
2003-07-23 12:07:35 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
INTERP.instance_eval{
|
2003-09-07 03:10:44 -04:00
|
|
|
@tk_cmd_tbl = {}.taint
|
|
|
|
@tk_windows = {}.taint
|
2003-07-23 12:07:35 -04:00
|
|
|
|
2003-09-07 03:10:44 -04:00
|
|
|
@tk_table_list = [].taint
|
2003-07-23 12:07:35 -04:00
|
|
|
|
2003-09-07 03:10:44 -04:00
|
|
|
@init_ip_env = [].taint # table of Procs
|
|
|
|
@add_tk_procs = [].taint # table of [name, args, body]
|
2003-07-25 12:43:03 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
@cb_entry_class = Class.new(TkCallbackEntry){|c|
|
2004-10-11 00:51:21 -04:00
|
|
|
class << c
|
|
|
|
def inspect
|
|
|
|
sprintf("#<Class(TkCallbackEntry):%0x>", self.__id__)
|
|
|
|
end
|
|
|
|
alias to_s inspect
|
|
|
|
end
|
|
|
|
|
|
|
|
def initialize(ip, cmd)
|
|
|
|
@ip = ip
|
|
|
|
@cmd = cmd
|
|
|
|
end
|
|
|
|
attr_reader :ip, :cmd
|
|
|
|
def call(*args)
|
|
|
|
@ip.cb_eval(@cmd, *args)
|
|
|
|
end
|
|
|
|
def inspect
|
|
|
|
sprintf("#<cb_entry:%0x>", self.__id__)
|
|
|
|
end
|
|
|
|
alias to_s inspect
|
2004-05-01 12:09:54 -04:00
|
|
|
}.freeze
|
2003-07-23 12:07:35 -04:00
|
|
|
}
|
2003-07-25 12:43:03 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def INTERP.cb_entry_class
|
|
|
|
@cb_entry_class
|
|
|
|
end
|
2003-07-23 12:07:35 -04:00
|
|
|
def INTERP.tk_cmd_tbl
|
|
|
|
@tk_cmd_tbl
|
|
|
|
end
|
|
|
|
def INTERP.tk_windows
|
|
|
|
@tk_windows
|
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
class Tk_OBJECT_TABLE
|
|
|
|
def initialize(id)
|
2004-10-11 00:51:21 -04:00
|
|
|
@id = id
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
def method_missing(m, *args, &b)
|
2004-10-11 00:51:21 -04:00
|
|
|
TkCore::INTERP.tk_object_table(@id).__send__(m, *args, &b)
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2003-07-23 12:07:35 -04:00
|
|
|
def INTERP.tk_object_table(id)
|
|
|
|
@tk_table_list[id]
|
|
|
|
end
|
|
|
|
def INTERP.create_table
|
|
|
|
id = @tk_table_list.size
|
2003-09-07 03:10:44 -04:00
|
|
|
(tbl = {}).tainted? || tbl.taint
|
|
|
|
@tk_table_list << tbl
|
2004-05-01 12:09:54 -04:00
|
|
|
# obj = Object.new
|
|
|
|
# obj.instance_eval <<-EOD
|
|
|
|
# def self.method_missing(m, *args)
|
2004-10-11 00:51:21 -04:00
|
|
|
# TkCore::INTERP.tk_object_table(#{id}).send(m, *args)
|
2004-05-01 12:09:54 -04:00
|
|
|
# end
|
|
|
|
# EOD
|
|
|
|
# return obj
|
|
|
|
Tk_OBJECT_TABLE.new(id)
|
2003-07-23 12:07:35 -04:00
|
|
|
end
|
|
|
|
|
2003-07-25 12:43:03 -04:00
|
|
|
def INTERP.get_cb_entry(cmd)
|
|
|
|
@cb_entry_class.new(__getip, cmd).freeze
|
|
|
|
end
|
|
|
|
def INTERP.cb_eval(cmd, *args)
|
2004-05-01 12:09:54 -04:00
|
|
|
TkUtil._get_eval_string(TkUtil.eval_cmd(cmd, *args))
|
2003-07-25 12:43:03 -04:00
|
|
|
end
|
|
|
|
|
2003-07-23 12:07:35 -04:00
|
|
|
def INTERP.init_ip_env(script = Proc.new)
|
|
|
|
@init_ip_env << script
|
|
|
|
script.call(self)
|
|
|
|
end
|
2003-07-25 12:43:03 -04:00
|
|
|
def INTERP.add_tk_procs(name, args = nil, body = nil)
|
2003-07-23 12:07:35 -04:00
|
|
|
@add_tk_procs << [name, args, body]
|
2003-07-25 12:43:03 -04:00
|
|
|
self._invoke('proc', name, args, body) if args && body
|
2003-07-23 12:07:35 -04:00
|
|
|
end
|
|
|
|
def INTERP.init_ip_internal
|
|
|
|
ip = self
|
|
|
|
@init_ip_env.each{|script| script.call(ip)}
|
|
|
|
@add_tk_procs.each{|name,args,body| ip._invoke('proc',name,args,body)}
|
|
|
|
end
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
WIDGET_DESTROY_HOOK = '<WIDGET_DESTROY_HOOK>'
|
|
|
|
INTERP._invoke_without_enc('event', 'add',
|
2004-11-12 00:09:37 -05:00
|
|
|
"<#{WIDGET_DESTROY_HOOK}>", '<Destroy>')
|
2004-05-01 12:09:54 -04:00
|
|
|
INTERP._invoke_without_enc('bind', 'all', "<#{WIDGET_DESTROY_HOOK}>",
|
2004-11-12 00:09:37 -05:00
|
|
|
install_cmd(proc{|path|
|
2004-10-11 00:51:21 -04:00
|
|
|
unless TkCore::INTERP.deleted?
|
2005-03-02 02:06:52 -05:00
|
|
|
begin
|
|
|
|
if (widget=TkCore::INTERP.tk_windows[path])
|
|
|
|
if widget.respond_to?(:__destroy_hook__)
|
2004-10-11 00:51:21 -04:00
|
|
|
widget.__destroy_hook__
|
|
|
|
end
|
|
|
|
end
|
2005-03-02 02:06:52 -05:00
|
|
|
rescue Exception=>e
|
|
|
|
p e if $DEBUG
|
2004-10-11 00:51:21 -04:00
|
|
|
end
|
|
|
|
end
|
2004-11-12 00:09:37 -05:00
|
|
|
}) << ' %W')
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
INTERP.add_tk_procs(TclTkLib::FINALIZE_PROC_NAME, '',
|
2004-10-11 00:51:21 -04:00
|
|
|
"bind all <#{WIDGET_DESTROY_HOOK}> {}")
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
INTERP.add_tk_procs('rb_out', 'args', <<-'EOL')
|
|
|
|
if {[set st [catch {eval {ruby_cmd TkCore callback} $args} ret]] != 0} {
|
|
|
|
#return -code $st $ret
|
|
|
|
set idx [string first "\n\n" $ret]
|
|
|
|
if {$idx > 0} {
|
|
|
|
return -code $st \
|
|
|
|
-errorinfo [string range $ret [expr $idx + 2] \
|
|
|
|
[string length $ret]] \
|
|
|
|
[string range $ret 0 [expr $idx - 1]]
|
|
|
|
} else {
|
|
|
|
return -code $st $ret
|
|
|
|
}
|
|
|
|
} else {
|
2004-10-11 00:51:21 -04:00
|
|
|
return $ret
|
2004-05-01 12:09:54 -04:00
|
|
|
}
|
|
|
|
EOL
|
|
|
|
=begin
|
2003-07-23 12:07:35 -04:00
|
|
|
INTERP.add_tk_procs('rb_out', 'args', <<-'EOL')
|
2004-05-01 12:09:54 -04:00
|
|
|
#regsub -all {\\} $args {\\\\} args
|
|
|
|
#regsub -all {!} $args {\\!} args
|
|
|
|
#regsub -all "{" $args "\\{" args
|
|
|
|
regsub -all {(\\|!|\{|\})} $args {\\\1} args
|
2001-10-29 00:07:26 -05:00
|
|
|
if {[set st [catch {ruby [format "TkCore.callback %%Q!%s!" $args]} ret]] != 0} {
|
2004-05-01 12:09:54 -04:00
|
|
|
#return -code $st $ret
|
|
|
|
set idx [string first "\n\n" $ret]
|
|
|
|
if {$idx > 0} {
|
|
|
|
return -code $st \
|
|
|
|
-errorinfo [string range $ret [expr $idx + 2] \
|
|
|
|
[string length $ret]] \
|
|
|
|
[string range $ret 0 [expr $idx - 1]]
|
|
|
|
} else {
|
|
|
|
return -code $st $ret
|
|
|
|
}
|
|
|
|
} else {
|
2004-10-11 00:51:21 -04:00
|
|
|
return $ret
|
2001-10-29 00:07:26 -05:00
|
|
|
}
|
|
|
|
EOL
|
2004-05-01 12:09:54 -04:00
|
|
|
=end
|
1999-08-13 01:37:52 -04:00
|
|
|
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
EventFlag = TclTkLib::EventFlag
|
|
|
|
|
1999-08-13 01:37:52 -04:00
|
|
|
def callback_break
|
2000-01-31 22:12:21 -05:00
|
|
|
fail TkCallbackBreak, "Tk callback returns 'break' status"
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def callback_continue
|
2000-01-31 22:12:21 -05:00
|
|
|
fail TkCallbackContinue, "Tk callback returns 'continue' status"
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def TkCore.callback(*arg)
|
|
|
|
begin
|
2005-03-02 02:06:52 -05:00
|
|
|
if TkCore::INTERP.tk_cmd_tbl.kind_of?(Hash)
|
|
|
|
#TkCore::INTERP.tk_cmd_tbl[arg.shift].call(*arg)
|
|
|
|
normal_ret = false
|
|
|
|
ret = catch(:IRB_EXIT) do # IRB hack
|
|
|
|
retval = TkCore::INTERP.tk_cmd_tbl[arg.shift].call(*arg)
|
|
|
|
normal_ret = true
|
|
|
|
retval
|
|
|
|
end
|
|
|
|
unless normal_ret
|
|
|
|
# catch IRB_EXIT
|
|
|
|
exit(ret)
|
|
|
|
end
|
|
|
|
ret
|
|
|
|
end
|
|
|
|
rescue SystemExit=>e
|
|
|
|
exit(e.status)
|
|
|
|
rescue Interrupt=>e
|
|
|
|
fail(e)
|
2004-05-01 12:09:54 -04:00
|
|
|
rescue Exception => e
|
2003-10-16 10:53:47 -04:00
|
|
|
begin
|
2004-10-11 00:51:21 -04:00
|
|
|
msg = _toUTF8(e.class.inspect) + ': ' +
|
|
|
|
_toUTF8(e.message) + "\n" +
|
|
|
|
"\n---< backtrace of Ruby side >-----\n" +
|
|
|
|
_toUTF8(e.backtrace.join("\n")) +
|
|
|
|
"\n---< backtrace of Tk side >-------"
|
|
|
|
msg.instance_variable_set(:@encoding, 'utf-8')
|
2004-05-01 12:09:54 -04:00
|
|
|
rescue Exception
|
2004-10-11 00:51:21 -04:00
|
|
|
msg = e.class.inspect + ': ' + e.message + "\n" +
|
|
|
|
"\n---< backtrace of Ruby side >-----\n" +
|
|
|
|
e.backtrace.join("\n") +
|
|
|
|
"\n---< backtrace of Tk side >-------"
|
2003-10-16 10:53:47 -04:00
|
|
|
end
|
2005-03-02 02:06:52 -05:00
|
|
|
# TkCore::INTERP._set_global_var('errorInfo', msg)
|
|
|
|
# fail(e)
|
2004-05-01 12:09:54 -04:00
|
|
|
fail(e, msg)
|
2003-10-16 10:53:47 -04:00
|
|
|
end
|
2003-07-25 12:43:03 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
=begin
|
|
|
|
def TkCore.callback(arg_str)
|
|
|
|
# arg = tk_split_list(arg_str)
|
|
|
|
arg = tk_split_simplelist(arg_str)
|
|
|
|
#_get_eval_string(TkUtil.eval_cmd(Tk_CMDTBL[arg.shift], *arg))
|
|
|
|
#_get_eval_string(TkUtil.eval_cmd(TkCore::INTERP.tk_cmd_tbl[arg.shift],
|
2004-10-11 00:51:21 -04:00
|
|
|
# *arg))
|
2004-05-01 12:09:54 -04:00
|
|
|
# TkCore::INTERP.tk_cmd_tbl[arg.shift].call(*arg)
|
|
|
|
begin
|
|
|
|
TkCore::INTERP.tk_cmd_tbl[arg.shift].call(*arg)
|
|
|
|
rescue Exception => e
|
|
|
|
raise(e, e.class.inspect + ': ' + e.message + "\n" +
|
|
|
|
"\n---< backtrace of Ruby side >-----\n" +
|
|
|
|
e.backtrace.join("\n") +
|
|
|
|
"\n---< backtrace of Tk side >-------")
|
|
|
|
end
|
|
|
|
#=begin
|
|
|
|
# cb_obj = TkCore::INTERP.tk_cmd_tbl[arg.shift]
|
|
|
|
# unless $DEBUG
|
|
|
|
# cb_obj.call(*arg)
|
|
|
|
# else
|
|
|
|
# begin
|
2004-10-11 00:51:21 -04:00
|
|
|
# raise 'check backtrace'
|
2004-05-01 12:09:54 -04:00
|
|
|
# rescue
|
2004-10-11 00:51:21 -04:00
|
|
|
# # ignore backtrace before 'callback'
|
|
|
|
# pos = -($!.backtrace.size)
|
2004-05-01 12:09:54 -04:00
|
|
|
# end
|
|
|
|
# begin
|
2004-10-11 00:51:21 -04:00
|
|
|
# cb_obj.call(*arg)
|
2004-05-01 12:09:54 -04:00
|
|
|
# rescue
|
2004-10-11 00:51:21 -04:00
|
|
|
# trace = $!.backtrace
|
|
|
|
# raise $!, "\n#{trace[0]}: #{$!.message} (#{$!.class})\n" +
|
|
|
|
# "\tfrom #{trace[1..pos].join("\n\tfrom ")}"
|
2004-05-01 12:09:54 -04:00
|
|
|
# end
|
|
|
|
# end
|
|
|
|
#=end
|
|
|
|
end
|
|
|
|
=end
|
2003-07-25 12:43:03 -04:00
|
|
|
|
|
|
|
def load_cmd_on_ip(tk_cmd)
|
|
|
|
bool(tk_call('auto_load', tk_cmd))
|
|
|
|
end
|
|
|
|
|
2003-06-16 03:14:50 -04:00
|
|
|
def after(ms, cmd=Proc.new)
|
2004-09-02 22:33:08 -04:00
|
|
|
crit_bup = Thread.critical
|
|
|
|
Thread.critical = true
|
|
|
|
|
1999-08-13 01:37:52 -04:00
|
|
|
myid = _curr_cmd_id
|
2004-09-02 22:33:08 -04:00
|
|
|
cmdid = install_cmd(proc{ret = cmd.call;uninstall_cmd(myid); ret})
|
|
|
|
|
|
|
|
Thread.critical = crit_bup
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call_without_enc("after",ms,cmdid) # return id
|
2002-03-08 02:03:09 -05:00
|
|
|
# return
|
|
|
|
# if false #defined? Thread
|
|
|
|
# Thread.start do
|
2004-10-11 00:51:21 -04:00
|
|
|
# ms = Float(ms)/1000
|
|
|
|
# ms = 10 if ms == 0
|
|
|
|
# sleep ms/1000
|
|
|
|
# cmd.call
|
2002-03-08 02:03:09 -05:00
|
|
|
# end
|
|
|
|
# else
|
|
|
|
# cmdid = install_cmd(cmd)
|
|
|
|
# tk_call("after",ms,cmdid)
|
|
|
|
# end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2003-06-16 03:14:50 -04:00
|
|
|
def after_idle(cmd=Proc.new)
|
2004-09-02 22:33:08 -04:00
|
|
|
crit_bup = Thread.critical
|
|
|
|
Thread.critical = true
|
|
|
|
|
2000-11-27 04:23:38 -05:00
|
|
|
myid = _curr_cmd_id
|
2004-09-02 22:33:08 -04:00
|
|
|
cmdid = install_cmd(proc{ret = cmd.call;uninstall_cmd(myid); ret})
|
|
|
|
|
|
|
|
Thread.critical = crit_bup
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call_without_enc('after','idle',cmdid)
|
2000-11-27 04:23:38 -05:00
|
|
|
end
|
|
|
|
|
2005-03-26 08:58:11 -05:00
|
|
|
def after_cancel(afterId)
|
|
|
|
tk_call_without_enc('after','cancel',afterId)
|
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def windowingsystem
|
|
|
|
tk_call_without_enc('tk', 'windowingsystem')
|
2000-11-27 04:23:38 -05:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def scaling(scale=nil)
|
|
|
|
if scale
|
|
|
|
tk_call_without_enc('tk', 'scaling', scale)
|
2000-11-27 04:23:38 -05:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
Float(number(tk_call_without_enc('tk', 'scaling')))
|
2000-11-27 04:23:38 -05:00
|
|
|
end
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
def scaling_displayof(win, scale=nil)
|
|
|
|
if scale
|
|
|
|
tk_call_without_enc('tk', 'scaling', '-displayof', win, scale)
|
2000-11-27 04:23:38 -05:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
Float(number(tk_call_without_enc('tk', '-displayof', win, 'scaling')))
|
2000-11-27 04:23:38 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2005-06-15 05:30:54 -04:00
|
|
|
def inactive
|
|
|
|
Integer(tk_call_without_enc('tk', 'inactive'))
|
|
|
|
end
|
|
|
|
def inactive_displayof(win)
|
|
|
|
Integer(tk_call_without_enc('tk', 'inactive', '-displayof', win))
|
|
|
|
end
|
|
|
|
def reset_inactive
|
|
|
|
tk_call_without_enc('tk', 'inactive', 'reset')
|
|
|
|
end
|
|
|
|
def reset_inactive_displayof(win)
|
|
|
|
tk_call_without_enc('tk', 'inactive', '-displayof', win, 'reset')
|
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def appname(name=None)
|
|
|
|
tk_call('tk', 'appname', name)
|
2000-11-27 04:23:38 -05:00
|
|
|
end
|
|
|
|
|
2004-05-21 16:45:27 -04:00
|
|
|
def appsend_deny
|
|
|
|
tk_call('rename', 'send', '')
|
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def appsend(interp, async, *args)
|
2004-05-21 16:45:27 -04:00
|
|
|
if $SAFE >= 4
|
|
|
|
fail SecurityError, "cannot send Tk commands at level 4"
|
|
|
|
elsif $SAFE >= 1 && args.find{|obj| obj.tainted?}
|
|
|
|
fail SecurityError, "cannot send tainted Tk commands at level #{$SAFE}"
|
|
|
|
end
|
|
|
|
if async != true && async != false && async != nil
|
|
|
|
args.unshift(async)
|
|
|
|
async = false
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
if async
|
|
|
|
tk_call('send', '-async', '--', interp, *args)
|
2000-11-27 04:23:38 -05:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call('send', '--', interp, *args)
|
2000-11-27 04:23:38 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def rb_appsend(interp, async, *args)
|
2004-05-21 16:45:27 -04:00
|
|
|
if $SAFE >= 4
|
|
|
|
fail SecurityError, "cannot send Ruby commands at level 4"
|
|
|
|
elsif $SAFE >= 1 && args.find{|obj| obj.tainted?}
|
|
|
|
fail SecurityError, "cannot send tainted Ruby commands at level #{$SAFE}"
|
|
|
|
end
|
|
|
|
if async != true && async != false && async != nil
|
|
|
|
args.unshift(async)
|
|
|
|
async = false
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
#args = args.collect!{|c| _get_eval_string(c).gsub(/[\[\]$"]/, '\\\\\&')}
|
|
|
|
args = args.collect!{|c| _get_eval_string(c).gsub(/[\[\]$"\\]/, '\\\\\&')}
|
2004-05-21 16:45:27 -04:00
|
|
|
# args.push(').to_s"')
|
|
|
|
# appsend(interp, async, 'ruby "(', *args)
|
|
|
|
args.push('}.call)"')
|
|
|
|
appsend(interp, async, 'ruby "TkComm._get_eval_string(proc{', *args)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def appsend_displayof(interp, win, async, *args)
|
2004-05-21 16:45:27 -04:00
|
|
|
if $SAFE >= 4
|
|
|
|
fail SecurityError, "cannot send Tk commands at level 4"
|
|
|
|
elsif $SAFE >= 1 && args.find{|obj| obj.tainted?}
|
|
|
|
fail SecurityError, "cannot send tainted Tk commands at level #{$SAFE}"
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
win = '.' if win == nil
|
2004-05-21 16:45:27 -04:00
|
|
|
if async != true && async != false && async != nil
|
|
|
|
args.unshift(async)
|
|
|
|
async = false
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
if async
|
|
|
|
tk_call('send', '-async', '-displayof', win, '--', interp, *args)
|
|
|
|
else
|
|
|
|
tk_call('send', '-displayor', win, '--', interp, *args)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def rb_appsend_displayof(interp, win, async, *args)
|
2004-05-21 16:45:27 -04:00
|
|
|
if $SAFE >= 4
|
|
|
|
fail SecurityError, "cannot send Ruby commands at level 4"
|
|
|
|
elsif $SAFE >= 1 && args.find{|obj| obj.tainted?}
|
|
|
|
fail SecurityError, "cannot send tainted Ruby commands at level #{$SAFE}"
|
|
|
|
end
|
|
|
|
win = '.' if win == nil
|
|
|
|
if async != true && async != false && async != nil
|
|
|
|
args.unshift(async)
|
|
|
|
async = false
|
|
|
|
end
|
2004-02-11 09:31:33 -05:00
|
|
|
#args = args.collect!{|c| _get_eval_string(c).gsub(/[\[\]$"]/, '\\\\\&')}
|
|
|
|
args = args.collect!{|c| _get_eval_string(c).gsub(/[\[\]$"\\]/, '\\\\\&')}
|
2004-05-21 16:45:27 -04:00
|
|
|
# args.push(').to_s"')
|
|
|
|
# appsend_displayof(interp, win, async, 'ruby "(', *args)
|
|
|
|
args.push('}.call)"')
|
|
|
|
appsend(interp, win, async, 'ruby "TkComm._get_eval_string(proc{', *args)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def info(*args)
|
|
|
|
tk_call('info', *args)
|
|
|
|
end
|
|
|
|
|
2003-08-29 04:34:14 -04:00
|
|
|
def mainloop(check_root = true)
|
|
|
|
TclTkLib.mainloop(check_root)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2005-03-02 02:06:52 -05:00
|
|
|
def mainloop_thread?
|
|
|
|
# true : current thread is mainloop
|
|
|
|
# nil : there is no mainloop
|
|
|
|
# false : mainloop is running on the other thread
|
|
|
|
# ( At then, it is dangerous to call Tk interpreter directly. )
|
|
|
|
TclTkLib.mainloop_thread?
|
|
|
|
end
|
|
|
|
|
|
|
|
def mainloop_exist?
|
|
|
|
TclTkLib.mainloop_thread? != nil
|
|
|
|
end
|
|
|
|
|
|
|
|
def is_mainloop?
|
|
|
|
TclTkLib.mainloop_thread? == true
|
|
|
|
end
|
|
|
|
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
def mainloop_watchdog(check_root = true)
|
2003-07-31 03:59:18 -04:00
|
|
|
# watchdog restarts mainloop when mainloop is dead
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
TclTkLib.mainloop_watchdog(check_root)
|
|
|
|
end
|
|
|
|
|
2003-06-19 12:14:43 -04:00
|
|
|
def do_one_event(flag = TclTkLib::EventFlag::ALL)
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
TclTkLib.do_one_event(flag)
|
|
|
|
end
|
|
|
|
|
|
|
|
def set_eventloop_tick(timer_tick)
|
|
|
|
TclTkLib.set_eventloop_tick(timer_tick)
|
|
|
|
end
|
|
|
|
|
|
|
|
def get_eventloop_tick()
|
|
|
|
TclTkLib.get_eventloop_tick
|
|
|
|
end
|
|
|
|
|
2003-06-19 12:14:43 -04:00
|
|
|
def set_no_event_wait(wait)
|
|
|
|
TclTkLib.set_no_even_wait(wait)
|
|
|
|
end
|
|
|
|
|
|
|
|
def get_no_event_wait()
|
|
|
|
TclTkLib.get_no_eventloop_wait
|
|
|
|
end
|
|
|
|
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
def set_eventloop_weight(loop_max, no_event_tick)
|
|
|
|
TclTkLib.set_eventloop_weight(loop_max, no_event_tick)
|
|
|
|
end
|
|
|
|
|
|
|
|
def get_eventloop_weight()
|
|
|
|
TclTkLib.get_eventloop_weight
|
|
|
|
end
|
|
|
|
|
2003-07-23 12:07:35 -04:00
|
|
|
def restart(app_name = nil, keys = {})
|
|
|
|
TkCore::INTERP.init_ip_internal
|
2003-06-18 15:46:20 -04:00
|
|
|
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
tk_call('set', 'argv0', app_name) if app_name
|
2003-07-25 12:43:03 -04:00
|
|
|
if keys.kind_of?(Hash)
|
2003-07-23 12:07:35 -04:00
|
|
|
# tk_call('set', 'argc', keys.size * 2)
|
|
|
|
tk_call('set', 'argv', hash_kv(keys).join(' '))
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
|
|
|
|
INTERP.restart
|
2002-03-08 02:03:09 -05:00
|
|
|
nil
|
|
|
|
end
|
|
|
|
|
2005-03-10 05:13:30 -05:00
|
|
|
def event_generate(win, context, keys=nil)
|
|
|
|
#win = win.path if win.kind_of?(TkObject)
|
1999-08-13 01:37:52 -04:00
|
|
|
if keys
|
2005-03-10 05:13:30 -05:00
|
|
|
tk_call_without_enc('event', 'generate', win,
|
2004-10-11 00:51:21 -04:00
|
|
|
"<#{tk_event_sequence(context)}>",
|
|
|
|
*hash_kv(keys, true))
|
1999-08-13 01:37:52 -04:00
|
|
|
else
|
2005-03-10 05:13:30 -05:00
|
|
|
tk_call_without_enc('event', 'generate', win,
|
2004-10-11 00:51:21 -04:00
|
|
|
"<#{tk_event_sequence(context)}>")
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
nil
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def messageBox(keys)
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call('tk_messageBox', *hash_kv(keys))
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2000-07-06 03:21:26 -04:00
|
|
|
def getOpenFile(keys = nil)
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call('tk_getOpenFile', *hash_kv(keys))
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2000-07-06 03:21:26 -04:00
|
|
|
def getSaveFile(keys = nil)
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call('tk_getSaveFile', *hash_kv(keys))
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2003-07-17 02:40:28 -04:00
|
|
|
|
2000-07-06 03:21:26 -04:00
|
|
|
def chooseColor(keys = nil)
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call('tk_chooseColor', *hash_kv(keys))
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2003-07-26 01:27:42 -04:00
|
|
|
def chooseDirectory(keys = nil)
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call('tk_chooseDirectory', *hash_kv(keys))
|
2003-07-26 01:27:42 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def _ip_eval_core(enc_mode, cmd_string)
|
|
|
|
case enc_mode
|
|
|
|
when nil
|
|
|
|
res = INTERP._eval(cmd_string)
|
|
|
|
when false
|
|
|
|
res = INTERP._eval_without_enc(cmd_string)
|
|
|
|
when true
|
|
|
|
res = INTERP._eval_with_enc(cmd_string)
|
|
|
|
end
|
2003-06-21 04:47:22 -04:00
|
|
|
if INTERP._return_value() != 0
|
|
|
|
fail RuntimeError, res, error_at
|
|
|
|
end
|
|
|
|
return res
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
private :_ip_eval_core
|
2003-06-21 04:47:22 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def ip_eval(cmd_string)
|
|
|
|
_ip_eval_core(nil, cmd_string)
|
|
|
|
end
|
|
|
|
|
|
|
|
def ip_eval_without_enc(cmd_string)
|
|
|
|
_ip_eval_core(false, cmd_string)
|
|
|
|
end
|
|
|
|
|
|
|
|
def ip_eval_with_enc(cmd_string)
|
|
|
|
_ip_eval_core(true, cmd_string)
|
|
|
|
end
|
|
|
|
|
|
|
|
def _ip_invoke_core(enc_mode, *args)
|
|
|
|
case enc_mode
|
|
|
|
when false
|
|
|
|
res = INTERP._invoke_without_enc(*args)
|
|
|
|
when nil
|
|
|
|
res = INTERP._invoke(*args)
|
|
|
|
when true
|
|
|
|
res = INTERP._invoke_with_enc(*args)
|
|
|
|
end
|
2003-06-21 04:47:22 -04:00
|
|
|
if INTERP._return_value() != 0
|
|
|
|
fail RuntimeError, res, error_at
|
|
|
|
end
|
|
|
|
return res
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
private :_ip_invoke_core
|
2003-06-21 04:47:22 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def ip_invoke(*args)
|
|
|
|
_ip_invoke_core(nil, *args)
|
|
|
|
end
|
|
|
|
|
|
|
|
def ip_invoke_without_enc(*args)
|
|
|
|
_ip_invoke_core(false, *args)
|
|
|
|
end
|
|
|
|
|
|
|
|
def ip_invoke_with_enc(*args)
|
|
|
|
_ip_invoke_core(true, *args)
|
|
|
|
end
|
|
|
|
|
|
|
|
def _tk_call_core(enc_mode, *args)
|
|
|
|
### puts args.inspect if $DEBUG
|
|
|
|
#args.collect! {|x|ruby2tcl(x, enc_mode)}
|
|
|
|
#args.compact!
|
|
|
|
#args.flatten!
|
|
|
|
args = _conv_args([], enc_mode, *args)
|
|
|
|
puts 'invoke args => ' + args.inspect if $DEBUG
|
|
|
|
### print "=> ", args.join(" ").inspect, "\n" if $DEBUG
|
1999-08-13 01:37:52 -04:00
|
|
|
begin
|
2003-06-20 10:52:45 -04:00
|
|
|
# res = INTERP._invoke(*args).taint
|
2004-05-01 12:09:54 -04:00
|
|
|
# res = INTERP._invoke(enc_mode, *args)
|
|
|
|
res = _ip_invoke_core(enc_mode, *args)
|
|
|
|
# >>>>> _invoke returns a TAINTED string <<<<<
|
2003-08-29 04:34:14 -04:00
|
|
|
rescue NameError => err
|
2004-05-01 12:09:54 -04:00
|
|
|
# err = $!
|
1999-08-13 01:37:52 -04:00
|
|
|
begin
|
|
|
|
args.unshift "unknown"
|
2003-06-20 10:52:45 -04:00
|
|
|
#res = INTERP._invoke(*args).taint
|
2004-05-01 12:09:54 -04:00
|
|
|
#res = INTERP._invoke(enc_mode, *args)
|
|
|
|
res = _ip_invoke_core(enc_mode, *args)
|
2004-10-11 00:51:21 -04:00
|
|
|
# >>>>> _invoke returns a TAINTED string <<<<<
|
2003-08-29 04:34:14 -04:00
|
|
|
rescue StandardError => err2
|
2004-10-11 00:51:21 -04:00
|
|
|
fail err2 unless /^invalid command/ =~ err2.message
|
|
|
|
fail err
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
if INTERP._return_value() != 0
|
|
|
|
fail RuntimeError, res, error_at
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
### print "==> ", res.inspect, "\n" if $DEBUG
|
1999-08-13 01:37:52 -04:00
|
|
|
return res
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
private :_tk_call_core
|
2001-03-27 02:10:58 -05:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def tk_call(*args)
|
|
|
|
_tk_call_core(nil, *args)
|
2001-03-27 02:10:58 -05:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def tk_call_without_enc(*args)
|
|
|
|
_tk_call_core(false, *args)
|
2001-03-27 02:10:58 -05:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def tk_call_with_enc(*args)
|
|
|
|
_tk_call_core(true, *args)
|
2001-03-27 02:10:58 -05:00
|
|
|
end
|
2005-05-25 17:11:13 -04:00
|
|
|
|
|
|
|
def _tk_call_to_list_core(depth, arg_enc, val_enc, *args)
|
|
|
|
args = _conv_args([], arg_enc, *args)
|
|
|
|
val = _tk_call_core(false, *args)
|
|
|
|
if !depth.kind_of?(Integer) || depth == 0
|
|
|
|
tk_split_simplelist(val, false, val_enc)
|
|
|
|
else
|
|
|
|
tk_split_list(val, depth, false, val_enc)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
#private :_tk_call_to_list_core
|
|
|
|
|
|
|
|
def tk_call_to_list(*args)
|
|
|
|
_tk_call_to_list_core(-1, nil, true, *args)
|
|
|
|
end
|
|
|
|
|
|
|
|
def tk_call_to_list_without_enc(*args)
|
|
|
|
_tk_call_to_list_core(-1, false, false, *args)
|
|
|
|
end
|
|
|
|
|
|
|
|
def tk_call_to_list_with_enc(*args)
|
|
|
|
_tk_call_to_list_core(-1, true, true, *args)
|
|
|
|
end
|
|
|
|
|
|
|
|
def tk_call_to_simplelist(*args)
|
|
|
|
_tk_call_to_list_core(0, nil, true, *args)
|
|
|
|
end
|
|
|
|
|
|
|
|
def tk_call_to_simplelist_without_enc(*args)
|
|
|
|
_tk_call_to_list_core(0, false, false, *args)
|
|
|
|
end
|
|
|
|
|
|
|
|
def tk_call_to_simplelist_with_enc(*args)
|
|
|
|
_tk_call_to_list_core(0, true, true, *args)
|
|
|
|
end
|
2001-03-27 02:10:58 -05:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
|
1999-08-13 01:37:52 -04:00
|
|
|
module Tk
|
|
|
|
include TkCore
|
|
|
|
extend Tk
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
TCL_VERSION = INTERP._invoke_without_enc("info", "tclversion").freeze
|
|
|
|
TCL_PATCHLEVEL = INTERP._invoke_without_enc("info", "patchlevel").freeze
|
2003-10-14 11:25:45 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
major, minor = TCL_VERSION.split('.')
|
|
|
|
TCL_MAJOR_VERSION = major.to_i
|
|
|
|
TCL_MINOR_VERSION = minor.to_i
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
TK_VERSION = INTERP._invoke_without_enc("set", "tk_version").freeze
|
|
|
|
TK_PATCHLEVEL = INTERP._invoke_without_enc("set", "tk_patchLevel").freeze
|
2001-03-27 02:10:58 -05:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
major, minor = TK_VERSION.split('.')
|
|
|
|
TK_MAJOR_VERSION = major.to_i
|
|
|
|
TK_MINOR_VERSION = minor.to_i
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
JAPANIZED_TK = (INTERP._invoke_without_enc("info", "commands",
|
2004-10-11 00:51:21 -04:00
|
|
|
"kanji") != "").freeze
|
2001-03-27 02:10:58 -05:00
|
|
|
|
2003-10-14 11:25:45 -04:00
|
|
|
def Tk.const_missing(sym)
|
|
|
|
case(sym)
|
|
|
|
when :TCL_LIBRARY
|
2004-07-06 05:42:12 -04:00
|
|
|
INTERP._invoke_without_enc('global', 'tcl_library')
|
2003-10-14 11:25:45 -04:00
|
|
|
INTERP._invoke("set", "tcl_library").freeze
|
|
|
|
|
|
|
|
when :TK_LIBRARY
|
2004-07-06 05:42:12 -04:00
|
|
|
INTERP._invoke_without_enc('global', 'tk_library')
|
2003-10-14 11:25:45 -04:00
|
|
|
INTERP._invoke("set", "tk_library").freeze
|
|
|
|
|
|
|
|
when :LIBRARY
|
|
|
|
INTERP._invoke("info", "library").freeze
|
|
|
|
|
|
|
|
#when :PKG_PATH, :PACKAGE_PATH, :TCL_PACKAGE_PATH
|
2004-07-06 05:42:12 -04:00
|
|
|
# INTERP._invoke_without_enc('global', 'tcl_pkgPath')
|
2003-10-14 11:25:45 -04:00
|
|
|
# tk_split_simplelist(INTERP._invoke('set', 'tcl_pkgPath'))
|
|
|
|
|
|
|
|
#when :LIB_PATH, :LIBRARY_PATH, :TCL_LIBRARY_PATH
|
2004-07-06 05:42:12 -04:00
|
|
|
# INTERP._invoke_without_enc('global', 'tcl_libPath')
|
2003-10-14 11:25:45 -04:00
|
|
|
# tk_split_simplelist(INTERP._invoke('set', 'tcl_libPath'))
|
|
|
|
|
|
|
|
when :PLATFORM, :TCL_PLATFORM
|
2004-05-01 12:09:54 -04:00
|
|
|
if $SAFE >= 4
|
2004-10-11 00:51:21 -04:00
|
|
|
fail SecurityError, "can't get #{sym} when $SAFE >= 4"
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
2004-07-06 05:42:12 -04:00
|
|
|
INTERP._invoke_without_enc('global', 'tcl_platform')
|
2004-05-01 12:09:54 -04:00
|
|
|
Hash[*tk_split_simplelist(INTERP._invoke_without_enc('array', 'get',
|
2004-10-11 00:51:21 -04:00
|
|
|
'tcl_platform'))]
|
2003-10-14 11:25:45 -04:00
|
|
|
|
|
|
|
when :ENV
|
2004-07-06 05:42:12 -04:00
|
|
|
INTERP._invoke_without_enc('global', 'env')
|
2003-10-14 11:25:45 -04:00
|
|
|
Hash[*tk_split_simplelist(INTERP._invoke('array', 'get', 'env'))]
|
|
|
|
|
|
|
|
#when :AUTO_PATH #<===
|
|
|
|
# tk_split_simplelist(INTERP._invoke('set', 'auto_path'))
|
|
|
|
|
|
|
|
#when :AUTO_OLDPATH
|
|
|
|
# tk_split_simplelist(INTERP._invoke('set', 'auto_oldpath'))
|
|
|
|
|
|
|
|
when :AUTO_INDEX
|
2004-07-06 05:42:12 -04:00
|
|
|
INTERP._invoke_without_enc('global', 'auto_index')
|
2003-10-14 11:25:45 -04:00
|
|
|
Hash[*tk_split_simplelist(INTERP._invoke('array', 'get', 'auto_index'))]
|
|
|
|
|
|
|
|
when :PRIV, :PRIVATE, :TK_PRIV
|
|
|
|
priv = {}
|
2004-05-01 12:09:54 -04:00
|
|
|
if INTERP._invoke_without_enc('info', 'vars', 'tk::Priv') != ""
|
2004-10-11 00:51:21 -04:00
|
|
|
var_nam = 'tk::Priv'
|
2003-10-14 11:25:45 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
var_nam = 'tkPriv'
|
2003-10-14 11:25:45 -04:00
|
|
|
end
|
2004-07-06 05:42:12 -04:00
|
|
|
INTERP._invoke_without_enc('global', var_nam)
|
2003-10-14 11:25:45 -04:00
|
|
|
Hash[*tk_split_simplelist(INTERP._invoke('array', 'get',
|
2004-10-11 00:51:21 -04:00
|
|
|
var_nam))].each{|k,v|
|
|
|
|
k.freeze
|
|
|
|
case v
|
|
|
|
when /^-?\d+$/
|
|
|
|
priv[k] = v.to_i
|
|
|
|
when /^-?\d+\.?\d*(e[-+]?\d+)?$/
|
|
|
|
priv[k] = v.to_f
|
|
|
|
else
|
|
|
|
priv[k] = v.freeze
|
|
|
|
end
|
2003-10-14 11:25:45 -04:00
|
|
|
}
|
|
|
|
priv
|
2001-03-27 02:10:58 -05:00
|
|
|
|
2003-06-18 15:46:20 -04:00
|
|
|
else
|
2003-10-14 11:25:45 -04:00
|
|
|
raise NameError, 'uninitialized constant Tk::' + sym.id2name
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2003-10-14 11:25:45 -04:00
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
|
2004-10-06 12:08:45 -04:00
|
|
|
def Tk.errorInfo
|
|
|
|
INTERP._invoke_without_enc('global', 'errorInfo')
|
|
|
|
INTERP._invoke_without_enc('set', 'errorInfo')
|
|
|
|
end
|
|
|
|
|
|
|
|
def Tk.errorCode
|
|
|
|
INTERP._invoke_without_enc('global', 'errorCode')
|
2004-10-07 04:38:03 -04:00
|
|
|
code = tk_split_simplelist(INTERP._invoke_without_enc('set', 'errorCode'))
|
|
|
|
case code[0]
|
|
|
|
when 'CHILDKILLED', 'CHILDSTATUS', 'CHILDSUSP'
|
|
|
|
begin
|
2004-10-11 00:51:21 -04:00
|
|
|
pid = Integer(code[1])
|
|
|
|
code[1] = pid
|
2004-10-07 04:38:03 -04:00
|
|
|
rescue
|
|
|
|
end
|
|
|
|
end
|
|
|
|
code
|
2004-10-06 12:08:45 -04:00
|
|
|
end
|
|
|
|
|
1999-08-13 01:37:52 -04:00
|
|
|
def root
|
|
|
|
TkRoot.new
|
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def Tk.load_tclscript(file, enc=nil)
|
|
|
|
if enc
|
|
|
|
# TCL_VERSION >= 8.5
|
|
|
|
tk_call('source', '-encoding', enc, file)
|
|
|
|
else
|
|
|
|
tk_call('source', file)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def Tk.load_tcllibrary(file, pkg_name=None, interp=None)
|
|
|
|
tk_call('load', file, pkg_name, interp)
|
|
|
|
end
|
|
|
|
|
|
|
|
def Tk.unload_tcllibrary(*args)
|
|
|
|
if args[-1].kind_of?(Hash)
|
|
|
|
keys = _symbolkey2str(args.pop)
|
|
|
|
nocomp = (keys['nocomplain'])? '-nocomplain': None
|
|
|
|
keeplib = (keys['keeplibrary'])? '-keeplibrary': None
|
|
|
|
tk_call('unload', nocomp, keeplib, '--', *args)
|
|
|
|
else
|
|
|
|
tk_call('unload', *args)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2003-08-29 04:34:14 -04:00
|
|
|
def Tk.bell(nice = false)
|
2003-06-18 15:46:20 -04:00
|
|
|
if nice
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call_without_enc('bell', '-nice')
|
2003-06-18 15:46:20 -04:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call_without_enc('bell')
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
nil
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
|
|
|
|
2003-08-29 04:34:14 -04:00
|
|
|
def Tk.bell_on_display(win, nice = false)
|
2003-06-18 15:46:20 -04:00
|
|
|
if nice
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call_without_enc('bell', '-displayof', win, '-nice')
|
2003-06-18 15:46:20 -04:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call_without_enc('bell', '-displayof', win)
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
nil
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def Tk.destroy(*wins)
|
2004-11-26 04:07:25 -05:00
|
|
|
#tk_call_without_enc('destroy', *wins)
|
|
|
|
tk_call_without_enc('destroy', *(wins.collect{|win|
|
|
|
|
if win.kind_of?(TkWindow)
|
|
|
|
win.epath
|
|
|
|
else
|
|
|
|
win
|
|
|
|
end
|
|
|
|
}))
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
|
|
|
|
2003-06-19 12:14:43 -04:00
|
|
|
def Tk.exit
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call_without_enc('destroy', '.')
|
|
|
|
end
|
|
|
|
|
|
|
|
def Tk.pack(*args)
|
2005-03-02 02:06:52 -05:00
|
|
|
TkPack.configure(*args)
|
|
|
|
end
|
|
|
|
def Tk.pack_forget(*args)
|
|
|
|
TkPack.forget(*args)
|
|
|
|
end
|
|
|
|
def Tk.unpack(*args)
|
|
|
|
TkPack.forget(*args)
|
2003-06-19 12:14:43 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def Tk.grid(*args)
|
|
|
|
TkGrid.configure(*args)
|
|
|
|
end
|
2005-03-02 02:06:52 -05:00
|
|
|
def Tk.grid_forget(*args)
|
|
|
|
TkGrid.forget(*args)
|
|
|
|
end
|
|
|
|
def Tk.ungrid(*args)
|
|
|
|
TkGrid.forget(*args)
|
|
|
|
end
|
|
|
|
|
|
|
|
def Tk.place(*args)
|
|
|
|
TkPlace.configure(*args)
|
|
|
|
end
|
|
|
|
def Tk.place_forget(*args)
|
|
|
|
TkPlace.forget(*args)
|
|
|
|
end
|
|
|
|
def Tk.unplace(*args)
|
|
|
|
TkPlace.forget(*args)
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def Tk.update(idle=nil)
|
|
|
|
if idle
|
|
|
|
tk_call_without_enc('update', 'idletasks')
|
|
|
|
else
|
|
|
|
tk_call_without_enc('update')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
def Tk.update_idletasks
|
|
|
|
update(true)
|
|
|
|
end
|
2004-07-28 01:58:49 -04:00
|
|
|
def update(idle=nil)
|
|
|
|
# only for backward compatibility (This never be recommended to use)
|
|
|
|
Tk.update(idle)
|
|
|
|
self
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
=begin
|
|
|
|
# See tcltklib.c for the reason of why the following methods are disabled.
|
|
|
|
def Tk.thread_update(idle=nil)
|
|
|
|
if idle
|
|
|
|
tk_call_without_enc('thread_update', 'idletasks')
|
|
|
|
else
|
|
|
|
tk_call_without_enc('thread_update')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
def Tk.thread_update_idletasks
|
|
|
|
thread_update(true)
|
|
|
|
end
|
|
|
|
=end
|
|
|
|
|
2005-05-25 07:09:59 -04:00
|
|
|
def Tk.lower_window(win, below=None)
|
|
|
|
tk_call('lower', _epath(win), _epath(below))
|
|
|
|
nil
|
|
|
|
end
|
|
|
|
def Tk.raise_window(win, above=None)
|
|
|
|
tk_call('raise', _epath(win), _epath(above))
|
|
|
|
nil
|
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def Tk.current_grabs(win = nil)
|
|
|
|
if win
|
|
|
|
window(tk_call_without_enc('grab', 'current', win))
|
|
|
|
else
|
|
|
|
tk_split_list(tk_call_without_enc('grab', 'current'))
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def Tk.focus(display=nil)
|
|
|
|
if display == nil
|
2004-05-01 12:09:54 -04:00
|
|
|
window(tk_call_without_enc('focus'))
|
|
|
|
else
|
|
|
|
window(tk_call_without_enc('focus', '-displayof', display))
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def Tk.focus_to(win, force=false)
|
|
|
|
if force
|
|
|
|
tk_call_without_enc('focus', '-force', win)
|
1999-08-13 01:37:52 -04:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call_without_enc('focus', win)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def Tk.focus_lastfor(win)
|
2004-05-01 12:09:54 -04:00
|
|
|
window(tk_call_without_enc('focus', '-lastfor', win))
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def Tk.focus_next(win)
|
|
|
|
TkManageFocus.next(win)
|
|
|
|
end
|
|
|
|
|
|
|
|
def Tk.focus_prev(win)
|
|
|
|
TkManageFocus.prev(win)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2005-03-10 05:13:30 -05:00
|
|
|
def Tk.strictMotif(mode=None)
|
|
|
|
bool(tk_call_without_enc('set', 'tk_strictMotif', mode))
|
2001-03-27 02:10:58 -05:00
|
|
|
end
|
|
|
|
|
2000-06-13 05:57:40 -04:00
|
|
|
def Tk.show_kinsoku(mode='both')
|
|
|
|
begin
|
|
|
|
if /^8\.*/ === TK_VERSION && JAPANIZED_TK
|
|
|
|
tk_split_simplelist(tk_call('kinsoku', 'show', mode))
|
|
|
|
end
|
|
|
|
rescue
|
|
|
|
end
|
|
|
|
end
|
|
|
|
def Tk.add_kinsoku(chars, mode='both')
|
|
|
|
begin
|
|
|
|
if /^8\.*/ === TK_VERSION && JAPANIZED_TK
|
|
|
|
tk_split_simplelist(tk_call('kinsoku', 'add', mode,
|
|
|
|
*(chars.split(''))))
|
|
|
|
else
|
|
|
|
[]
|
|
|
|
end
|
|
|
|
rescue
|
|
|
|
[]
|
|
|
|
end
|
|
|
|
end
|
|
|
|
def Tk.delete_kinsoku(chars, mode='both')
|
|
|
|
begin
|
|
|
|
if /^8\.*/ === TK_VERSION && JAPANIZED_TK
|
|
|
|
tk_split_simplelist(tk_call('kinsoku', 'delete', mode,
|
|
|
|
*(chars.split(''))))
|
|
|
|
end
|
|
|
|
rescue
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def Tk.toUTF8(str, encoding = nil)
|
|
|
|
_toUTF8(str, encoding)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def Tk.fromUTF8(str, encoding = nil)
|
|
|
|
_fromUTF8(str, encoding)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
###########################################
|
|
|
|
# string with Tcl's encoding
|
|
|
|
###########################################
|
|
|
|
module Tk
|
|
|
|
def Tk.subst_utf_backslash(str)
|
|
|
|
Tk::EncodedString.subst_utf_backslash(str)
|
|
|
|
end
|
|
|
|
def Tk.subst_tk_backslash(str)
|
|
|
|
Tk::EncodedString.subst_tk_backslash(str)
|
|
|
|
end
|
|
|
|
def Tk.utf_to_backslash_sequence(str)
|
|
|
|
Tk::EncodedString.utf_to_backslash_sequence(str)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
def Tk.utf_to_backslash(str)
|
|
|
|
Tk::EncodedString.utf_to_backslash_sequence(str)
|
|
|
|
end
|
|
|
|
def Tk.to_backslash_sequence(str)
|
|
|
|
Tk::EncodedString.to_backslash_sequence(str)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
###########################################
|
|
|
|
# convert kanji string to/from utf-8
|
|
|
|
###########################################
|
|
|
|
if (/^(8\.[1-9]|9\.|[1-9][0-9])/ =~ Tk::TCL_VERSION && !Tk::JAPANIZED_TK)
|
|
|
|
class TclTkIp
|
|
|
|
# from tkencoding.rb by ttate@jaist.ac.jp
|
|
|
|
attr_accessor :encoding
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
alias __eval _eval
|
|
|
|
alias __invoke _invoke
|
2003-07-23 12:07:35 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
alias __toUTF8 _toUTF8
|
|
|
|
alias __fromUTF8 _fromUTF8
|
2003-07-23 12:07:35 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
=begin
|
|
|
|
#### --> definition is moved to TclTkIp module
|
|
|
|
|
|
|
|
def _toUTF8(str, encoding = nil)
|
|
|
|
# decide encoding
|
|
|
|
if encoding
|
2004-10-11 00:51:21 -04:00
|
|
|
encoding = encoding.to_s
|
2004-05-01 12:09:54 -04:00
|
|
|
elsif str.kind_of?(Tk::EncodedString) && str.encoding != nil
|
2004-10-11 00:51:21 -04:00
|
|
|
encoding = str.encoding.to_s
|
2004-05-01 12:09:54 -04:00
|
|
|
elsif str.instance_variable_get(:@encoding)
|
2004-10-11 00:51:21 -04:00
|
|
|
encoding = str.instance_variable_get(:@encoding).to_s
|
2004-05-01 12:09:54 -04:00
|
|
|
elsif defined?(@encoding) && @encoding != nil
|
2004-10-11 00:51:21 -04:00
|
|
|
encoding = @encoding.to_s
|
2003-06-18 15:46:20 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
encoding = __invoke('encoding', 'system')
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
# convert
|
|
|
|
case encoding
|
|
|
|
when 'utf-8', 'binary'
|
2004-10-11 00:51:21 -04:00
|
|
|
str
|
2003-06-18 15:46:20 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
__toUTF8(str, encoding)
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def _fromUTF8(str, encoding = nil)
|
|
|
|
unless encoding
|
2004-10-11 00:51:21 -04:00
|
|
|
if defined?(@encoding) && @encoding != nil
|
|
|
|
encoding = @encoding.to_s
|
|
|
|
else
|
|
|
|
encoding = __invoke('encoding', 'system')
|
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
if str.kind_of?(Tk::EncodedString)
|
2004-10-11 00:51:21 -04:00
|
|
|
if str.encoding == 'binary'
|
|
|
|
str
|
|
|
|
else
|
|
|
|
__fromUTF8(str, encoding)
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
elsif str.instance_variable_get(:@encoding).to_s == 'binary'
|
2004-10-11 00:51:21 -04:00
|
|
|
str
|
2003-06-18 15:46:20 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
__fromUTF8(str, encoding)
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
=end
|
|
|
|
|
|
|
|
def _eval(cmd)
|
|
|
|
_fromUTF8(__eval(_toUTF8(cmd)))
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def _invoke(*cmds)
|
|
|
|
_fromUTF8(__invoke(*(cmds.collect{|cmd| _toUTF8(cmd)})))
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
alias _eval_with_enc _eval
|
|
|
|
alias _invoke_with_enc _invoke
|
|
|
|
|
|
|
|
=begin
|
|
|
|
def _eval(cmd)
|
|
|
|
if defined?(@encoding) && @encoding != 'utf-8'
|
2004-10-11 00:51:21 -04:00
|
|
|
ret = if cmd.kind_of?(Tk::EncodedString)
|
|
|
|
case cmd.encoding
|
|
|
|
when 'utf-8', 'binary'
|
|
|
|
__eval(cmd)
|
|
|
|
else
|
|
|
|
__eval(_toUTF8(cmd, cmd.encoding))
|
|
|
|
end
|
|
|
|
elsif cmd.instance_variable_get(:@encoding) == 'binary'
|
|
|
|
__eval(cmd)
|
|
|
|
else
|
|
|
|
__eval(_toUTF8(cmd, @encoding))
|
|
|
|
end
|
|
|
|
if ret.kind_of?(String) && ret.instance_variable_get(:@encoding) == 'binary'
|
|
|
|
ret
|
|
|
|
else
|
|
|
|
_fromUTF8(ret, @encoding)
|
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
__eval(cmd)
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def _invoke(*cmds)
|
|
|
|
if defined?(@encoding) && @encoding != 'utf-8'
|
2004-10-11 00:51:21 -04:00
|
|
|
cmds = cmds.collect{|cmd|
|
|
|
|
if cmd.kind_of?(Tk::EncodedString)
|
|
|
|
case cmd.encoding
|
|
|
|
when 'utf-8', 'binary'
|
|
|
|
cmd
|
|
|
|
else
|
|
|
|
_toUTF8(cmd, cmd.encoding)
|
|
|
|
end
|
|
|
|
elsif cmd.instance_variable_get(:@encoding) == 'binary'
|
|
|
|
cmd
|
|
|
|
else
|
|
|
|
_toUTF8(cmd, @encoding)
|
|
|
|
end
|
|
|
|
}
|
|
|
|
ret = __invoke(*cmds)
|
|
|
|
if ret.kind_of?(String) && ret.instance_variable_get(:@encoding) == 'binary'
|
|
|
|
ret
|
|
|
|
else
|
|
|
|
_fromUTF8(ret, @encoding)
|
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
__invoke(*cmds)
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
=end
|
|
|
|
end
|
|
|
|
|
|
|
|
module Tk
|
|
|
|
module Encoding
|
|
|
|
extend Encoding
|
|
|
|
|
|
|
|
TkCommandNames = ['encoding'.freeze].freeze
|
|
|
|
|
|
|
|
def encoding=(name)
|
2004-10-11 00:51:21 -04:00
|
|
|
TkCore::INTERP.encoding = name
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def encoding
|
2004-10-11 00:51:21 -04:00
|
|
|
TkCore::INTERP.encoding
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def encoding_names
|
2004-10-11 00:51:21 -04:00
|
|
|
tk_split_simplelist(tk_call('encoding', 'names'))
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def encoding_system
|
2004-10-11 00:51:21 -04:00
|
|
|
tk_call('encoding', 'system')
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def encoding_system=(enc)
|
2004-10-11 00:51:21 -04:00
|
|
|
tk_call('encoding', 'system', enc)
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
2004-07-30 03:13:55 -04:00
|
|
|
def encoding_convertfrom(str, enc=nil)
|
2004-10-11 00:51:21 -04:00
|
|
|
# str must be a Tcl's internal string expression in enc.
|
|
|
|
# the return value is a UTF-8 string.
|
|
|
|
enc = encoding_system unless enc
|
|
|
|
TkCore::INTERP.__invoke('encoding', 'convertfrom', enc, str)
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
alias encoding_convert_from encoding_convertfrom
|
|
|
|
|
2004-07-30 03:13:55 -04:00
|
|
|
def encoding_convertto(str, enc=nil)
|
2004-10-11 00:51:21 -04:00
|
|
|
# str must be a UTF-8 string.
|
|
|
|
# The return value is a Tcl's internal string expression in enc.
|
2004-07-30 03:13:55 -04:00
|
|
|
# To get an usual enc string, use Tk.fromUTF8(ret_val, enc).
|
2004-10-11 00:51:21 -04:00
|
|
|
enc = encoding_system unless enc
|
|
|
|
TkCore::INTERP.__invoke('encoding', 'convertto', enc, str)
|
2000-08-02 00:54:21 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
alias encoding_convert_to encoding_convertto
|
2000-08-02 00:54:21 -04:00
|
|
|
end
|
2003-07-23 12:07:35 -04:00
|
|
|
|
|
|
|
extend Encoding
|
2000-08-02 00:54:21 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
# estimate encoding
|
|
|
|
case $KCODE
|
|
|
|
when /^e/i # EUC
|
|
|
|
Tk.encoding = 'euc-jp'
|
2004-12-17 02:31:51 -05:00
|
|
|
Tk.encoding_system = 'euc-jp'
|
2000-08-02 00:54:21 -04:00
|
|
|
when /^s/i # SJIS
|
2004-12-17 02:31:51 -05:00
|
|
|
begin
|
|
|
|
if Tk.encoding_system == 'cp932'
|
|
|
|
Tk.encoding = 'cp932'
|
|
|
|
else
|
|
|
|
Tk.encoding = 'shiftjis'
|
|
|
|
Tk.encoding_system = 'shiftjis'
|
|
|
|
end
|
|
|
|
rescue StandardError, NameError
|
|
|
|
Tk.encoding = 'shiftjis'
|
|
|
|
Tk.encoding_system = 'shiftjis'
|
|
|
|
end
|
2000-08-02 00:54:21 -04:00
|
|
|
when /^u/i # UTF8
|
|
|
|
Tk.encoding = 'utf-8'
|
2004-12-17 02:31:51 -05:00
|
|
|
Tk.encoding_system = 'utf-8'
|
2000-08-02 00:54:21 -04:00
|
|
|
else # NONE
|
|
|
|
begin
|
|
|
|
Tk.encoding = Tk.encoding_system
|
|
|
|
rescue StandardError, NameError
|
|
|
|
Tk.encoding = 'utf-8'
|
2004-12-17 02:31:51 -05:00
|
|
|
Tk.encoding_system = 'utf-8'
|
2000-08-02 00:54:21 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
else
|
|
|
|
# dummy methods
|
2003-07-31 19:04:45 -04:00
|
|
|
class TclTkIp
|
|
|
|
alias __eval _eval
|
|
|
|
alias __invoke _invoke
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
alias _eval_with_enc _eval
|
|
|
|
alias _invoke_with_enc _invoke
|
2003-07-31 19:04:45 -04:00
|
|
|
end
|
|
|
|
|
2000-08-02 00:54:21 -04:00
|
|
|
module Tk
|
2003-07-23 12:07:35 -04:00
|
|
|
module Encoding
|
|
|
|
extend Encoding
|
|
|
|
|
|
|
|
def encoding=(name)
|
2004-10-11 00:51:21 -04:00
|
|
|
nil
|
2003-07-23 12:07:35 -04:00
|
|
|
end
|
|
|
|
def encoding
|
2004-10-11 00:51:21 -04:00
|
|
|
nil
|
2003-07-23 12:07:35 -04:00
|
|
|
end
|
|
|
|
def encoding_names
|
2004-10-11 00:51:21 -04:00
|
|
|
nil
|
2003-07-23 12:07:35 -04:00
|
|
|
end
|
|
|
|
def encoding_system
|
2004-10-11 00:51:21 -04:00
|
|
|
nil
|
2003-07-23 12:07:35 -04:00
|
|
|
end
|
|
|
|
def encoding_system=(enc)
|
2004-10-11 00:51:21 -04:00
|
|
|
nil
|
2003-07-23 12:07:35 -04:00
|
|
|
end
|
2003-07-31 19:04:45 -04:00
|
|
|
|
|
|
|
def encoding_convertfrom(str, enc=None)
|
2004-10-11 00:51:21 -04:00
|
|
|
str
|
2003-07-31 19:04:45 -04:00
|
|
|
end
|
|
|
|
alias encoding_convert_from encoding_convertfrom
|
|
|
|
|
|
|
|
def encoding_convertto(str, enc=None)
|
2004-10-11 00:51:21 -04:00
|
|
|
str
|
2003-07-31 19:04:45 -04:00
|
|
|
end
|
|
|
|
alias encoding_convert_to encoding_convertto
|
2000-08-02 00:54:21 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2000-01-17 03:37:53 -05:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
module TkBindCore
|
2004-12-08 13:14:15 -05:00
|
|
|
#def bind(context, cmd=Proc.new, *args)
|
|
|
|
# Tk.bind(self, context, cmd, *args)
|
|
|
|
#end
|
|
|
|
def bind(context, *args)
|
2004-12-16 02:13:14 -05:00
|
|
|
# if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
|
2005-01-25 00:09:22 -05:00
|
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
2004-12-08 13:14:15 -05:00
|
|
|
cmd = args.shift
|
|
|
|
else
|
|
|
|
cmd = Proc.new
|
|
|
|
end
|
2004-11-07 09:53:02 -05:00
|
|
|
Tk.bind(self, context, cmd, *args)
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
|
2004-12-08 13:14:15 -05:00
|
|
|
#def bind_append(context, cmd=Proc.new, *args)
|
|
|
|
# Tk.bind_append(self, context, cmd, *args)
|
|
|
|
#end
|
|
|
|
def bind_append(context, *args)
|
2004-12-16 02:13:14 -05:00
|
|
|
# if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
|
2005-01-25 00:09:22 -05:00
|
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
2004-12-08 13:14:15 -05:00
|
|
|
cmd = args.shift
|
|
|
|
else
|
|
|
|
cmd = Proc.new
|
|
|
|
end
|
2004-11-07 09:53:02 -05:00
|
|
|
Tk.bind_append(self, context, cmd, *args)
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def bind_remove(context)
|
|
|
|
Tk.bind_remove(self, context)
|
|
|
|
end
|
|
|
|
|
|
|
|
def bindinfo(context=nil)
|
|
|
|
Tk.bindinfo(self, context)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
module TkTreatFont
|
2004-07-01 05:38:48 -04:00
|
|
|
def __font_optkeys
|
|
|
|
['font']
|
|
|
|
end
|
|
|
|
private :__font_optkeys
|
|
|
|
|
|
|
|
def __pathname
|
|
|
|
self.path
|
|
|
|
end
|
|
|
|
private :__pathname
|
|
|
|
|
|
|
|
################################
|
|
|
|
|
|
|
|
def font_configinfo(key = nil)
|
|
|
|
optkeys = __font_optkeys
|
|
|
|
if key && !optkeys.find{|opt| opt.to_s == key.to_s}
|
|
|
|
fail ArgumentError, "unknown font option name `#{key}'"
|
|
|
|
end
|
|
|
|
|
|
|
|
win, tag = __pathname.split(':')
|
|
|
|
|
|
|
|
if key
|
|
|
|
pathname = [win, tag, key].join(';')
|
|
|
|
TkFont.used_on(pathname) ||
|
2004-11-03 03:09:55 -05:00
|
|
|
TkFont.init_widget_font(pathname, *__confinfo_cmd)
|
2004-07-01 05:38:48 -04:00
|
|
|
elsif optkeys.size == 1
|
|
|
|
pathname = [win, tag, optkeys[0]].join(';')
|
|
|
|
TkFont.used_on(pathname) ||
|
2004-11-03 03:09:55 -05:00
|
|
|
TkFont.init_widget_font(pathname, *__confinfo_cmd)
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
|
|
|
fonts = {}
|
|
|
|
optkeys.each{|key|
|
2004-10-11 00:51:21 -04:00
|
|
|
key = key.to_s
|
|
|
|
pathname = [win, tag, key].join(';')
|
|
|
|
fonts[key] =
|
|
|
|
TkFont.used_on(pathname) ||
|
2004-11-03 03:09:55 -05:00
|
|
|
TkFont.init_widget_font(pathname, *__confinfo_cmd)
|
2004-07-01 05:38:48 -04:00
|
|
|
}
|
|
|
|
fonts
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
2000-04-10 01:57:37 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
alias fontobj font_configinfo
|
2000-04-10 01:57:37 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def font_configure(slot)
|
2004-07-01 05:38:48 -04:00
|
|
|
pathname = __pathname
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
slot = _symbolkey2str(slot)
|
2000-01-17 03:37:53 -05:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
__font_optkeys.each{|optkey|
|
|
|
|
optkey = optkey.to_s
|
|
|
|
l_optkey = 'latin' << optkey
|
|
|
|
a_optkey = 'ascii' << optkey
|
|
|
|
k_optkey = 'kanji' << optkey
|
|
|
|
|
|
|
|
if slot.key?(optkey)
|
2004-10-11 00:51:21 -04:00
|
|
|
fnt = slot.delete(optkey)
|
|
|
|
if fnt.kind_of?(TkFont)
|
|
|
|
slot.delete(l_optkey)
|
|
|
|
slot.delete(a_optkey)
|
|
|
|
slot.delete(k_optkey)
|
|
|
|
|
|
|
|
fnt.call_font_configure([pathname, optkey], *(__config_cmd << {}))
|
|
|
|
next
|
|
|
|
else
|
|
|
|
if fnt
|
|
|
|
if (slot.key?(l_optkey) ||
|
|
|
|
slot.key?(a_optkey) ||
|
|
|
|
slot.key?(k_optkey))
|
|
|
|
fnt = TkFont.new(fnt)
|
|
|
|
|
|
|
|
lfnt = slot.delete(l_optkey)
|
|
|
|
lfnt = slot.delete(a_optkey) if slot.key?(a_optkey)
|
|
|
|
kfnt = slot.delete(k_optkey)
|
|
|
|
|
|
|
|
fnt.latin_replace(lfnt) if lfnt
|
|
|
|
fnt.kanji_replace(kfnt) if kfnt
|
|
|
|
|
|
|
|
fnt.call_font_configure([pathname, optkey],
|
|
|
|
*(__config_cmd << {}))
|
|
|
|
next
|
|
|
|
else
|
|
|
|
fnt = hash_kv(fnt) if fnt.kind_of?(Hash)
|
|
|
|
tk_call(*(__config_cmd << "-#{optkey}" << fnt))
|
|
|
|
end
|
|
|
|
end
|
|
|
|
next
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
2000-01-17 03:37:53 -05:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
lfnt = slot.delete(l_optkey)
|
|
|
|
lfnt = slot.delete(a_optkey) if slot.key?(a_optkey)
|
|
|
|
kfnt = slot.delete(k_optkey)
|
|
|
|
|
|
|
|
if lfnt && kfnt
|
2004-10-11 00:51:21 -04:00
|
|
|
TkFont.new(lfnt, kfnt).call_font_configure([pathname, optkey],
|
|
|
|
*(__config_cmd << {}))
|
2004-07-01 05:38:48 -04:00
|
|
|
elsif lfnt
|
2004-10-11 00:51:21 -04:00
|
|
|
latinfont_configure([lfnt, optkey])
|
2004-07-01 05:38:48 -04:00
|
|
|
elsif kfnt
|
2004-10-11 00:51:21 -04:00
|
|
|
kanjifont_configure([kfnt, optkey])
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
}
|
2001-05-06 11:06:00 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
# configure other (without font) options
|
|
|
|
tk_call(*(__config_cmd.concat(hash_kv(slot)))) if slot != {}
|
2004-05-01 12:09:54 -04:00
|
|
|
self
|
2000-01-17 03:37:53 -05:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def latinfont_configure(ltn, keys=nil)
|
2004-07-01 05:38:48 -04:00
|
|
|
if ltn.kind_of?(Array)
|
|
|
|
key = ltn[1]
|
|
|
|
ltn = ltn[0]
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2004-07-01 05:38:48 -04:00
|
|
|
key = nil
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
2003-07-17 01:23:54 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
optkeys = __font_optkeys
|
|
|
|
if key && !optkeys.find{|opt| opt.to_s == key.to_s}
|
|
|
|
fail ArgumentError, "unknown font option name `#{key}'"
|
|
|
|
end
|
|
|
|
|
|
|
|
win, tag = __pathname.split(':')
|
|
|
|
|
|
|
|
optkeys = [key] if key
|
|
|
|
|
|
|
|
optkeys.each{|optkey|
|
|
|
|
optkey = optkey.to_s
|
|
|
|
|
|
|
|
pathname = [win, tag, optkey].join(';')
|
|
|
|
|
|
|
|
if (fobj = TkFont.used_on(pathname))
|
2004-10-11 00:51:21 -04:00
|
|
|
fobj = TkFont.new(fobj) # create a new TkFont object
|
2004-07-01 05:38:48 -04:00
|
|
|
elsif Tk::JAPANIZED_TK
|
2004-10-11 00:51:21 -04:00
|
|
|
fobj = fontobj # create a new TkFont object
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
ltn = hash_kv(ltn) if ltn.kind_of?(Hash)
|
|
|
|
tk_call(*(__config_cmd << "-#{optkey}" << ltn))
|
|
|
|
next
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
if fobj.kind_of?(TkFont)
|
2004-10-11 00:51:21 -04:00
|
|
|
if ltn.kind_of?(TkFont)
|
|
|
|
conf = {}
|
|
|
|
ltn.latin_configinfo.each{|key,val| conf[key] = val}
|
|
|
|
if keys
|
|
|
|
fobj.latin_configure(conf.update(keys))
|
|
|
|
else
|
|
|
|
fobj.latin_configure(conf)
|
|
|
|
end
|
|
|
|
else
|
|
|
|
fobj.latin_replace(ltn)
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
2003-06-25 10:40:32 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
fobj.call_font_configure([pathname, optkey], *(__config_cmd << {}))
|
|
|
|
}
|
|
|
|
self
|
2000-01-17 03:37:53 -05:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
alias asciifont_configure latinfont_configure
|
2000-01-17 03:37:53 -05:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def kanjifont_configure(knj, keys=nil)
|
2004-07-01 05:38:48 -04:00
|
|
|
if knj.kind_of?(Array)
|
|
|
|
key = knj[1]
|
|
|
|
knj = knj[0]
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2004-07-01 05:38:48 -04:00
|
|
|
key = nil
|
|
|
|
end
|
|
|
|
|
|
|
|
optkeys = __font_optkeys
|
|
|
|
if key && !optkeys.find{|opt| opt.to_s == key.to_s}
|
|
|
|
fail ArgumentError, "unknown font option name `#{key}'"
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
2000-01-17 03:37:53 -05:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
win, tag = __pathname.split(':')
|
|
|
|
|
|
|
|
optkeys = [key] if key
|
|
|
|
|
|
|
|
optkeys.each{|optkey|
|
|
|
|
optkey = optkey.to_s
|
|
|
|
|
|
|
|
pathname = [win, tag, optkey].join(';')
|
|
|
|
|
|
|
|
if (fobj = TkFont.used_on(pathname))
|
2004-10-11 00:51:21 -04:00
|
|
|
fobj = TkFont.new(fobj) # create a new TkFont object
|
2004-07-01 05:38:48 -04:00
|
|
|
elsif Tk::JAPANIZED_TK
|
2004-10-11 00:51:21 -04:00
|
|
|
fobj = fontobj # create a new TkFont object
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
knj = hash_kv(knj) if knj.kind_of?(Hash)
|
|
|
|
tk_call(*(__config_cmd << "-#{optkey}" << knj))
|
|
|
|
next
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
if fobj.kind_of?(TkFont)
|
2004-10-11 00:51:21 -04:00
|
|
|
if knj.kind_of?(TkFont)
|
|
|
|
conf = {}
|
|
|
|
knj.kanji_configinfo.each{|key,val| conf[key] = val}
|
|
|
|
if keys
|
|
|
|
fobj.kanji_configure(conf.update(keys))
|
|
|
|
else
|
|
|
|
fobj.kanji_configure(conf)
|
|
|
|
end
|
|
|
|
else
|
|
|
|
fobj.kanji_replace(knj)
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
2000-06-12 03:48:31 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
fobj.call_font_configure([pathname, optkey], *(__config_cmd << {}))
|
|
|
|
}
|
|
|
|
self
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
|
|
|
|
2005-03-10 05:13:30 -05:00
|
|
|
def font_copy(win, wintag=nil, winkey=nil, targetkey=nil)
|
2004-07-01 05:38:48 -04:00
|
|
|
if wintag
|
|
|
|
if winkey
|
2005-03-10 05:13:30 -05:00
|
|
|
fnt = win.tagfontobj(wintag, winkey).dup
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
2005-03-10 05:13:30 -05:00
|
|
|
fnt = win.tagfontobj(wintag).dup
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2004-07-01 05:38:48 -04:00
|
|
|
if winkey
|
2005-03-10 05:13:30 -05:00
|
|
|
fnt = win.fontobj(winkey).dup
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
2005-03-10 05:13:30 -05:00
|
|
|
fnt = win.fontobj.dup
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
if targetkey
|
|
|
|
fnt.call_font_configure([__pathname, targetkey], *(__config_cmd << {}))
|
|
|
|
else
|
|
|
|
fnt.call_font_configure(__pathname, *(__config_cmd << {}))
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
self
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
|
|
|
|
2005-03-10 05:13:30 -05:00
|
|
|
def latinfont_copy(win, wintag=nil, winkey=nil, targetkey=nil)
|
2004-07-01 05:38:48 -04:00
|
|
|
if targetkey
|
|
|
|
fontobj(targetkey).dup.call_font_configure([__pathname, targetkey],
|
2004-10-11 00:51:21 -04:00
|
|
|
*(__config_cmd << {}))
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
|
|
|
fontobj.dup.call_font_configure(__pathname, *(__config_cmd << {}))
|
|
|
|
end
|
|
|
|
|
|
|
|
if wintag
|
|
|
|
if winkey
|
2005-03-10 05:13:30 -05:00
|
|
|
fontobj.latin_replace(win.tagfontobj(wintag, winkey).latin_font_id)
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
2005-03-10 05:13:30 -05:00
|
|
|
fontobj.latin_replace(win.tagfontobj(wintag).latin_font_id)
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2004-07-01 05:38:48 -04:00
|
|
|
if winkey
|
2005-03-10 05:13:30 -05:00
|
|
|
fontobj.latin_replace(win.fontobj(winkey).latin_font_id)
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
2005-03-10 05:13:30 -05:00
|
|
|
fontobj.latin_replace(win.fontobj.latin_font_id)
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
self
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
alias asciifont_copy latinfont_copy
|
2003-06-18 15:46:20 -04:00
|
|
|
|
2005-03-10 05:13:30 -05:00
|
|
|
def kanjifont_copy(win, wintag=nil, winkey=nil, targetkey=nil)
|
2004-07-01 05:38:48 -04:00
|
|
|
if targetkey
|
|
|
|
fontobj(targetkey).dup.call_font_configure([__pathname, targetkey],
|
2004-10-11 00:51:21 -04:00
|
|
|
*(__config_cmd << {}))
|
2002-02-28 01:53:33 -05:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
fontobj.dup.call_font_configure(__pathname, *(__config_cmd << {}))
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
if wintag
|
|
|
|
if winkey
|
2005-03-10 05:13:30 -05:00
|
|
|
fontobj.kanji_replace(win.tagfontobj(wintag, winkey).kanji_font_id)
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
2005-03-10 05:13:30 -05:00
|
|
|
fontobj.kanji_replace(win.tagfontobj(wintag).kanji_font_id)
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
else
|
|
|
|
if winkey
|
2005-03-10 05:13:30 -05:00
|
|
|
fontobj.kanji_replace(win.fontobj(winkey).kanji_font_id)
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
2005-03-10 05:13:30 -05:00
|
|
|
fontobj.kanji_replace(win.fontobj.kanji_font_id)
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
self
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2003-12-20 10:15:51 -05:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
module TkConfigMethod
|
|
|
|
include TkUtil
|
|
|
|
include TkTreatFont
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def __cget_cmd
|
|
|
|
[self.path, 'cget']
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
private :__cget_cmd
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def __config_cmd
|
|
|
|
[self.path, 'configure']
|
2002-02-28 01:53:33 -05:00
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
private :__config_cmd
|
2002-02-28 01:53:33 -05:00
|
|
|
|
2004-11-03 03:09:55 -05:00
|
|
|
def __confinfo_cmd
|
|
|
|
__config_cmd
|
|
|
|
end
|
|
|
|
private :__config_cmd
|
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def __configinfo_struct
|
|
|
|
{:key=>0, :alias=>1, :db_name=>1, :db_class=>2,
|
|
|
|
:default_value=>3, :current_value=>4}
|
2002-02-28 01:53:33 -05:00
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
private :__configinfo_struct
|
2002-02-28 01:53:33 -05:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def __numval_optkeys
|
|
|
|
[]
|
|
|
|
end
|
|
|
|
private :__numval_optkeys
|
1999-12-06 04:04:03 -05:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def __numstrval_optkeys
|
|
|
|
[]
|
|
|
|
end
|
|
|
|
private :__numstrval_optkeys
|
2003-06-18 15:46:20 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def __boolval_optkeys
|
|
|
|
[]
|
|
|
|
end
|
|
|
|
private :__boolval_optkeys
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def __strval_optkeys
|
|
|
|
['text', 'label', 'show', 'data', 'file']
|
2000-01-31 22:12:21 -05:00
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
private :__strval_optkeys
|
2004-05-01 12:09:54 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def __listval_optkeys
|
|
|
|
[]
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
private :__listval_optkeys
|
2004-05-01 12:09:54 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def __numlistval_optkeys
|
|
|
|
[]
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
private :__numlistval_optkeys
|
|
|
|
|
|
|
|
def __methodcall_optkeys # { key=>method, ... }
|
|
|
|
{}
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
private :__methodcall_optkeys
|
|
|
|
|
|
|
|
def __keyonly_optkeys # { def_key=>undef_key or nil, ... }
|
|
|
|
{}
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
private :__keyonly_optkeys
|
2004-05-01 12:09:54 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def __conv_keyonly_opts(keys)
|
|
|
|
return keys unless keys.kind_of?(Hash)
|
|
|
|
keyonly = __keyonly_optkeys
|
|
|
|
keys2 = {}
|
|
|
|
keys.each{|k, v|
|
|
|
|
optkey = keyonly.find{|kk,vv| kk.to_s == k.to_s}
|
|
|
|
if optkey
|
2004-10-11 00:51:21 -04:00
|
|
|
defkey, undefkey = optkey
|
|
|
|
if v
|
|
|
|
keys2[defkey.to_s] = None
|
|
|
|
elsif undefkey
|
|
|
|
keys2[undefkey.to_s] = None
|
|
|
|
else
|
|
|
|
# remove key
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
keys2[k.to_s] = v
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
}
|
|
|
|
keys2
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def config_hash_kv(keys, enc_mode = nil, conf = nil)
|
|
|
|
hash_kv(__conv_keyonly_opts(keys), enc_mode, conf)
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
################################
|
2000-06-12 03:48:31 -04:00
|
|
|
|
2004-07-06 05:42:12 -04:00
|
|
|
def [](id)
|
|
|
|
cget(id)
|
|
|
|
end
|
|
|
|
|
|
|
|
def []=(id, val)
|
|
|
|
configure(id, val)
|
|
|
|
val
|
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def cget(slot)
|
2005-03-26 08:58:11 -05:00
|
|
|
orig_slot = slot
|
2004-07-01 05:38:48 -04:00
|
|
|
slot = slot.to_s
|
2005-03-26 08:58:11 -05:00
|
|
|
|
|
|
|
if slot.length == 0
|
|
|
|
fail ArgumentError, "Invalid option `#{orig_slot.inspect}'"
|
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
|
|
|
|
if ( method = _symbolkey2str(__methodcall_optkeys)[slot] )
|
|
|
|
return self.__send__(method)
|
|
|
|
end
|
|
|
|
|
|
|
|
case slot
|
|
|
|
when /^(#{__numval_optkeys.join('|')})$/
|
|
|
|
begin
|
2004-10-11 00:51:21 -04:00
|
|
|
number(tk_call_without_enc(*(__cget_cmd << "-#{slot}")))
|
2004-07-01 05:38:48 -04:00
|
|
|
rescue
|
2004-10-11 00:51:21 -04:00
|
|
|
nil
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__numstrval_optkeys.join('|')})$/
|
|
|
|
num_or_str(tk_call_without_enc(*(__cget_cmd << "-#{slot}")))
|
|
|
|
|
|
|
|
when /^(#{__boolval_optkeys.join('|')})$/
|
|
|
|
begin
|
2004-10-11 00:51:21 -04:00
|
|
|
bool(tk_call_without_enc(*(__cget_cmd << "-#{slot}")))
|
2004-07-01 05:38:48 -04:00
|
|
|
rescue
|
2004-10-11 00:51:21 -04:00
|
|
|
nil
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__listval_optkeys.join('|')})$/
|
|
|
|
simplelist(tk_call_without_enc(*(__cget_cmd << "-#{slot}")))
|
|
|
|
|
|
|
|
when /^(#{__numlistval_optkeys.join('|')})$/
|
|
|
|
conf = tk_call_without_enc(*(__cget_cmd << "-#{slot}"))
|
|
|
|
if conf =~ /^[0-9+-]/
|
2004-10-11 00:51:21 -04:00
|
|
|
list(conf)
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
conf
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__strval_optkeys.join('|')})$/
|
|
|
|
_fromUTF8(tk_call_without_enc(*(__cget_cmd << "-#{slot}")))
|
|
|
|
|
|
|
|
when /^(|latin|ascii|kanji)(#{__font_optkeys.join('|')})$/
|
|
|
|
fontcode = $1
|
|
|
|
fontkey = $2
|
|
|
|
fnt = tk_tcl2ruby(tk_call_without_enc(*(__cget_cmd << "-#{fontkey}")), true)
|
2003-08-29 04:34:14 -04:00
|
|
|
unless fnt.kind_of?(TkFont)
|
2004-10-11 00:51:21 -04:00
|
|
|
fnt = fontobj(fontkey)
|
2003-08-29 04:34:14 -04:00
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
if fontcode == 'kanji' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
|
2004-10-11 00:51:21 -04:00
|
|
|
# obsolete; just for compatibility
|
|
|
|
fnt.kanji_font
|
2003-09-02 01:04:30 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
fnt
|
2003-09-02 01:04:30 -04:00
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
|
2000-11-27 04:23:38 -05:00
|
|
|
else
|
2004-07-01 05:38:48 -04:00
|
|
|
tk_tcl2ruby(tk_call_without_enc(*(__cget_cmd << "-#{slot}")), true)
|
2000-11-27 04:23:38 -05:00
|
|
|
end
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def configure(slot, value=None)
|
|
|
|
if slot.kind_of? Hash
|
2004-07-01 05:38:48 -04:00
|
|
|
slot = _symbolkey2str(slot)
|
|
|
|
|
|
|
|
__methodcall_optkeys.each{|key, method|
|
2004-10-11 00:51:21 -04:00
|
|
|
value = slot.delete(key.to_s)
|
|
|
|
self.__send__(method, value) if value
|
2004-07-01 05:38:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
__keyonly_optkeys.each{|defkey, undefkey|
|
2004-10-11 00:51:21 -04:00
|
|
|
conf = slot.find{|kk, vv| kk == defkey.to_s}
|
|
|
|
if conf
|
|
|
|
k, v = conf
|
|
|
|
if v
|
|
|
|
slot[k] = None
|
|
|
|
else
|
|
|
|
slot[undefkey.to_s] = None if undefkey
|
|
|
|
slot.delete(k)
|
|
|
|
end
|
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (slot.find{|k, v| k =~ /^(|latin|ascii|kanji)(#{__font_optkeys.join('|')})$/})
|
2004-10-11 00:51:21 -04:00
|
|
|
font_configure(slot)
|
2004-05-01 12:09:54 -04:00
|
|
|
elsif slot.size > 0
|
2004-10-11 00:51:21 -04:00
|
|
|
tk_call(*(__config_cmd.concat(hash_kv(slot))))
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
else
|
2005-03-26 08:58:11 -05:00
|
|
|
orig_slot = slot
|
2004-07-01 05:38:48 -04:00
|
|
|
slot = slot.to_s
|
2005-03-26 08:58:11 -05:00
|
|
|
if slot.length == 0
|
|
|
|
fail ArgumentError, "Invalid option `#{orig_slot.inspect}'"
|
|
|
|
end
|
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
if ( conf = __keyonly_optkeys.find{|k, v| k.to_s == slot} )
|
2004-10-11 00:51:21 -04:00
|
|
|
defkey, undefkey = conf
|
|
|
|
if value
|
|
|
|
tk_call(*(__config_cmd << "-#{defkey}"))
|
|
|
|
elsif undefkey
|
|
|
|
tk_call(*(__config_cmd << "-#{undefkey}"))
|
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
elsif ( method = _symbolkey2str(__methodcall_optkeys)[slot] )
|
2004-10-11 00:51:21 -04:00
|
|
|
self.__send__(method, value)
|
2004-07-01 05:38:48 -04:00
|
|
|
elsif (slot =~ /^(|latin|ascii|kanji)(#{__font_optkeys.join('|')})$/)
|
2004-10-11 00:51:21 -04:00
|
|
|
if value == None
|
|
|
|
fontobj($2)
|
|
|
|
else
|
|
|
|
font_configure({slot=>value})
|
|
|
|
end
|
2000-06-12 03:48:31 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
tk_call(*(__config_cmd << "-#{slot}" << value))
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
self
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def configure_cmd(slot, value)
|
|
|
|
configure(slot, install_cmd(value))
|
|
|
|
end
|
|
|
|
|
|
|
|
def configinfo(slot = nil)
|
|
|
|
if TkComm::GET_CONFIGINFO_AS_ARRAY
|
2005-03-26 08:58:11 -05:00
|
|
|
if (slot &&
|
|
|
|
slot.to_s =~ /^(|latin|ascii|kanji)(#{__font_optkeys.join('|')})$/)
|
2004-10-11 00:51:21 -04:00
|
|
|
fontkey = $2
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{fontkey}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{fontkey}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
conf[__configinfo_struct[:key]] =
|
|
|
|
conf[__configinfo_struct[:key]][1..-1]
|
|
|
|
if ( ! __configinfo_struct[:alias] \
|
|
|
|
|| conf.size > __configinfo_struct[:alias] + 1 )
|
|
|
|
conf[__configinfo_struct[:current_value]] = fontobj(fontkey)
|
|
|
|
elsif ( __configinfo_struct[:alias] \
|
|
|
|
&& conf.size == __configinfo_struct[:alias] + 1 \
|
|
|
|
&& conf[__configinfo_struct[:alias]][0] == ?- )
|
|
|
|
conf[__configinfo_struct[:alias]] =
|
|
|
|
conf[__configinfo_struct[:alias]][1..-1]
|
|
|
|
end
|
|
|
|
conf
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
if slot
|
|
|
|
slot = slot.to_s
|
|
|
|
case slot
|
|
|
|
when /^(#{__methodcall_optkeys.keys.join('|')})$/
|
|
|
|
method = _symbolkey2str(__methodcall_optkeys)[slot]
|
|
|
|
return [slot, '', '', '', self.__send__(method)]
|
|
|
|
|
|
|
|
when /^(#{__numval_optkeys.join('|')})$/
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]])
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
number(conf[__configinfo_struct[:default_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:default_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
number(conf[__configinfo_struct[:current_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:current_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__numstrval_optkeys.join('|')})$/
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]])
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
num_or_str(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
num_or_str(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__boolval_optkeys.join('|')})$/
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]])
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
bool(conf[__configinfo_struct[:default_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:default_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
bool(conf[__configinfo_struct[:current_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:current_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__listval_optkeys.join('|')})$/
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]])
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
simplelist(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
simplelist(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__numlistval_optkeys.join('|')})$/
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] =~ /^[0-9]/ )
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
list(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] \
|
|
|
|
&& conf[__configinfo_struct[:current_value]] =~ /^[0-9]/ )
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
list(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__strval_optkeys.join('|')})$/
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
else
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_list(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_list(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), 0, false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
end
|
|
|
|
conf[__configinfo_struct[:key]] =
|
|
|
|
conf[__configinfo_struct[:key]][1..-1]
|
|
|
|
|
|
|
|
if ( __configinfo_struct[:alias] \
|
|
|
|
&& conf.size == __configinfo_struct[:alias] + 1 \
|
|
|
|
&& conf[__configinfo_struct[:alias]][0] == ?- )
|
|
|
|
conf[__configinfo_struct[:alias]] =
|
|
|
|
conf[__configinfo_struct[:alias]][1..-1]
|
|
|
|
end
|
|
|
|
|
|
|
|
conf
|
|
|
|
|
|
|
|
else
|
2005-05-25 07:09:59 -04:00
|
|
|
# ret = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*__confinfo_cmd))).collect{|conflist|
|
|
|
|
# conf = tk_split_simplelist(conflist)
|
|
|
|
ret = tk_split_simplelist(tk_call_without_enc(*__confinfo_cmd), false, false).collect{|conflist|
|
|
|
|
conf = tk_split_simplelist(conflist, false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
conf[__configinfo_struct[:key]] =
|
|
|
|
conf[__configinfo_struct[:key]][1..-1]
|
|
|
|
|
|
|
|
case conf[__configinfo_struct[:key]]
|
|
|
|
when /^(#{__strval_optkeys.join('|')})$/
|
|
|
|
# do nothing
|
|
|
|
|
|
|
|
when /^(#{__numval_optkeys.join('|')})$/
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
number(conf[__configinfo_struct[:default_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:default_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
number(conf[__configinfo_struct[:current_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:current_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__numstrval_optkeys.join('|')})$/
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
num_or_str(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
num_or_str(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__boolval_optkeys.join('|')})$/
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
bool(conf[__configinfo_struct[:default_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:default_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
bool(conf[__configinfo_struct[:current_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:current_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__listval_optkeys.join('|')})$/
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
simplelist(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
simplelist(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__numlistval_optkeys.join('|')})$/
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] =~ /^[0-9]/ )
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
list(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] \
|
|
|
|
&& conf[__configinfo_struct[:current_value]] =~ /^[0-9]/ )
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
list(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
|
|
|
|
else
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
if conf[__configinfo_struct[:default_value]].index('{')
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
tk_split_list(conf[__configinfo_struct[:default_value]])
|
|
|
|
else
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
tk_tcl2ruby(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if conf[__configinfo_struct[:current_value]]
|
|
|
|
if conf[__configinfo_struct[:current_value]].index('{')
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
tk_split_list(conf[__configinfo_struct[:current_value]])
|
|
|
|
else
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
tk_tcl2ruby(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
if ( __configinfo_struct[:alias] \
|
|
|
|
&& conf.size == __configinfo_struct[:alias] + 1 \
|
|
|
|
&& conf[__configinfo_struct[:alias]][0] == ?- )
|
|
|
|
conf[__configinfo_struct[:alias]] =
|
|
|
|
conf[__configinfo_struct[:alias]][1..-1]
|
|
|
|
end
|
|
|
|
|
|
|
|
conf
|
|
|
|
}
|
|
|
|
|
|
|
|
__font_optkeys.each{|optkey|
|
|
|
|
optkey = optkey.to_s
|
|
|
|
fontconf = ret.assoc(optkey)
|
|
|
|
if fontconf && fontconf.size > 2
|
|
|
|
ret.delete_if{|inf| inf[0] =~ /^(|latin|ascii|kanji)#{optkey}$/}
|
|
|
|
fontconf[__configinfo_struct[:current_value]] = fontobj(optkey)
|
|
|
|
ret.push(fontconf)
|
|
|
|
end
|
|
|
|
}
|
|
|
|
|
|
|
|
__methodcall_optkeys.each{|optkey, method|
|
|
|
|
ret << [optkey.to_s, '', '', '', self.__send__(method)]
|
|
|
|
}
|
|
|
|
|
|
|
|
ret
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
|
2005-03-26 08:58:11 -05:00
|
|
|
if (slot &&
|
|
|
|
slot.to_s =~ /^(|latin|ascii|kanji)(#{__font_optkeys.join('|')})$/)
|
2004-10-11 00:51:21 -04:00
|
|
|
fontkey = $2
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{fontkey}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{fontkey}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
conf[__configinfo_struct[:key]] =
|
|
|
|
conf[__configinfo_struct[:key]][1..-1]
|
|
|
|
|
|
|
|
if ( ! __configinfo_struct[:alias] \
|
|
|
|
|| conf.size > __configinfo_struct[:alias] + 1 )
|
|
|
|
conf[__configinfo_struct[:current_value]] = fontobj(fontkey)
|
|
|
|
{ conf.shift => conf }
|
|
|
|
elsif ( __configinfo_struct[:alias] \
|
|
|
|
&& conf.size == __configinfo_struct[:alias] + 1 )
|
|
|
|
if conf[__configinfo_struct[:alias]][0] == ?-
|
|
|
|
conf[__configinfo_struct[:alias]] =
|
|
|
|
conf[__configinfo_struct[:alias]][1..-1]
|
|
|
|
end
|
|
|
|
{ conf[0] => conf[1] }
|
|
|
|
else
|
|
|
|
{ conf.shift => conf }
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
if slot
|
|
|
|
slot = slot.to_s
|
|
|
|
case slot
|
|
|
|
when /^(#{__methodcall_optkeys.keys.join('|')})$/
|
|
|
|
method = _symbolkey2str(__methodcall_optkeys)[slot]
|
|
|
|
return {slot => ['', '', '', self.__send__(method)]}
|
|
|
|
|
|
|
|
when /^(#{__numval_optkeys.join('|')})$/
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
number(conf[__configinfo_struct[:default_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:default_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
number(conf[__configinfo_struct[:current_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:current_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__numstrval_optkeys.join('|')})$/
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
num_or_str(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
num_or_str(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__boolval_optkeys.join('|')})$/
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
bool(conf[__configinfo_struct[:default_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:default_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
bool(conf[__configinfo_struct[:current_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:current_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__listval_optkeys.join('|')})$/
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
simplelist(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
simplelist(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__numlistval_optkeys.join('|')})$/
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] =~ /^[0-9]/ )
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
list(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] \
|
|
|
|
&& conf[__configinfo_struct[:current_value]] =~ /^[0-9]/ )
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
list(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__strval_optkeys.join('|')})$/
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_simplelist(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_simplelist(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
else
|
2005-05-25 07:09:59 -04:00
|
|
|
# conf = tk_split_list(_fromUTF8(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}"))))
|
|
|
|
conf = tk_split_list(tk_call_without_enc(*(__confinfo_cmd << "-#{slot}")), 0, false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
end
|
|
|
|
conf[__configinfo_struct[:key]] =
|
|
|
|
conf[__configinfo_struct[:key]][1..-1]
|
|
|
|
|
|
|
|
if ( __configinfo_struct[:alias] \
|
|
|
|
&& conf.size == __configinfo_struct[:alias] + 1 )
|
|
|
|
if conf[__configinfo_struct[:alias]][0] == ?-
|
|
|
|
conf[__configinfo_struct[:alias]] =
|
|
|
|
conf[__configinfo_struct[:alias]][1..-1]
|
|
|
|
end
|
|
|
|
{ conf[0] => conf[1] }
|
|
|
|
else
|
|
|
|
{ conf.shift => conf }
|
|
|
|
end
|
|
|
|
|
|
|
|
else
|
|
|
|
ret = {}
|
2005-05-25 07:09:59 -04:00
|
|
|
# tk_split_simplelist(_fromUTF8(tk_call_without_enc(*__confinfo_cmd))).each{|conflist|
|
|
|
|
# conf = tk_split_simplelist(conflist)
|
|
|
|
tk_split_simplelist(tk_call_without_enc(*__confinfo_cmd), false, false).each{|conflist|
|
|
|
|
conf = tk_split_simplelist(conflist, false, true)
|
2004-10-11 00:51:21 -04:00
|
|
|
conf[__configinfo_struct[:key]] =
|
|
|
|
conf[__configinfo_struct[:key]][1..-1]
|
|
|
|
|
|
|
|
case conf[__configinfo_struct[:key]]
|
|
|
|
when /^(#{__strval_optkeys.join('|')})$/
|
|
|
|
# do nothing
|
|
|
|
|
|
|
|
when /^(#{__numval_optkeys.join('|')})$/
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
number(conf[__configinfo_struct[:default_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:default_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
number(conf[__configinfo_struct[:current_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:current_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__numstrval_optkeys.join('|')})$/
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
num_or_str(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
num_or_str(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__boolval_optkeys.join('|')})$/
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
bool(conf[__configinfo_struct[:default_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:default_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
begin
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
bool(conf[__configinfo_struct[:current_value]])
|
|
|
|
rescue
|
|
|
|
conf[__configinfo_struct[:current_value]] = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__listval_optkeys.join('|')})$/
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
simplelist(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] )
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
simplelist(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
|
|
|
|
when /^(#{__numlistval_optkeys.join('|')})$/
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] =~ /^[0-9]/ )
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
list(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
if ( conf[__configinfo_struct[:current_value]] \
|
|
|
|
&& conf[__configinfo_struct[:current_value]] =~ /^[0-9]/ )
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
list(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
|
|
|
|
else
|
|
|
|
if ( __configinfo_struct[:default_value] \
|
|
|
|
&& conf[__configinfo_struct[:default_value]] )
|
|
|
|
if conf[__configinfo_struct[:default_value]].index('{')
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
tk_split_list(conf[__configinfo_struct[:default_value]])
|
|
|
|
else
|
|
|
|
conf[__configinfo_struct[:default_value]] =
|
|
|
|
tk_tcl2ruby(conf[__configinfo_struct[:default_value]])
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if conf[__configinfo_struct[:current_value]]
|
|
|
|
if conf[__configinfo_struct[:current_value]].index('{')
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
tk_split_list(conf[__configinfo_struct[:current_value]])
|
|
|
|
else
|
|
|
|
conf[__configinfo_struct[:current_value]] =
|
|
|
|
tk_tcl2ruby(conf[__configinfo_struct[:current_value]])
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
if ( __configinfo_struct[:alias] \
|
|
|
|
&& conf.size == __configinfo_struct[:alias] + 1 )
|
|
|
|
if conf[__configinfo_struct[:alias]][0] == ?-
|
|
|
|
conf[__configinfo_struct[:alias]] =
|
|
|
|
conf[__configinfo_struct[:alias]][1..-1]
|
|
|
|
end
|
|
|
|
ret[conf[0]] = conf[1]
|
|
|
|
else
|
|
|
|
ret[conf.shift] = conf
|
|
|
|
end
|
|
|
|
}
|
|
|
|
|
|
|
|
__font_optkeys.each{|optkey|
|
|
|
|
optkey = optkey.to_s
|
|
|
|
fontconf = ret[optkey]
|
|
|
|
if fontconf.kind_of?(Array)
|
|
|
|
ret.delete(optkey)
|
|
|
|
ret.delete('latin' << optkey)
|
|
|
|
ret.delete('ascii' << optkey)
|
|
|
|
ret.delete('kanji' << optkey)
|
|
|
|
fontconf[__configinfo_struct[:current_value]] = fontobj(optkey)
|
|
|
|
ret[optkey] = fontconf
|
|
|
|
end
|
|
|
|
}
|
|
|
|
|
|
|
|
__methodcall_optkeys.each{|optkey, method|
|
|
|
|
ret[optkey.to_s] = ['', '', '', self.__send__(method)]
|
|
|
|
}
|
|
|
|
|
|
|
|
ret
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def current_configinfo(slot = nil)
|
|
|
|
if TkComm::GET_CONFIGINFO_AS_ARRAY
|
|
|
|
if slot
|
2004-10-11 00:51:21 -04:00
|
|
|
org_slot = slot
|
|
|
|
begin
|
|
|
|
conf = configinfo(slot)
|
|
|
|
if ( ! __configinfo_struct[:alias] \
|
|
|
|
|| conf.size > __configinfo_struct[:alias] + 1 )
|
|
|
|
return {conf[0] => conf[-1]}
|
|
|
|
end
|
|
|
|
slot = conf[__configinfo_struct[:alias]]
|
|
|
|
end while(org_slot != slot)
|
|
|
|
fail RuntimeError,
|
|
|
|
"there is a configure alias loop about '#{org_slot}'"
|
2003-08-29 04:34:14 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
ret = {}
|
|
|
|
configinfo().each{|conf|
|
|
|
|
if ( ! __configinfo_struct[:alias] \
|
|
|
|
|| conf.size > __configinfo_struct[:alias] + 1 )
|
|
|
|
ret[conf[0]] = conf[-1]
|
|
|
|
end
|
|
|
|
}
|
|
|
|
ret
|
2003-08-29 04:34:14 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
|
|
|
|
ret = {}
|
2004-10-11 00:51:21 -04:00
|
|
|
configinfo(slot).each{|key, conf|
|
|
|
|
ret[key] = conf[-1] if conf.kind_of?(Array)
|
2004-05-01 12:09:54 -04:00
|
|
|
}
|
|
|
|
ret
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
class TkObject<TkKernel
|
2004-07-15 22:12:58 -04:00
|
|
|
extend TkCore
|
2004-07-01 05:38:48 -04:00
|
|
|
include Tk
|
|
|
|
include TkConfigMethod
|
|
|
|
include TkBindCore
|
|
|
|
|
|
|
|
### --> definition is moved to TkUtil module
|
|
|
|
# def path
|
|
|
|
# @path
|
|
|
|
# end
|
|
|
|
|
|
|
|
def epath
|
|
|
|
@path
|
|
|
|
end
|
|
|
|
|
|
|
|
def to_eval
|
|
|
|
@path
|
|
|
|
end
|
|
|
|
|
|
|
|
def tk_send(cmd, *rest)
|
|
|
|
tk_call(path, cmd, *rest)
|
|
|
|
end
|
|
|
|
def tk_send_without_enc(cmd, *rest)
|
|
|
|
tk_call_without_enc(path, cmd, *rest)
|
|
|
|
end
|
|
|
|
def tk_send_with_enc(cmd, *rest)
|
|
|
|
tk_call_with_enc(path, cmd, *rest)
|
|
|
|
end
|
|
|
|
# private :tk_send, :tk_send_without_enc, :tk_send_with_enc
|
|
|
|
|
2005-05-25 17:11:13 -04:00
|
|
|
def tk_send_to_list(cmd, *rest)
|
|
|
|
tk_call_to_list(path, cmd, *rest)
|
|
|
|
end
|
|
|
|
def tk_send_to_list_without_enc(cmd, *rest)
|
|
|
|
tk_call_to_list_without_enc(path, cmd, *rest)
|
|
|
|
end
|
|
|
|
def tk_send_to_list_with_enc(cmd, *rest)
|
|
|
|
tk_call_to_list_with_enc(path, cmd, *rest)
|
|
|
|
end
|
|
|
|
def tk_send_to_simplelist(cmd, *rest)
|
|
|
|
tk_call_to_simplelist(path, cmd, *rest)
|
|
|
|
end
|
|
|
|
def tk_send_to_simplelist_without_enc(cmd, *rest)
|
|
|
|
tk_call_to_simplelist_without_enc(path, cmd, *rest)
|
|
|
|
end
|
|
|
|
def tk_send_to_simplelist_with_enc(cmd, *rest)
|
|
|
|
tk_call_to_simplelist_with_enc(path, cmd, *rest)
|
|
|
|
end
|
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def method_missing(id, *args)
|
|
|
|
name = id.id2name
|
|
|
|
case args.length
|
|
|
|
when 1
|
|
|
|
if name[-1] == ?=
|
2004-10-11 00:51:21 -04:00
|
|
|
configure name[0..-2], args[0]
|
2004-12-02 11:59:02 -05:00
|
|
|
args[0]
|
2004-07-01 05:38:48 -04:00
|
|
|
else
|
2004-10-11 00:51:21 -04:00
|
|
|
configure name, args[0]
|
2004-12-02 11:59:02 -05:00
|
|
|
self
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
when 0
|
|
|
|
begin
|
2004-10-11 00:51:21 -04:00
|
|
|
cget(name)
|
2004-07-01 05:38:48 -04:00
|
|
|
rescue
|
2004-10-11 00:51:21 -04:00
|
|
|
fail NameError,
|
|
|
|
"undefined local variable or method `#{name}' for #{self.to_s}",
|
|
|
|
error_at
|
2004-07-01 05:38:48 -04:00
|
|
|
end
|
|
|
|
else
|
|
|
|
fail NameError, "undefined method `#{name}' for #{self.to_s}", error_at
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2004-07-06 05:42:12 -04:00
|
|
|
=begin
|
2004-07-01 05:38:48 -04:00
|
|
|
def [](id)
|
|
|
|
cget(id)
|
|
|
|
end
|
|
|
|
|
|
|
|
def []=(id, val)
|
|
|
|
configure(id, val)
|
|
|
|
val
|
|
|
|
end
|
2004-07-06 05:42:12 -04:00
|
|
|
=end
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def event_generate(context, keys=nil)
|
|
|
|
if keys
|
|
|
|
#tk_call('event', 'generate', path,
|
2004-10-11 00:51:21 -04:00
|
|
|
# "<#{tk_event_sequence(context)}>", *hash_kv(keys))
|
2004-05-01 12:09:54 -04:00
|
|
|
tk_call_without_enc('event', 'generate', path,
|
2004-10-11 00:51:21 -04:00
|
|
|
"<#{tk_event_sequence(context)}>",
|
|
|
|
*hash_kv(keys, true))
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
|
|
|
#tk_call('event', 'generate', path, "<#{tk_event_sequence(context)}>")
|
|
|
|
tk_call_without_enc('event', 'generate', path,
|
2004-10-11 00:51:21 -04:00
|
|
|
"<#{tk_event_sequence(context)}>")
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def tk_trace_variable(v)
|
2004-07-15 00:49:01 -04:00
|
|
|
#unless v.kind_of?(TkVariable)
|
|
|
|
# fail(ArgumentError, "type error (#{v.class}); must be TkVariable object")
|
|
|
|
#end
|
2004-05-01 12:09:54 -04:00
|
|
|
v
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
private :tk_trace_variable
|
2003-12-09 09:38:15 -05:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def destroy
|
2004-07-08 12:50:07 -04:00
|
|
|
#tk_call 'trace', 'vdelete', @tk_vn, 'w', @var_id if @var_id
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
class TkWindow<TkObject
|
|
|
|
include TkWinfo
|
|
|
|
extend TkBindCore
|
2003-06-18 15:46:20 -04:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
TkCommandNames = [].freeze
|
|
|
|
## ==> If TkCommandNames[0] is a string (not a null string),
|
|
|
|
## assume the string is a Tcl/Tk's create command of the widget class.
|
2004-05-01 12:09:54 -04:00
|
|
|
WidgetClassName = ''.freeze
|
2004-07-01 05:38:48 -04:00
|
|
|
# WidgetClassNames[WidgetClassName] = self
|
|
|
|
## ==> If self is a widget class, entry to the WidgetClassNames table.
|
2004-05-01 12:09:54 -04:00
|
|
|
def self.to_eval
|
|
|
|
self::WidgetClassName
|
|
|
|
end
|
|
|
|
|
|
|
|
def initialize(parent=nil, keys=nil)
|
|
|
|
if parent.kind_of? Hash
|
|
|
|
keys = _symbolkey2str(parent)
|
|
|
|
parent = keys.delete('parent')
|
|
|
|
widgetname = keys.delete('widgetname')
|
|
|
|
install_win(if parent then parent.path end, widgetname)
|
|
|
|
without_creating = keys.delete('without_creating')
|
2005-04-01 12:22:02 -05:00
|
|
|
# if without_creating && !widgetname
|
|
|
|
# fail ArgumentError,
|
|
|
|
# "if set 'without_creating' to true, need to define 'widgetname'"
|
|
|
|
# end
|
2004-05-01 12:09:54 -04:00
|
|
|
elsif keys
|
|
|
|
keys = _symbolkey2str(keys)
|
|
|
|
widgetname = keys.delete('widgetname')
|
|
|
|
install_win(if parent then parent.path end, widgetname)
|
|
|
|
without_creating = keys.delete('without_creating')
|
2005-04-01 12:22:02 -05:00
|
|
|
# if without_creating && !widgetname
|
|
|
|
# fail ArgumentError,
|
|
|
|
# "if set 'without_creating' to true, need to define 'widgetname'"
|
|
|
|
# end
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
|
|
|
install_win(if parent then parent.path end)
|
|
|
|
end
|
|
|
|
if self.method(:create_self).arity == 0
|
|
|
|
p 'create_self has no arg' if $DEBUG
|
|
|
|
create_self unless without_creating
|
|
|
|
if keys
|
|
|
|
# tk_call @path, 'configure', *hash_kv(keys)
|
|
|
|
configure(keys)
|
|
|
|
end
|
2002-02-28 01:53:33 -05:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
p 'create_self has args' if $DEBUG
|
|
|
|
fontkeys = {}
|
2004-07-01 05:38:48 -04:00
|
|
|
methodkeys = {}
|
2004-05-01 12:09:54 -04:00
|
|
|
if keys
|
2004-07-01 05:38:48 -04:00
|
|
|
#['font', 'kanjifont', 'latinfont', 'asciifont'].each{|key|
|
|
|
|
# fontkeys[key] = keys.delete(key) if keys.key?(key)
|
|
|
|
#}
|
2004-10-11 00:51:21 -04:00
|
|
|
__font_optkeys.each{|key|
|
|
|
|
fkey = key.to_s
|
|
|
|
fontkeys[fkey] = keys.delete(fkey) if keys.key?(fkey)
|
2004-07-01 05:38:48 -04:00
|
|
|
|
2004-10-11 00:51:21 -04:00
|
|
|
fkey = "kanji#{key}"
|
|
|
|
fontkeys[fkey] = keys.delete(fkey) if keys.key?(fkey)
|
2004-07-01 05:38:48 -04:00
|
|
|
|
2004-10-11 00:51:21 -04:00
|
|
|
fkey = "latin#{key}"
|
|
|
|
fontkeys[fkey] = keys.delete(fkey) if keys.key?(fkey)
|
2004-07-01 05:38:48 -04:00
|
|
|
|
2004-10-11 00:51:21 -04:00
|
|
|
fkey = "ascii#{key}"
|
|
|
|
fontkeys[fkey] = keys.delete(fkey) if keys.key?(fkey)
|
|
|
|
}
|
2004-07-01 05:38:48 -04:00
|
|
|
|
2004-10-11 00:51:21 -04:00
|
|
|
__methodcall_optkeys.each{|key|
|
|
|
|
key = key.to_s
|
|
|
|
methodkeys[key] = keys.delete(key) if keys.key?(key)
|
|
|
|
}
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
if without_creating && keys
|
2004-07-01 05:38:48 -04:00
|
|
|
#configure(keys)
|
|
|
|
configure(__conv_keyonly_opts(keys))
|
2004-05-01 12:09:54 -04:00
|
|
|
else
|
2004-07-01 05:38:48 -04:00
|
|
|
#create_self(keys)
|
|
|
|
create_self(__conv_keyonly_opts(keys))
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
|
|
|
font_configure(fontkeys) unless fontkeys.empty?
|
2004-07-01 05:38:48 -04:00
|
|
|
configure(methodkeys) unless methodkeys.empty?
|
2002-02-28 01:53:33 -05:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2003-12-09 09:38:15 -05:00
|
|
|
|
2004-07-01 05:38:48 -04:00
|
|
|
def create_self(keys)
|
|
|
|
# may need to override
|
|
|
|
begin
|
|
|
|
cmd = self.class::TkCommandNames[0]
|
|
|
|
fail unless (cmd.kind_of?(String) && cmd.length > 0)
|
|
|
|
rescue
|
|
|
|
fail RuntimeError, "class #{self.class} may be an abstract class"
|
|
|
|
end
|
|
|
|
|
|
|
|
if keys and keys != None
|
|
|
|
tk_call_without_enc(cmd, @path, *hash_kv(keys, true))
|
|
|
|
else
|
|
|
|
tk_call_without_enc(cmd, @path)
|
|
|
|
end
|
2003-06-22 12:17:02 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
private :create_self
|
|
|
|
|
|
|
|
def exist?
|
|
|
|
TkWinfo.exist?(self)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def bind_class
|
|
|
|
@db_class || self.class()
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def database_classname
|
|
|
|
TkWinfo.classname(self)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
def database_class
|
|
|
|
name = database_classname()
|
|
|
|
if WidgetClassNames[name]
|
|
|
|
WidgetClassNames[name]
|
|
|
|
else
|
|
|
|
TkDatabaseClass.new(name)
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
def self.database_classname
|
|
|
|
self::WidgetClassName
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
def self.database_class
|
|
|
|
WidgetClassNames[self::WidgetClassName]
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def pack(keys = nil)
|
|
|
|
#tk_call_without_enc('pack', epath, *hash_kv(keys, true))
|
|
|
|
if keys
|
|
|
|
TkPack.configure(self, keys)
|
|
|
|
else
|
|
|
|
TkPack.configure(self)
|
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
self
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def pack_in(target, keys = nil)
|
|
|
|
if keys
|
|
|
|
keys = keys.dup
|
|
|
|
keys['in'] = target
|
|
|
|
else
|
|
|
|
keys = {'in'=>target}
|
|
|
|
end
|
|
|
|
#tk_call 'pack', epath, *hash_kv(keys)
|
|
|
|
TkPack.configure(self, keys)
|
2003-06-18 15:46:20 -04:00
|
|
|
self
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def pack_forget
|
|
|
|
#tk_call_without_enc('pack', 'forget', epath)
|
|
|
|
TkPack.forget(self)
|
2003-06-18 15:46:20 -04:00
|
|
|
self
|
2000-11-20 02:31:55 -05:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
alias unpack pack_forget
|
|
|
|
|
|
|
|
def pack_config(slot, value=None)
|
|
|
|
#if slot.kind_of? Hash
|
|
|
|
# tk_call 'pack', 'configure', epath, *hash_kv(slot)
|
|
|
|
#else
|
|
|
|
# tk_call 'pack', 'configure', epath, "-#{slot}", value
|
|
|
|
#end
|
|
|
|
if slot.kind_of? Hash
|
|
|
|
TkPack.configure(self, slot)
|
|
|
|
else
|
|
|
|
TkPack.configure(self, slot=>value)
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-06-12 11:25:49 -04:00
|
|
|
alias pack_configure pack_config
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def pack_info()
|
|
|
|
#ilist = list(tk_call('pack', 'info', epath))
|
|
|
|
#info = {}
|
|
|
|
#while key = ilist.shift
|
|
|
|
# info[key[1..-1]] = ilist.shift
|
|
|
|
#end
|
|
|
|
#return info
|
|
|
|
TkPack.info(self)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def pack_propagate(mode=None)
|
|
|
|
#if mode == None
|
|
|
|
# bool(tk_call('pack', 'propagate', epath))
|
|
|
|
#else
|
|
|
|
# tk_call('pack', 'propagate', epath, mode)
|
|
|
|
# self
|
|
|
|
#end
|
|
|
|
if mode == None
|
|
|
|
TkPack.propagate(self)
|
2000-11-27 04:23:38 -05:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
TkPack.propagate(self, mode)
|
|
|
|
self
|
2000-11-27 04:23:38 -05:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def pack_slaves()
|
|
|
|
#list(tk_call('pack', 'slaves', epath))
|
|
|
|
TkPack.slaves(self)
|
|
|
|
end
|
|
|
|
|
|
|
|
def grid(keys = nil)
|
|
|
|
#tk_call 'grid', epath, *hash_kv(keys)
|
|
|
|
if keys
|
|
|
|
TkGrid.configure(self, keys)
|
1999-08-13 01:37:52 -04:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
TkGrid.configure(self)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
self
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def grid_in(target, keys = nil)
|
|
|
|
if keys
|
|
|
|
keys = keys.dup
|
|
|
|
keys['in'] = target
|
1999-08-13 01:37:52 -04:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
keys = {'in'=>target}
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
#tk_call 'grid', epath, *hash_kv(keys)
|
|
|
|
TkGrid.configure(self, keys)
|
|
|
|
self
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2005-03-02 02:06:52 -05:00
|
|
|
def grid_forget
|
2004-05-01 12:09:54 -04:00
|
|
|
#tk_call('grid', 'forget', epath)
|
|
|
|
TkGrid.forget(self)
|
|
|
|
self
|
2000-11-20 02:31:55 -05:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
alias ungrid grid_forget
|
2000-11-20 02:31:55 -05:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def grid_bbox(*args)
|
|
|
|
#list(tk_call('grid', 'bbox', epath, *args))
|
|
|
|
TkGrid.bbox(self, *args)
|
|
|
|
end
|
|
|
|
|
|
|
|
def grid_config(slot, value=None)
|
|
|
|
#if slot.kind_of? Hash
|
|
|
|
# tk_call 'grid', 'configure', epath, *hash_kv(slot)
|
|
|
|
#else
|
|
|
|
# tk_call 'grid', 'configure', epath, "-#{slot}", value
|
|
|
|
#end
|
|
|
|
if slot.kind_of? Hash
|
|
|
|
TkGrid.configure(self, slot)
|
2002-02-28 01:53:33 -05:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
TkGrid.configure(self, slot=>value)
|
2002-02-28 01:53:33 -05:00
|
|
|
end
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-06-12 11:25:49 -04:00
|
|
|
alias grid_configure grid_config
|
2000-06-12 03:48:31 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def grid_columnconfig(index, keys)
|
|
|
|
#tk_call('grid', 'columnconfigure', epath, index, *hash_kv(keys))
|
|
|
|
TkGrid.columnconfigure(self, index, keys)
|
|
|
|
end
|
|
|
|
alias grid_columnconfigure grid_columnconfig
|
2000-06-12 03:48:31 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def grid_rowconfig(index, keys)
|
|
|
|
#tk_call('grid', 'rowconfigure', epath, index, *hash_kv(keys))
|
|
|
|
TkGrid.rowconfigure(self, index, keys)
|
|
|
|
end
|
|
|
|
alias grid_rowconfigure grid_rowconfig
|
2000-06-12 03:48:31 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def grid_columnconfiginfo(index, slot=nil)
|
|
|
|
#if slot
|
|
|
|
# tk_call('grid', 'columnconfigure', epath, index, "-#{slot}").to_i
|
|
|
|
#else
|
|
|
|
# ilist = list(tk_call('grid', 'columnconfigure', epath, index))
|
|
|
|
# info = {}
|
|
|
|
# while key = ilist.shift
|
2004-10-11 00:51:21 -04:00
|
|
|
# info[key[1..-1]] = ilist.shift
|
2004-05-01 12:09:54 -04:00
|
|
|
# end
|
|
|
|
# info
|
|
|
|
#end
|
|
|
|
TkGrid.columnconfiginfo(self, index, slot)
|
|
|
|
end
|
2000-06-12 03:48:31 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def grid_rowconfiginfo(index, slot=nil)
|
|
|
|
#if slot
|
|
|
|
# tk_call('grid', 'rowconfigure', epath, index, "-#{slot}").to_i
|
|
|
|
#else
|
|
|
|
# ilist = list(tk_call('grid', 'rowconfigure', epath, index))
|
|
|
|
# info = {}
|
|
|
|
# while key = ilist.shift
|
2004-10-11 00:51:21 -04:00
|
|
|
# info[key[1..-1]] = ilist.shift
|
2004-05-01 12:09:54 -04:00
|
|
|
# end
|
|
|
|
# info
|
|
|
|
#end
|
|
|
|
TkGrid.rowconfiginfo(self, index, slot)
|
|
|
|
end
|
|
|
|
|
|
|
|
def grid_info()
|
|
|
|
#list(tk_call('grid', 'info', epath))
|
|
|
|
TkGrid.info(self)
|
|
|
|
end
|
|
|
|
|
|
|
|
def grid_location(x, y)
|
|
|
|
#list(tk_call('grid', 'location', epath, x, y))
|
|
|
|
TkGrid.location(self, x, y)
|
|
|
|
end
|
|
|
|
|
|
|
|
def grid_propagate(mode=None)
|
|
|
|
#if mode == None
|
|
|
|
# bool(tk_call('grid', 'propagate', epath))
|
|
|
|
#else
|
|
|
|
# tk_call('grid', 'propagate', epath, mode)
|
|
|
|
# self
|
|
|
|
#end
|
|
|
|
if mode == None
|
|
|
|
TkGrid.propagete(self)
|
2002-02-28 01:53:33 -05:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
TkGrid.propagete(self, mode)
|
|
|
|
self
|
2002-02-28 01:53:33 -05:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def grid_remove()
|
|
|
|
#tk_call 'grid', 'remove', epath
|
|
|
|
TkGrid.remove(self)
|
|
|
|
self
|
|
|
|
end
|
2003-07-23 12:07:35 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def grid_size()
|
|
|
|
#list(tk_call('grid', 'size', epath))
|
|
|
|
TkGrid.size(self)
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def grid_slaves(args)
|
|
|
|
#list(tk_call('grid', 'slaves', epath, *hash_kv(args)))
|
|
|
|
TkGrid.slaves(self, args)
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def place(keys)
|
|
|
|
#tk_call 'place', epath, *hash_kv(keys)
|
|
|
|
TkPlace.configure(self, keys)
|
|
|
|
self
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def place_in(target, keys = nil)
|
|
|
|
if keys
|
|
|
|
keys = keys.dup
|
|
|
|
keys['in'] = target
|
|
|
|
else
|
|
|
|
keys = {'in'=>target}
|
|
|
|
end
|
|
|
|
#tk_call 'place', epath, *hash_kv(keys)
|
|
|
|
TkPlace.configure(self, keys)
|
2003-06-18 15:46:20 -04:00
|
|
|
self
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def place_forget
|
|
|
|
#tk_call 'place', 'forget', epath
|
|
|
|
TkPlace.forget(self)
|
2003-06-18 15:46:20 -04:00
|
|
|
self
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
alias unplace place_forget
|
|
|
|
|
|
|
|
def place_config(slot, value=None)
|
|
|
|
#if slot.kind_of? Hash
|
|
|
|
# tk_call 'place', 'configure', epath, *hash_kv(slot)
|
|
|
|
#else
|
|
|
|
# tk_call 'place', 'configure', epath, "-#{slot}", value
|
|
|
|
#end
|
|
|
|
TkPlace.configure(self, slot, value)
|
|
|
|
end
|
2004-06-12 11:25:49 -04:00
|
|
|
alias place_configure place_config
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def place_configinfo(slot = nil)
|
|
|
|
# for >= Tk8.4a2 ?
|
|
|
|
#if slot
|
|
|
|
# conf = tk_split_list(tk_call('place', 'configure', epath, "-#{slot}") )
|
|
|
|
# conf[0] = conf[0][1..-1]
|
|
|
|
# conf
|
|
|
|
#else
|
|
|
|
# tk_split_simplelist(tk_call('place',
|
2004-10-11 00:51:21 -04:00
|
|
|
# 'configure', epath)).collect{|conflist|
|
|
|
|
# conf = tk_split_simplelist(conflist)
|
|
|
|
# conf[0] = conf[0][1..-1]
|
|
|
|
# conf
|
2004-05-01 12:09:54 -04:00
|
|
|
# }
|
|
|
|
#end
|
2004-06-12 11:25:49 -04:00
|
|
|
TkPlace.configinfo(self, slot)
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def place_info()
|
|
|
|
#ilist = list(tk_call('place', 'info', epath))
|
|
|
|
#info = {}
|
|
|
|
#while key = ilist.shift
|
|
|
|
# info[key[1..-1]] = ilist.shift
|
|
|
|
#end
|
|
|
|
#return info
|
|
|
|
TkPlace.info(self)
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def place_slaves()
|
|
|
|
#list(tk_call('place', 'slaves', epath))
|
|
|
|
TkPlace.slaves(self)
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def set_focus(force=false)
|
|
|
|
if force
|
|
|
|
tk_call_without_enc('focus', '-force', path)
|
|
|
|
else
|
|
|
|
tk_call_without_enc('focus', path)
|
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
self
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
alias focus set_focus
|
|
|
|
|
|
|
|
def grab(opt = nil)
|
|
|
|
unless opt
|
|
|
|
tk_call_without_enc('grab', 'set', path)
|
|
|
|
return self
|
|
|
|
end
|
|
|
|
|
|
|
|
case opt
|
2004-06-14 23:12:40 -04:00
|
|
|
when 'set', :set
|
|
|
|
tk_call_without_enc('grab', 'set', path)
|
|
|
|
return self
|
2004-05-01 12:09:54 -04:00
|
|
|
when 'global', :global
|
|
|
|
#return(tk_call('grab', 'set', '-global', path))
|
|
|
|
tk_call_without_enc('grab', 'set', '-global', path)
|
|
|
|
return self
|
|
|
|
when 'release', :release
|
|
|
|
#return tk_call('grab', 'release', path)
|
|
|
|
tk_call_without_enc('grab', 'release', path)
|
|
|
|
return self
|
|
|
|
when 'current', :current
|
|
|
|
return window(tk_call_without_enc('grab', 'current', path))
|
|
|
|
when 'status', :status
|
|
|
|
return tk_call_without_enc('grab', 'status', path)
|
|
|
|
else
|
2004-06-14 23:12:40 -04:00
|
|
|
return tk_call_without_enc('grab', opt, path)
|
2004-05-01 12:09:54 -04:00
|
|
|
end
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def grab_current
|
|
|
|
grab('current')
|
2003-06-22 12:17:02 -04:00
|
|
|
end
|
2004-06-14 23:12:40 -04:00
|
|
|
alias current_grab grab_current
|
2004-05-01 12:09:54 -04:00
|
|
|
def grab_release
|
|
|
|
grab('release')
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-06-14 23:12:40 -04:00
|
|
|
alias release_grab grab_release
|
2004-05-01 12:09:54 -04:00
|
|
|
def grab_set
|
|
|
|
grab('set')
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-06-14 23:12:40 -04:00
|
|
|
alias set_grab grab_set
|
2004-05-01 12:09:54 -04:00
|
|
|
def grab_set_global
|
|
|
|
grab('global')
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-06-14 23:12:40 -04:00
|
|
|
alias set_global_grab grab_set_global
|
2004-05-01 12:09:54 -04:00
|
|
|
def grab_status
|
|
|
|
grab('status')
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def lower(below=None)
|
|
|
|
# below = below.epath if below.kind_of?(TkObject)
|
|
|
|
below = _epath(below)
|
|
|
|
tk_call 'lower', epath, below
|
2003-06-18 15:46:20 -04:00
|
|
|
self
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2005-05-25 07:09:59 -04:00
|
|
|
alias lower_window lower
|
2004-05-01 12:09:54 -04:00
|
|
|
def raise(above=None)
|
|
|
|
#above = above.epath if above.kind_of?(TkObject)
|
|
|
|
above = _epath(above)
|
|
|
|
tk_call 'raise', epath, above
|
|
|
|
self
|
2000-06-12 03:48:31 -04:00
|
|
|
end
|
2005-05-25 07:09:59 -04:00
|
|
|
alias raise_window raise
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def command(cmd=nil, &b)
|
|
|
|
if cmd
|
|
|
|
configure_cmd('command', cmd)
|
|
|
|
elsif b
|
|
|
|
configure_cmd('command', Proc.new(&b))
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
cget('command')
|
* tkfont.rb: Fix bugs on TkFont.init_widget_font for Tk8.x.
* tkafter.rb: Add self to 1st argument of interval- and loop-proc
TkAfter#current_interval returns an interval (sleep) time value
TkAfter#current_args returns an array of arguments
TkAfter#return_value returns a return value of last loop-proc
e.g.
TkAfter.new(
proc{|obj| 500 - obj.current_interval}, 10,
[proc{|obj| p obj.current_args}, 'proc', 1],
proc{|obj| p obj.current_args; ['return', 2]},
[proc{|obj|
p obj.return_value
p ['proc', obj.current_args[0].call(obj.return_value[1],
obj.current_args[1])]},
proc{|*args| args[0] + args[1]}, 1],
proc{p ['proc', 4]} ).start(100)
* tk*.rb: Allow to use Symbols for parameters.
Allow new notation of constructor (also allow old notation).
e.g.
TkFrame.new('classname'=>'User'){|base|
pack
f = TkFrame.new(base, :classname=>'ButtonFrame').pack
TkButton.new(
:parent => f,
:text => 'Quit',
:command => proc{exit}
).pack(
:fill => :x,
:pady => 2
)
}
* tkcanvas.rb: (TkcItem) Add 'coords' parameter to the canvas item
constructor (for new notation of constructor).
e.g.
c = TkCanvas.new.pack
l = TkcLine.new(c, :coords=>[[0,0], [100,100]])
* tcltklib.c: New 'mainloop' and 'mainloop_watchdog'.
The priority of their event-loop can be controlled.
They accept an optional argument.
If it false, they don't exit although the root widget is destroyed.
This function is sometimes useful, if it is used with 'restart'.
'mainloop' can't treat Thread#join/value in a callback routine.
(e.g. TkButton.new(:command=>proc{p Thread.new{button.invoke}.value}) )
'mainloop_watchdog' can treat them, but watchdog thread is always running
(so, a little heavier than 'mainloop').
If the purpose of using Thread#join/value is to do something under some
safe-level, please use Proc object.
(e.g. :command=>proc{$SAFE=1;proc{$SAFE=2;button.invoke}.call;p $SAFE})
* tk.rb: Support functions of new 'mainloop' and 'mainloop_watchdog'.
* tk.rb: (Tk.restart) Add 'app-name' paramater and 'use' parameter.
'app-name' specifies the name and the resource class of the
application. If 'app-name' is specified to 'xxx', the application
class on the resource database is set to 'Xxx' and the application
name is changed by the same rule of Tk.appname method. 'use'
specifies the main window for embedding the root widget instead of
generating a new window.
* tk.rb: Add new parameter 'widgetname' to the widget constructor to
support effective use of Resource Database. For example, the
resource 'Xxx*quit.text: QUIT' can set the text of the button
generated by the following code.
e.g.
Tk.restart('Xxx')
TkButton.new(nil, 'widgetname'=>'quit', 'command'=>proc{exit}).pack
Tk.mainloop
* tk.rb: TkOption::get always returns a tainted string.
Add TkOption::new_proc_class.
It generates a class to import procedures defined on the resource
database. For example, there is a following resource file.
----< resource-test >------------
*CMD.foo: {|*args| p [$SAFE, :foo, args]}
*CMD.XXX.bar: {|*args| p [$SAFE, :bar, args]}
*Button.command: ruby {p self; p $SAFE; TkOption::CMD::XXX.bar(1,2,3)}
---------------------------------
The following code is a sample of use of the resource file.
e.g.
require 'tk'
TkOption.readfile 'resource-test'
p TkOption.new_proc_class(:CMD, [:foo], 1)
p TkOption.new_proc_class(:XXX, [:bar], 2, false, TkOption::CMD)
TkButton.new(:text=>'test').pack
Tk.mainloop
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2515 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2002-06-04 03:03:33 -04:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def colormodel(model=None)
|
|
|
|
tk_call('tk', 'colormodel', path, model)
|
|
|
|
self
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def caret(keys=nil)
|
|
|
|
TkXIM.caret(path, keys)
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def destroy
|
|
|
|
super
|
|
|
|
children = []
|
|
|
|
rexp = /^#{self.path}\.[^.]+$/
|
|
|
|
TkCore::INTERP.tk_windows.each{|path, obj|
|
|
|
|
children << [path, obj] if path =~ rexp
|
|
|
|
}
|
|
|
|
if defined?(@cmdtbl)
|
|
|
|
for id in @cmdtbl
|
2004-10-11 00:51:21 -04:00
|
|
|
uninstall_cmd id
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
children.each{|path, obj|
|
|
|
|
if defined?(@cmdtbl)
|
2004-10-11 00:51:21 -04:00
|
|
|
for id in @cmdtbl
|
|
|
|
uninstall_cmd id
|
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
TkCore::INTERP.tk_windows.delete(path)
|
|
|
|
}
|
|
|
|
|
|
|
|
begin
|
|
|
|
tk_call_without_enc('destroy', epath)
|
|
|
|
rescue
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
uninstall_win
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def wait_visibility(on_thread = true)
|
|
|
|
if $SAFE >= 4
|
|
|
|
fail SecurityError, "can't wait visibility at $SAFE >= 4"
|
|
|
|
end
|
|
|
|
on_thread &= (Thread.list.size != 1)
|
|
|
|
if on_thread
|
|
|
|
INTERP._thread_tkwait('visibility', path)
|
2003-06-18 15:46:20 -04:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
INTERP._invoke('tkwait', 'visibility', path)
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
def eventloop_wait_visibility
|
|
|
|
wait_visibility(false)
|
|
|
|
end
|
|
|
|
def thread_wait_visibility
|
|
|
|
wait_visibility(true)
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
alias wait wait_visibility
|
|
|
|
alias tkwait wait_visibility
|
|
|
|
alias eventloop_wait eventloop_wait_visibility
|
|
|
|
alias eventloop_tkwait eventloop_wait_visibility
|
|
|
|
alias eventloop_tkwait_visibility eventloop_wait_visibility
|
|
|
|
alias thread_wait thread_wait_visibility
|
|
|
|
alias thread_tkwait thread_wait_visibility
|
|
|
|
alias thread_tkwait_visibility thread_wait_visibility
|
2003-06-18 15:46:20 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def wait_destroy(on_thread = true)
|
|
|
|
if $SAFE >= 4
|
|
|
|
fail SecurityError, "can't wait destroy at $SAFE >= 4"
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
on_thread &= (Thread.list.size != 1)
|
|
|
|
if on_thread
|
|
|
|
INTERP._thread_tkwait('window', epath)
|
2003-06-18 15:46:20 -04:00
|
|
|
else
|
2004-05-01 12:09:54 -04:00
|
|
|
INTERP._invoke('tkwait', 'window', epath)
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
|
|
|
end
|
2004-09-17 02:05:33 -04:00
|
|
|
alias wait_window wait_destroy
|
2004-05-01 12:09:54 -04:00
|
|
|
def eventloop_wait_destroy
|
|
|
|
wait_destroy(false)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-09-17 02:05:33 -04:00
|
|
|
alias eventloop_wait_window eventloop_wait_destroy
|
2004-05-01 12:09:54 -04:00
|
|
|
def thread_wait_destroy
|
|
|
|
wait_destroy(true)
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
2004-09-17 02:05:33 -04:00
|
|
|
alias thread_wait_window thread_wait_destroy
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
alias tkwait_destroy wait_destroy
|
2004-09-17 02:05:33 -04:00
|
|
|
alias tkwait_window wait_destroy
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
alias eventloop_tkwait_destroy eventloop_wait_destroy
|
2004-09-17 02:05:33 -04:00
|
|
|
alias eventloop_tkwait_window eventloop_wait_destroy
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
alias thread_tkwait_destroy thread_wait_destroy
|
2004-09-17 02:05:33 -04:00
|
|
|
alias thread_tkwait_window thread_wait_destroy
|
1999-08-13 01:37:52 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def bindtags(taglist=nil)
|
|
|
|
if taglist
|
|
|
|
fail ArgumentError, "taglist must be Array" unless taglist.kind_of? Array
|
|
|
|
tk_call('bindtags', path, taglist)
|
|
|
|
taglist
|
|
|
|
else
|
|
|
|
list(tk_call('bindtags', path)).collect{|tag|
|
2004-10-11 00:51:21 -04:00
|
|
|
if tag.kind_of?(String)
|
|
|
|
if cls = WidgetClassNames[tag]
|
|
|
|
cls
|
|
|
|
elsif btag = TkBindTag.id2obj(tag)
|
|
|
|
btag
|
|
|
|
else
|
|
|
|
tag
|
|
|
|
end
|
|
|
|
else
|
|
|
|
tag
|
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
}
|
|
|
|
end
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
def bindtags=(taglist)
|
|
|
|
bindtags(taglist)
|
|
|
|
taglist
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def bindtags_shift
|
|
|
|
taglist = bindtags
|
|
|
|
tag = taglist.shift
|
|
|
|
bindtags(taglist)
|
|
|
|
tag
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
2004-05-01 12:09:54 -04:00
|
|
|
|
|
|
|
def bindtags_unshift(tag)
|
|
|
|
bindtags(bindtags().unshift(tag))
|
2003-06-18 15:46:20 -04:00
|
|
|
end
|
1999-08-13 01:37:52 -04:00
|
|
|
end
|
|
|
|
|
2003-06-25 01:49:10 -04:00
|
|
|
|
2003-08-29 04:34:14 -04:00
|
|
|
# freeze core modules
|
2003-11-12 16:11:40 -05:00
|
|
|
#TclTkLib.freeze
|
|
|
|
#TclTkIp.freeze
|
|
|
|
#TkUtil.freeze
|
|
|
|
#TkKernel.freeze
|
|
|
|
#TkComm.freeze
|
|
|
|
#TkComm::Event.freeze
|
|
|
|
#TkCore.freeze
|
|
|
|
#Tk.freeze
|
2003-08-29 04:34:14 -04:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
module Tk
|
2005-06-15 05:30:54 -04:00
|
|
|
RELEASE_DATE = '2005-06-15'.freeze
|
2004-12-22 23:17:03 -05:00
|
|
|
|
2004-05-01 12:09:54 -04:00
|
|
|
autoload :AUTO_PATH, 'tk/variable'
|
|
|
|
autoload :TCL_PACKAGE_PATH, 'tk/variable'
|
|
|
|
autoload :PACKAGE_PATH, 'tk/variable'
|
|
|
|
autoload :TCL_LIBRARY_PATH, 'tk/variable'
|
|
|
|
autoload :LIBRARY_PATH, 'tk/variable'
|
|
|
|
autoload :TCL_PRECISION, 'tk/variable'
|
|
|
|
end
|
2004-07-01 05:38:48 -04:00
|
|
|
|
|
|
|
# call setup script for Tk extension libraries (base configuration)
|
|
|
|
begin
|
|
|
|
require 'tkextlib/setup.rb'
|
|
|
|
rescue LoadError
|
|
|
|
# ignore
|
|
|
|
end
|