summaryrefslogtreecommitdiff
path: root/ext/tk/lib
diff options
context:
space:
mode:
Diffstat (limited to 'ext/tk/lib')
-rw-r--r--ext/tk/lib/README19
-rw-r--r--ext/tk/lib/multi-tk.rb1363
-rw-r--r--ext/tk/lib/tk.rb5883
-rw-r--r--ext/tk/lib/tkafter.rb414
-rw-r--r--ext/tk/lib/tkbgerror.rb29
-rw-r--r--ext/tk/lib/tkcanvas.rb1014
-rw-r--r--ext/tk/lib/tkclass.rb47
-rw-r--r--ext/tk/lib/tkconsole.rb28
-rw-r--r--ext/tk/lib/tkdialog.rb276
-rw-r--r--ext/tk/lib/tkentry.rb292
-rw-r--r--ext/tk/lib/tkfont.rb1390
-rw-r--r--ext/tk/lib/tkmacpkg.rb56
-rw-r--r--ext/tk/lib/tkmenubar.rb143
-rw-r--r--ext/tk/lib/tkmngfocus.rb33
-rw-r--r--ext/tk/lib/tkpalette.rb54
-rw-r--r--ext/tk/lib/tkscrollbox.rb30
-rw-r--r--ext/tk/lib/tktext.rb1302
-rw-r--r--ext/tk/lib/tkvirtevent.rb85
-rw-r--r--ext/tk/lib/tkwinpkg.rb84
19 files changed, 0 insertions, 12542 deletions
diff --git a/ext/tk/lib/README b/ext/tk/lib/README
deleted file mode 100644
index c003adb2c8..0000000000
--- a/ext/tk/lib/README
+++ /dev/null
@@ -1,19 +0,0 @@
-README this file
-multi-tk.rb multiple Tk interpreter (included safe-Tk) support
-tk.rb Tk interface
-tkafter.rb handles Tcl after
-tkbgerror.rb Tk error module
-tkcanvas.rb Tk canvas interface
-tkclass.rb provides generic names for Tk classes
-tkconsole.rb console command support
-tkdialog.rb Tk dialog class
-tkentry.rb Tk entry class
-tkfont.rb Tk font support
-tkmacpkg.rb Mac resource support
-tkmenubar.rb TK menubar utility
-tkmngfocus.rb focus manager
-tkpalette.rb pallete support
-tkscrollbox.rb scroll box, also example of compound widget
-tktext.rb text classes
-tkvirtevent.rb virtual event support
-tkwinpkg.rb Win DDE and registry support
diff --git a/ext/tk/lib/multi-tk.rb b/ext/tk/lib/multi-tk.rb
deleted file mode 100644
index b6c800177f..0000000000
--- a/ext/tk/lib/multi-tk.rb
+++ /dev/null
@@ -1,1363 +0,0 @@
-#
-# multi-tk.rb - supports multi Tk interpreters
-# by Hidetoshi NAGAI <nagai@ai.kyutech.ac.jp>
-
-require 'tcltklib'
-require 'thread'
-
-################################################
-# ignore exception on the mainloop?
-
-TclTkLib.mainloop_abort_on_exception = true
-# TclTkLib.mainloop_abort_on_exception = false
-# TclTkLib.mainloop_abort_on_exception = nil
-
-
-
-################################################
-# exceptiopn to treat the return value from IP
-class MultiTkIp_OK < Exception
- def self.send(thred, ret=nil)
- thread.raise self.new(ret)
- end
-
- def initialize(ret=nil)
- super('succeed')
- @return_value = ret
- end
-
- attr_reader :return_value
- alias value return_value
-end
-MultiTkIp_OK.freeze
-
-
-################################################
-# methods for construction
-class MultiTkIp
- SLAVE_IP_ID = ['slave'.freeze, '0'.taint].freeze
-
- @@IP_TABLE = {}.taint
-
- @@INIT_IP_ENV = [].taint # table of Procs
- @@ADD_TK_PROCS = [].taint # table of [name, args, body]
-
- @@TK_TABLE_LIST = [].taint
-
- @@TK_CMD_TBL = {}.taint
-
- ######################################
-
- @@CB_ENTRY_CLASS = Class.new{|c|
- def initialize(ip, cmd)
- @ip = ip
- @cmd = cmd
- end
- attr_reader :ip, :cmd
- def call(*args)
- begin
- unless @ip.deleted?
- @ip.cb_eval(@cmd, *args)
- end
- rescue TkCallbackBreak, TkCallbackContinue
- fail
- rescue Exception
- end
- end
- }.freeze
-
- ######################################
-
- def _keys2opts(keys)
- keys.collect{|k,v| "-#{k} #{v}"}.join(' ')
- end
- private :_keys2opts
-
- def _check_and_return(thread, exception, wait=0)
- return nil unless thread
-
- if wait == 0
- # no wait
- thread.raise exception
- return thread
- end
-
- # wait to stop the caller thread
- wait.times{
- if thread.stop?
- # ready to send exception
- thread.raise exception
- return thread
- end
-
- # wait
- Thread.pass
- }
-
- # unexpected error
- thread.raise RuntimeError, "the thread may not wait for the return value"
- return thread
- end
-
- ######################################
-
- def set_safe_level(safe)
- @cmd_queue.enq([@system, 'set_safe_level', safe])
- self
- end
- def self.set_safe_level(safe)
- __getip.set_safe_level(safe)
- self
- end
-
- def _create_receiver_and_watchdog()
- # command-procedures receiver
- receiver = Thread.new{
- safe_level = $SAFE
- loop do
- thread, cmd, *args = @cmd_queue.deq
- if thread == @system
- # control command
- case cmd
- when 'set_safe_level'
- begin
- safe_level = args[0] if safe_level < args[0]
- rescue Exception
- nil
- end
- else
- # ignore
- end
-
- else
- # procedure
- begin
- ret = proc{$SAFE = safe_level; cmd.call(*args)}.call
- rescue SystemExit
- # delete IP
- unless @interp.deleted?
- if @interp._invoke('info', 'command', '.') != ""
- @interp._invoke('destroy', '.')
- end
- @interp.delete
- end
- _check_and_return(thread, MultiTkIp_OK.new(nil))
- break
- rescue Exception => e
- # raise exception
- _check_and_return(thread, e)
- else
- # no exception
- _check_and_return(thread, MultiTkIp_OK.new(ret))
- end
- end
- end
- }
-
- # watchdog of receiver
- watchdog = Thread.new{
- begin
- loop do
- sleep 1
- break unless receiver.alive?
- end
- rescue Exception
- # ignore all kind of Exception
- end
- # receiver is dead
- loop do
- thread, cmd, *args = @cmd_queue.deq
- next unless thread
- if thread.alive?
- if @interp.deleted?
- thread.raise RuntimeError, 'the interpreter is already deleted'
- else
- thread.raise RuntimeError,
- 'the interpreter no longer receives command procedures'
- end
- end
- end
- }
-
- # return threads
- [receiver, watchdog]
- end
- private :_check_and_return, :_create_receiver_and_watchdog
-
- ######################################
-
- if self.const_defined? :DEFAULT_MASTER_NAME
- name = DEFAULT_MASTER_NAME.to_s
- else
- name = nil
- end
- if self.const_defined?(:DEFAULT_MASTER_OPTS) &&
- DEFAULT_MASTER_OPTS.kind_of?(Hash)
- keys = DEFAULT_MASTER_OPTS
- else
- keys = {}
- end
-
- @@DEFAULT_MASTER = self.allocate
- @@DEFAULT_MASTER.instance_eval{
- @encoding = [].taint
-
- @tk_windows = {}.taint
-
- @tk_table_list = [].taint
-
- @slave_ip_tbl = {}.taint
-
- unless keys.kind_of? Hash
- fail ArgumentError, "expecting a Hash object for the 2nd argument"
- end
-
- @interp = TclTkIp.new(name, _keys2opts(keys))
- @ip_name = nil
-
- @system = Object.new
-
- @threadgroup = Thread.current.group
-
- @cmd_queue = Queue.new
-
- @cmd_receiver, @receiver_watchdog = _create_receiver_and_watchdog()
-
- @threadgroup.add @cmd_receiver
- @threadgroup.add @receiver_watchdog
-
- # NOT enclose @threadgroup for @@DEFAULT_MASTER
-
- @@IP_TABLE[ThreadGroup::Default] = self
- @@IP_TABLE[@threadgroup] = self
- }
- @@DEFAULT_MASTER.freeze # defend against modification
-
- ######################################
-
- def self.inherited(subclass)
- # trust if on ThreadGroup::Default or @@DEFAULT_MASTER's ThreadGroup
- if @@IP_TABLE[Thread.current.group] == @@DEFAULT_MASTER
- begin
- class << subclass
- self.methods.each{|m|
- begin
- unless m == '__id__' || m == '__send__' || m == 'freeze'
- undef_method(m)
- end
- rescue Exception
- # ignore all exceptions
- end
- }
- end
- ensure
- subclass.freeze
- fail SecurityError,
- "cannot create subclass of MultiTkIp on a untrusted ThreadGroup"
- end
- end
- end
-
- ######################################
-
- SAFE_OPT_LIST = [
- 'accessPath'.freeze,
- 'statics'.freeze,
- 'nested'.freeze,
- 'deleteHook'.freeze
- ].freeze
-
- def _parse_slaveopts(keys)
- name = nil
- safe = false
- safe_opts = {}
- tk_opts = {}
-
- keys.each{|k,v|
- if k.to_s == 'name'
- name = v
- elsif k.to_s == 'safe'
- safe = v
- elsif SAFE_OPT_LIST.member?(k.to_s)
- safe_opts[k] = v
- else
- tk_opts[k] = v
- end
- }
-
- [name, safe, safe_opts, tk_opts]
- end
- private :_parse_slaveopts
-
- def _create_slave_ip_name
- name = SLAVE_IP_ID.join
- SLAVE_IP_ID[1].succ!
- name
- end
- private :_create_slave_ip_name
-
- ######################################
-
- def __check_safetk_optkeys(optkeys)
- # based on 'safetk.tcl'
- new_keys = {}
- optkeys.each{|k,v| new_keys[k.to_s] = v}
-
- # check 'display'
- if !new_keys.key?('display')
- begin
- #new_keys['display'] = @interp._invoke('winfo screen .')
- new_keys['display'] = @interp._invoke('winfo', 'screen', '.')
- rescue
- if ENV[DISPLAY]
- new_keys['display'] = ENV[DISPLAY]
- elsif !new_keys.key?('use')
- warn "Warning: no screen info or ENV[DISPLAY], so use ':0.0'"
- new_keys['display'] = ':0.0'
- end
- end
- end
-
- # check 'use'
- if new_keys.key?('use')
- # given 'use'
- case new_keys['use']
- when TkWindow
- new_keys['use'] = TkWinfo.id(new_keys['use'])
- #assoc_display = @interp._eval('winfo screen .')
- assoc_display = @interp._invoke('winfo', 'screen', '.')
- when /^\..*/
- new_keys['use'] = @interp._invoke('winfo', 'id', new_keys['use'])
- assoc_display = @interp._invoke('winfo', 'screen', new_keys['use'])
- else
- begin
- pathname = @interp._invoke('winfo', 'pathname', new_keys['use'])
- assco_display = @interp._invoke('winfo', 'screen', pathname)
- rescue
- assoc_display = new_keys['display']
- end
- end
-
- # match display?
- if assoc_display != new_keys['display']
- if optkeys.keys?(:display) || optkeys.keys?('display')
- fail RuntimeError,
- "conflicting 'display'=>#{new_keys['display']} " +
- "and display '#{assoc_display}' on 'use'=>#{new_keys['use']}"
- else
- new_keys['display'] = assoc_display
- end
- end
- end
-
- # return
- new_keys
- end
- private :__check_safetk_optkeys
-
- def __create_safetk_frame(slave_ip, slave_name, app_name, keys)
- # display option is used by ::safe::loadTk
- loadTk_keys = {}
- loadTk_keys['display'] = keys['display']
- dup_keys = keys.dup
-
- # keys for toplevel : allow followings
- toplevel_keys = {}
- ['height', 'width', 'background', 'menu'].each{|k|
- toplevel_keys[k] = dup_keys.delete(k) if dup_keys.key?(k)
- }
- toplevel_keys['classname'] = 'SafeTk'
- toplevel_keys['screen'] = dup_keys.delete('display')
-
- # other keys used by pack option of container frame
-
- # create toplevel widget
- begin
- top = TkToplevel.new(toplevel_keys)
- rescue NameError
- fail unless @interp.safe?
- fail SecurityError, "unable create toplevel on the safe interpreter"
- end
- msg = "Untrusted Ruby/Tk applet (#{slave_name})"
- if app_name.kind_of?(String)
- top.title "#{app_name} (#{slave_name})"
- else
- top.title msg
- end
-
- # procedure to delete slave interpreter
- slave_delete_proc = proc{
- unless slave_ip.deleted?
- if slave_ip._invoke('info', 'command', '.') != ""
- slave_ip._invoke('destroy', '.')
- end
- slave_ip.delete
- end
- }
- tag = TkBindTag.new.bind('Destroy', slave_delete_proc)
-
- # create control frame
- TkFrame.new(top, :bg=>'red', :borderwidth=>3, :relief=>'ridge') {|fc|
- fc.bindtags = fc.bindtags.unshift(tag)
-
- TkFrame.new(fc, :bd=>0){|f|
- TkButton.new(f,
- :text=>'Delete', :bd=>1, :padx=>2, :pady=>0,
- :highlightthickness=>0, :command=>slave_delete_proc
- ).pack(:side=>:right, :fill=>:both)
- f.pack(:side=>:right, :fill=>:both, :expand=>true)
- }
-
- TkLabel.new(fc, :text=>msg, :padx=>2, :pady=>0,
- :anchor=>:w).pack(:side=>:left, :fill=>:both, :expand=>true)
-
- fc.pack(:side=>:bottom, :fill=>:x)
- }
-
- # container frame for slave interpreter
- dup_keys['fill'] = :both unless dup_keys.key?('fill')
- dup_keys['expand'] = true unless dup_keys.key?('expand')
- c = TkFrame.new(top, :container=>true).pack(dup_keys)
-
- # return keys
- loadTk_keys['use'] = TkWinfo.id(c)
- loadTk_keys
- end
- private :__create_safetk_frame
-
- def __create_safe_slave_obj(safe_opts, app_name, tk_opts)
- # safe interpreter
- # at present, not enough support for '-deleteHook' option
- ip_name = _create_slave_ip_name
- slave_ip = @interp.create_slave(ip_name, true)
- @interp._eval("::safe::interpInit #{ip_name} "+_keys2opts(safe_opts))
- tk_opts = __check_safetk_optkeys(tk_opts)
- unless tk_opts.key?('use')
- tk_opts = __create_safetk_frame(slave_ip, ip_name, app_name, tk_opts)
- end
- slave_ip._invoke('set', 'argv0', app_name) if app_name.kind_of?(String)
- @interp._eval("::safe::loadTk #{ip_name} #{_keys2opts(tk_opts)}")
- @slave_ip_tbl[ip_name] = slave_ip
- [slave_ip, ip_name]
- end
-
- def __create_trusted_slave_obj(name, keys)
- ip_name = _create_slave_ip_name
- slave_ip = @interp.create_slave(ip_name, false)
- slave_ip._invoke('set', 'argv0', name) if name.kind_of?(String)
- slave_ip._invoke('set', 'argv', _keys2opts(keys))
- @interp._invoke('load', '', 'Tk', ip_name)
- @slave_ip_tbl[ip_name] = slave_ip
- [slave_ip, ip_name]
- end
-
- ######################################
-
- def _create_slave_object(keys={})
- ip = MultiTkIp.new_slave(self, keys={})
- @slave_ip_tbl[ip.name] = ip
- end
-
- ######################################
-
- def initialize(master, safeip=true, keys={})
- if $SAFE >= 4
- fail SecurityError, "cannot create a new interpreter at level #{$SAFE}"
- end
-
- if safeip == nil && $SAFE >= 2
- fail SecurityError, "cannot create a master-ip at level #{$SAFE}"
- end
-
- if !master.master? && master.safe?
- fail SecurityError, "safe-slave-ip cannot create a new interpreter"
- end
-
- if safeip == nil && !master.master?
- fail SecurityError, "slave-ip cannot create a master-ip"
- end
-
- unless keys.kind_of? Hash
- fail ArgumentError, "expecting a Hash object for the 2nd argument"
- end
-
- @encoding = []
- @tk_windows = {}
- @tk_table_list = []
- @slave_ip_tbl = {}
-
- @encoding.taint unless @encoding.tainted?
- @tk_windows.taint unless @tk_windows.tainted?
- @tk_table_list.taint unless @tk_table_list.tainted?
- @slave_ip_tbl.taint unless @slave_ip_tbl.tainted?
-
- name, safe, safe_opts, tk_opts = _parse_slaveopts(keys)
-
- if safeip == nil
- # create master-ip
- @interp = TclTkIp.new(name, _keys2opts(tk_opts))
- @ip_name = nil
- else
- # create slave-ip
- if safeip || master.safe?
- @interp, @ip_name = master.__create_safe_slave_obj(safe_opts,
- name, tk_opts)
- else
- @interp, @ip_name = master.__create_trusted_slave_obj(name, tk_opts)
- end
- @set_alias_proc = proc{|name|
- master._invoke('interp', 'alias', @ip_name, name, '', name)
- }.freeze
- end
-
- @system = Object.new
-
- @threadgroup = ThreadGroup.new
-
- @cmd_queue = Queue.new
-
- @cmd_receiver, @receiver_watchdog = _create_receiver_and_watchdog()
-
- @threadgroup.add @cmd_receiver
- @threadgroup.add @receiver_watchdog
-
- @threadgroup.enclose
-
- @@IP_TABLE[@threadgroup] = self
- _init_ip_internal(@@INIT_IP_ENV, @@ADD_TK_PROCS)
- @@TK_TABLE_LIST.size.times{
- (tbl = {}).tainted? || tbl.taint
- @tk_table_list << tbl
- }
-
- self.freeze # defend against modification
- end
-end
-
-
-# get target IP
-class MultiTkIp
- def self.__getip
- if Thread.current.group == ThreadGroup::Default
- @@DEFAULT_MASTER
- else
- ip = @@IP_TABLE[Thread.current.group]
- unless ip
- fail SecurityError,
- "cannot call Tk methods on #{Thread.current.inspect}"
- end
- ip
- end
- end
-end
-
-
-# aliases of constructor
-class << MultiTkIp
- alias __new new
- private :__new
-
- def new_master(keys={}, &b)
- ip = __new(__getip, nil, keys)
- ip.eval_proc(&b) if b
- ip
- end
-
- alias new new_master
-
- def new_slave(keys={}, &b)
- ip = __new(__getip, false, keys)
- ip.eval_proc(&b) if b
- ip
- end
- alias new_trusted_slave new_master
-
- def new_safe_slave(keys={},&b)
- ip = __new(__getip, true, keys)
- ip.eval_proc(&b) if b
- ip
- end
- alias new_safeTk new_safe_slave
-end
-
-
-# get info
-class MultiTkIp
- def inspect
- s = self.to_s.chop!
- if master?
- s << ':master'
- else
- if @interp.safe?
- s << ':safe-slave'
- else
- s << ':trusted-slave'
- end
- end
- s << '>'
- end
-
- def master?
- if @ip_name
- false
- else
- true
- end
- end
- def self.master?
- __getip.master?
- end
-
- def slave?
- not master?
- end
- def self.slave?
- end
-
- def alive?
- begin
- return false unless @cmd_receiver.alive?
- return false if @interp.deleted?
- return false if @interp._invoke('interp', 'exists', '') == '0'
- rescue Exception
- return false
- end
- true
- end
- def self.alive?
- __getip.alive?
- end
-
- def path
- @ip_name || ''
- end
- def self.path
- __getip.path
- end
- def ip_name
- @ip_name || ''
- end
- def self.ip_name
- __getip.ip_name
- end
- def to_eval
- @ip_name || ''
- end
- def self.to_eval
- __getip.to_eval
- end
-
- def slaves(all = false)
- @interp._invoke('interp','slaves').split.map!{|name|
- if @slave_ip_tbl.key?(name)
- @slave_ip_tbl[name]
- elsif all
- name
- else
- nil
- end
- }.compact!
- end
- def self.slaves(all = false)
- __getip.slaves(all)
- end
-end
-
-
-# instance methods to treat tables
-class MultiTkIp
- def _tk_cmd_tbl
- tbl = {}
- MultiTkIp.tk_cmd_tbl.each{|id, ent| tbl[id] = ent if ent.ip == self }
- tbl
- end
-
- def _tk_windows
- @tk_windows
- end
-
- def _tk_table_list
- @tk_table_list
- end
-
- def _add_new_tables
- (@@TK_TABLE_LIST.size - @tk_table_list.size).times{
- (tbl = {}).tainted? || tbl.taint
- @tk_table_list << tbl
- }
- end
-
- def _init_ip_env(script)
- script.call(self)
- end
-
- def _add_tk_procs(name, args, body)
- return if slave?
- @interp._invoke('proc', name, args, body) if args && body
- @interp._invoke('interp', 'slaves').split.each{|slave|
- @interp._invoke('interp', 'alias', slave, name, '', name)
- }
- end
-
- def _init_ip_internal(init_ip_env, add_tk_procs)
- init_ip_env.each{|script| script.call(self)}
- add_tk_procs.each{|name, args, body|
- if master?
- @interp._invoke('proc', name, args, body) if args && body
- else
- @set_alias_proc.call(name)
- end
- }
- end
-end
-
-
-# class methods to treat tables
-class MultiTkIp
- def self.tk_cmd_tbl
- @@TK_CMD_TBL
- end
- def self.tk_windows
- __getip._tk_windows
- end
- def self.tk_object_table(id)
- __getip._tk_table_list[id]
- end
- def self.create_table
- #if __getip.slave?
- # raise SecurityError, "slave-IP has no permission creating a new table"
- #end
- id = @@TK_TABLE_LIST.size
- obj = Object.new
- @@TK_TABLE_LIST << obj
- obj.instance_eval <<-EOD
- def self.method_missing(m, *args)
- MultiTkIp.tk_object_table(#{id}).send(m, *args)
- end
- EOD
- obj.freeze
- @@IP_TABLE.each{|tg, ip| ip._add_new_tables }
- return obj
- end
-
- def self.init_ip_env(script = Proc.new)
- @@INIT_IP_ENV << script
- @@IP_TABLE.each{|tg, ip|
- ip._init_ip_env(script)
- }
- end
-
- def self.add_tk_procs(name, args=nil, body=nil)
- @@ADD_TK_PROCS << [name, args, body]
- @@IP_TABLE.each{|tg, ip|
- ip._add_tk_procs(name, args, body)
- }
- end
-
- def self.init_ip_internal
- __getip._init_ip_internal(@@INIT_IP_ENV, @@ADD_TK_PROCS)
- end
-end
-
-
-# for callback operation
-class MultiTkIp
- def self.get_cb_entry(cmd)
- @@CB_ENTRY_CLASS.new(__getip, cmd).freeze
- end
-
- def cb_eval(cmd, *args)
- self.eval_callback{ TkComm._get_eval_string(TkUtil.eval_cmd(cmd, *args)) }
- end
-end
-
-
-# evaluate a procedure on the proper interpreter
-class MultiTkIp
- # instance method
- def eval_proc_core(req_val, cmd, *args)
- # cmd string ==> proc
- if cmd.kind_of?(String)
- xcmd = cmd
- xargs = args
- cmd = proc{ TkComm._get_eval_string(TkUtil.eval_cmd(xcmd, *xargs)) }
- args = []
- end
-
- # check
- unless cmd.kind_of?(Proc)
- raise RuntimeError, "A Proc object is expected for the 'cmd' argument"
- end
-
- # on IP thread
- if (@cmd_receiver == Thread.current)
- begin
- ret = cmd.call(*args)
- rescue SystemExit
- # exit IP
- warn("Warning: "+ $! + " on " + self.inspect) if $DEBUG
- self.delete
- ret = nil
- rescue Exception => e
- warn("Warning: " + e.class.inspect +
- ((e.message.length > 0)? ' "' + e.message + '"': '') +
- " on " + self.inspect)
- ret = nil
- end
- return ret
- end
-
- # send cmd to the proc-queue
- unless req_val
- @cmd_queue.enq([nil, cmd, *args])
- return nil
- end
-
- # send and get return value by exception
- begin
- @cmd_queue.enq([Thread.current, cmd, *args])
- Thread.stop
- rescue MultiTkIp_OK => ret
- # return value
- return ret.value
- rescue SystemExit
- # exit IP
- warn("Warning: " + $! + " on " + self.inspect) if $DEBUG
- self.delete
- rescue Exception => e
- # others --> warning
- warn("Warning: " + e.class.inspect +
- ((e.message.length > 0)? ' "' + e.message + '"': '') +
- " on " + self.inspect)
- end
- return nil
- end
- private :eval_proc_core
-
- def eval_callback(cmd = Proc.new, *args)
- eval_proc_core(false, cmd, *args)
- end
-
- def eval_proc(cmd = Proc.new, *args)
- eval_proc_core(true, cmd, *args)
- end
- alias call eval_proc
- alias eval_string eval_proc
-end
-class << MultiTkIp
- # class method
- def eval_proc(cmd = Proc.new, *args)
- # class ==> interp object
- __getip.eval_proc(cmd, *args)
- end
- alias call eval_proc
- alias eval_string eval_proc
-end
-
-
-# event loop
-# all master/slave IPs are controled by only one event-loop
-class << MultiTkIp
- def mainloop(check_root = true)
- __getip.mainloop(check_root)
- end
- def mainloop_watchdog(check_root = true)
- __getip.mainloop_watchdog(check_root)
- end
- def do_one_event(flag = TclTkLib::EventFlag::ALL)
- __getip.do_one_event(flag)
- end
- def mainloop_abort_on_exception
- __getip.mainloop_abort_on_exception
- end
- def mainloop_abort_on_exception=(mode)
- __getip.mainloop_abort_on_exception=(mode)
- end
- def set_eventloop_tick(tick)
- __getip.set_eventloop_tick(tick)
- end
- def get_eventloop_tick
- __getip.get_eventloop_tick
- end
- def set_no_event_wait(tick)
- __getip.set_no_event_wait(tick)
- end
- def get_no_event_wait
- __getip.get_no_event_wait
- end
- def set_eventloop_weight(loop_max, no_event_tick)
- __getip.set_eventloop_weight(loop_max, no_event_tick)
- end
- def get_eventloop_weight
- __getip.get_eventloop_weight
- end
-end
-
-# class methods to delegate to TclTkIp
-class << MultiTkIp
- def method_missing(id, *args)
- __getip.send(id, *args)
- end
-
- def make_safe
- __getip.make_safe
- end
-
- def safe?
- __getip.safe?
- end
-
- def restart
- __getip.restart
- end
-
- def _eval(str)
- __getip._eval(str)
- end
-
- def _invoke(*args)
- __getip._invoke(*args)
- end
-
- def _toUTF8(str, encoding)
- __getip._toUTF8(str, encoding)
- end
-
- def _fromUTF8(str, encoding)
- __getip._fromUTF8(str, encoding)
- end
-
- def _thread_vwait(var)
- __getip._thread_vwait(var)
- end
-
- def _thread_tkwait(mode, target)
- __getip._thread_tkwait(mode, target)
- end
-
- def _return_value
- __getip._return_value
- end
-end
-
-
-# wrap methods on TclTkLib : not permit calling TclTkLib module methods
-class << TclTkLib
- def mainloop(check_root = true)
- MultiTkIp.mainloop(check_root)
- end
- def mainloop_watchdog(check_root = true)
- MultiTkIp.mainloop_watchdog(check_root)
- end
- def do_one_event(flag = TclTkLib::EventFlag::ALL)
- MultiTkIp.do_one_event(flag)
- end
- def mainloop_abort_on_exception
- MultiTkIp.mainloop_abort_on_exception
- end
- def mainloop_abort_on_exception=(mode)
- MultiTkIp.mainloop_abort_on_exception=(mode)
- end
- def set_eventloop_tick(tick)
- MultiTkIp.set_eventloop_tick(tick)
- end
- def get_eventloop_tick
- MultiTkIp.get_eventloop_tick
- end
- def set_no_event_wait(tick)
- MultiTkIp.set_no_event_wait(tick)
- end
- def get_no_event_wait
- MultiTkIp.get_no_event_wait
- end
- def set_eventloop_weight(loop_max, no_event_tick)
- MultiTkIp.set_eventloop_weight(loop_max, no_event_tick)
- end
- def get_eventloop_weight
- MultiTkIp.get_eventloop_weight
- end
- def restart
- MultiTkIp.restart
- end
-end
-
-
-# depend on TclTkIp
-class MultiTkIp
- def mainloop(check_root = true, restart_on_dead = true)
- return self if self.slave?
- unless restart_on_dead
- @interp.mainloop(check_root)
- else
- begin
- loop do
- break unless self.alive?
- if check_root
- begin
- break if TclTkLib.num_of_mainwindows == 0
- rescue Exception
- break
- end
- end
- @interp.mainloop(check_root)
- end
- rescue StandardError
- if TclTkLib.mainloop_abort_on_exception != nil
- STDERR.print("Warning: Tk mainloop on ", @interp.inspect,
- " receives ", $!.class.inspect,
- " exception (ignore) : ", $!.message, "\n");
- end
- retry
- end
- end
- self
- end
-
- def make_safe
- @interp.make_safe
- end
-
- def safe?
- @interp.safe?
- end
-
- def delete
- @interp.delete
- end
-
- def deleted?
- @interp.deleted?
- end
-
- def restart
- @interp.restart
- end
-
- def _eval(str)
- @interp._eval(str)
- end
-
- def _invoke(*args)
- @interp._invoke(*args)
- end
-
- def _toUTF8(str, encoding)
- @interp._toUTF8(str, encoding)
- end
-
- def _fromUTF8(str, encoding)
- @interp._fromUTF8(str, encoding)
- end
-
- def _thread_vwait(var)
- @interp._thread_vwait(var)
- end
-
- def _thread_tkwait(mode, target)
- @interp._thread_tkwait(mode, target)
- end
-
- def _return_value
- @interp._return_value
- end
-end
-
-
-# interp command support
-class MultiTkIp
- def _lst2ary(str)
- return [] if str == ""
- idx = str.index('{')
- while idx and idx > 0 and str[idx-1] == ?\\
- idx = str.index('{', idx+1)
- end
- return str.split unless idx
-
- list = str[0,idx].split
- str = str[idx+1..-1]
- i = -1
- brace = 1
- str.each_byte {|c|
- i += 1
- brace += 1 if c == ?{
- brace -= 1 if c == ?}
- break if brace == 0
- }
- if i == 0
- list.push ''
- elsif str[0, i] == ' '
- list.push ' '
- else
- list.push str[0..i-1]
- end
- list += tk_split_simplelist(str[i+1..-1])
- list
- end
- private :_lst2ary
-
- def _slavearg(slave)
- if slave.kind_of?(MultiTkIp)
- slave.path
- elsif slave.kind_of?(String)
- slave
- else
- cmd_name.to_s
- end
- end
- private :_slavearg
-
- def alias_info(slave, cmd_name)
- _lst2ary(@interp._invoke('interp', 'alias', _slavearg(slave), cmd_name))
- end
- def self.alias_info(slave, cmd_name)
- __getip.alias_info(slave, cmd_name)
- end
-
- def alias_delete(slave, cmd_name)
- @interp._invoke('interp', 'alias', _slavearg(slave), cmd_name, '')
- self
- end
- def self.alias_delete(slave, cmd_name)
- __getip.alias_delete(slave, cmd_name)
- self
- end
-
- def def_alias(slave, new_cmd, org_cmd, *args)
- ret = @interp._invoke('interp', 'alias', _slavearg(slave), new_cmd,
- '', org_cmd, *args)
- (ret == new_cmd)? self: nil
- end
- def self.def_alias(slave, new_cmd, org_cmd, *args)
- ret = __getip.def_alias(slave, new_cmd, org_cmd, *args)
- (ret == new_cmd)? self: nil
- end
-
- def aliases(slave = '')
- _lst2ary(@interp._invoke('interp', 'aliases', _slavearg(slave)))
- end
- def self.aliases(slave = '')
- __getip.aliases(slave)
- end
-
- def delete_slaves(*args)
- slaves = args.collect{|s| _slavearg(s)}
- @interp._invoke('interp', 'delete', *slaves) if slaves.size > 0
- self
- end
- def self.delete_slaves(*args)
- __getip.delete_slaves(*args)
- self
- end
-
- def exist?(slave = '')
- ret = @interp._invoke('interp', 'exists', _slavearg(slave))
- (ret == '1')? true: false
- end
- def self.exist?(slave = '')
- __getip.exist?(slave)
- end
-
- def delete_cmd(slave, cmd)
- slave_invoke = @interp._invoke('list', 'rename', cmd, '')
- @interp._invoke('interp', 'eval', _slavearg(slave), slave_invoke)
- self
- end
- def self.delete_cmd(slave, cmd)
- __getip.delete_cmd(slave, cmd)
- self
- end
-
- def expose_cmd(slave, cmd, aliasname = nil)
- if aliasname
- @interp._invoke('interp', 'expose', _slavearg(slave), cmd, aliasname)
- else
- @interp._invoke('interp', 'expose', _slavearg(slave), cmd)
- end
- self
- end
- def self.expose_cmd(slave, cmd, aliasname = nil)
- __getip.expose_cmd(slave, cmd, aliasname)
- self
- end
-
- def hide_cmd(slave, cmd, aliasname = nil)
- if aliasname
- @interp._invoke('interp', 'hide', _slavearg(slave), cmd, aliasname)
- else
- @interp._invoke('interp', 'hide', _slavearg(slave), cmd)
- end
- self
- end
- def self.hide_cmd(slave, cmd, aliasname = nil)
- __getip.hide_cmd(slave, cmd, aliasname)
- self
- end
-
- def hidden_cmds(slave = '')
- _lst2ary(@interp._invoke('interp', 'hidden', _slavearg(slave)))
- end
- def self.hidden_cmds(slave = '')
- __getip.hidden_cmds(slave)
- end
-
- def invoke_hidden(slave, cmd, *args)
- @interp._invoke('interp', 'invokehidden', _slavearg(slave), cmd, *args)
- end
- def self.invoke_hidden(slave, cmd, *args)
- __getip.invoke_hidden(slave, cmd, *args)
- end
-
- def invoke_hidden_on_global(slave, cmd, *args)
- @interp._invoke('interp', 'invokehidden', _slavearg(slave),
- '-global', cmd, *args)
- end
- def self.invoke_hidden_on_global(slave, cmd, *args)
- __getip.invoke_hidden_on_global(slave, cmd, *args)
- end
-
- def mark_trusted(slave = '')
- @interp._invoke('interp', 'marktrusted', _slavearg(slave))
- self
- end
- def self.mark_trusted(slave = '')
- __getip.mark_trusted(slave)
- self
- end
-
- def alias_target(aliascmd, slave = '')
- @interp._invoke('interp', 'target', _slavearg(slave), aliascmd)
- end
- def self.alias_target(aliascmd, slave = '')
- __getip.alias_target(aliascmd, slave)
- end
-
- def share_stdin(dist, src = '')
- @interp._invoke('interp', 'share', src, 'stdin', dist)
- self
- end
- def self.share_stdin(dist, src = '')
- __getip.share_stdin(dist, src)
- self
- end
-
- def share_stdout(dist, src = '')
- @interp._invoke('interp', 'share', src, 'stdout', dist)
- self
- end
- def self.share_stdout(dist, src = '')
- __getip.share_stdout(dist, src)
- self
- end
-
- def share_stderr(dist, src = '')
- @interp._invoke('interp', 'share', src, 'stderr', dist)
- self
- end
- def self.share_stderr(dist, src = '')
- __getip.share_stderr(dist, src)
- self
- end
-
- def transfer_stdin(dist, src = '')
- @interp._invoke('interp', 'transfer', src, 'stdin', dist)
- self
- end
- def self.transfer_stdin(dist, src = '')
- __getip.transfer_stdin(dist, src)
- self
- end
-
- def transfer_stdout(dist, src = '')
- @interp._invoke('interp', 'transfer', src, 'stdout', dist)
- self
- end
- def self.transfer_stdout(dist, src = '')
- __getip.transfer_stdout(dist, src)
- self
- end
-
- def transfer_stderr(dist, src = '')
- @interp._invoke('interp', 'transfer', src, 'stderr', dist)
- self
- end
- def self.transfer_stderr(dist, src = '')
- __getip.transfer_stderr(dist, src)
- self
- end
-
- def share_stdio(dist, src = '')
- @interp._invoke('interp', 'share', src, 'stdin', dist)
- @interp._invoke('interp', 'share', src, 'stdout', dist)
- @interp._invoke('interp', 'share', src, 'stderr', dist)
- self
- end
- def self.share_stdio(dist, src = '')
- __getip.share_stdio(dist, src)
- self
- end
-
- def transfer_stdio(dist, src = '')
- @interp._invoke('interp', 'transfer', src, 'stdin', dist)
- @interp._invoke('interp', 'transfer', src, 'stdout', dist)
- @interp._invoke('interp', 'transfer', src, 'stderr', dist)
- self
- end
- def self.transfer_stdio(dist, src = '')
- __getip.transfer_stdio(dist, src)
- self
- end
-end
-
-
-# encoding convert
-class MultiTkIp
- # from tkencoding.rb by ttate@jaist.ac.jp
- alias __eval _eval
- alias __invoke _invoke
-
- def encoding
- @encoding[0]
- end
- def encoding=(enc)
- @encoding[0] = enc
- end
-
- def _eval(cmd)
- if @encoding[0] != nil
- _fromUTF8(__eval(_toUTF8(cmd, @encoding[0])), @encoding[0])
- else
- __eval(cmd)
- end
- end
-
- def _invoke(*cmds)
- if defined?(@encoding[0]) && @encoding[0] != nil
- cmds = cmds.collect{|cmd| _toUTF8(cmd, @encoding[0])}
- _fromUTF8(__invoke(*cmds), @encoding[0])
- else
- __invoke(*cmds)
- end
- end
-end
-
-
-# remove methods for security
-class MultiTkIp
- undef_method :instance_eval
- undef_method :instance_variable_get
- undef_method :instance_variable_set
-end
-
-
-# end of MultiTkIp definition
-
-# defend against modification
-#MultiTkIp.freeze
-#TclTkLib.freeze
-
-########################################
-# start Tk which depends on MultiTkIp
-module TkCore
- INTERP = MultiTkIp
-end
-require 'tk'
diff --git a/ext/tk/lib/tk.rb b/ext/tk/lib/tk.rb
deleted file mode 100644
index a73f15e367..0000000000
--- a/ext/tk/lib/tk.rb
+++ /dev/null
@@ -1,5883 +0,0 @@
-#
-# tk.rb - Tk interface module using tcltklib
-# $Date$
-# by Yukihiro Matsumoto <matz@netlab.jp>
-
-# use Shigehiro's tcltklib
-require "tcltklib"
-require "tkutil"
-
-module TkComm
- WidgetClassNames = {}.taint
-
- None = Object.new
- def None.to_s
- 'None'
- end
- None.freeze
-
- #Tk_CMDTBL = {}
- #Tk_WINDOWS = {}
- Tk_IDs = ["00000".taint, "00000".taint].freeze # [0]-cmdid, [1]-winid
-
- # for backward compatibility
- Tk_CMDTBL = Object.new
- def Tk_CMDTBL.method_missing(id, *args)
- TkCore::INTERP.tk_cmd_tbl.send(id, *args)
- end
- Tk_CMDTBL.freeze
- Tk_WINDOWS = Object.new
- def Tk_WINDOWS.method_missing(id, *args)
- TkCore::INTERP.tk_windows.send(id, *args)
- end
- Tk_WINDOWS.freeze
-
- self.instance_eval{
- @cmdtbl = [].taint
- }
-
- 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
- #tk_class = TkCore::INTERP._invoke('winfo', 'class', path)
- tk_class = Tk.ip_invoke('winfo', 'class', path)
- rescue
- return path
- end
-
- if ruby_class = WidgetClassNames[tk_class]
- ruby_class_name = ruby_class.name
- # gen_class_name = ruby_class_name + 'GeneratedOnTk'
- gen_class_name = ruby_class_name
- classname_def = ''
- elsif Object.const_defined?('Tk' + tk_class)
- ruby_class_name = 'Tk' + tk_class
- # gen_class_name = ruby_class_name + 'GeneratedOnTk'
- gen_class_name = ruby_class_name
- classname_def = ''
- else
- 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"
- end
- unless Object.const_defined? gen_class_name
- Object.class_eval "class #{gen_class_name}<#{ruby_class_name}
- #{classname_def}
- end"
- end
- Object.class_eval "#{gen_class_name}.new('widgetname'=>'#{path}',
- 'without_creating'=>true)"
- end
- private :_genobj_for_tkwidget
- module_function :_genobj_for_tkwidget
-
- def tk_tcl2ruby(val)
- if val =~ /^rb_out (c\d+)/
- #return Tk_CMDTBL[$1]
- return TkCore::INTERP.tk_cmd_tbl[$1]
- end
- if val.include? ?\s
- return val.split.collect{|v| tk_tcl2ruby(v)}
- end
- case val
- when /^@font/
- TkFont.get_obj(val)
- when /^-?\d+$/
- val.to_i
- when /^\./
- #Tk_WINDOWS[val] ? Tk_WINDOWS[val] : _genobj_for_tkwidget(val)
- TkCore::INTERP.tk_windows[val]?
- TkCore::INTERP.tk_windows[val] : _genobj_for_tkwidget(val)
- when /^i\d+$/
- TkImage::Tk_IMGTBL[val]? TkImage::Tk_IMGTBL[val] : val
- when / /
- val.split.collect{|elt|
- tk_tcl2ruby(elt)
- }
- when /^-?\d+\.?\d*(e[-+]?\d+)?$/
- val.to_f
- else
- val
- end
- end
-
- def tk_split_list(str)
- return [] if str == ""
- idx = str.index('{')
- while idx and idx > 0 and str[idx-1] == ?\\
- idx = str.index('{', idx+1)
- end
- unless idx
- list = tk_tcl2ruby(str)
- unless Array === list
- list = [list]
- end
- return list
- end
-
- list = tk_tcl2ruby(str[0,idx])
- list = [] if list == ""
- str = str[idx+1..-1]
- i = -1
- brace = 1
- str.each_byte {|c|
- i += 1
- brace += 1 if c == ?{
- brace -= 1 if c == ?}
- break if brace == 0
- }
- if str.size == i + 1
- return tk_split_list(str[0, i])
- end
- 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
-
- def tk_split_simplelist(str)
- return [] if str == ""
- idx = str.index('{')
- while idx and idx > 0 and str[idx-1] == ?\\
- idx = str.index('{', idx+1)
- end
- return str.split unless idx
-
- list = str[0,idx].split
- str = str[idx+1..-1]
- i = -1
- brace = 1
- str.each_byte {|c|
- i += 1
- brace += 1 if c == ?{
- brace -= 1 if c == ?}
- break if brace == 0
- }
- if i == 0
- list.push ''
- elsif str[0, i] == ' '
- list.push ' '
- else
- list.push str[0..i-1]
- end
- list += tk_split_simplelist(str[i+1..-1])
- list
- end
- private :tk_tcl2ruby, :tk_split_list, :tk_split_simplelist
-
- def _symbolkey2str(keys)
- h = {}
- keys.each{|key,value| h[key.to_s] = value}
- h
- end
- private :_symbolkey2str
-
- def hash_kv(keys)
- conf = []
- if keys and keys != None
- for k, v in keys
- conf.push("-#{k}")
- conf.push(v)
- end
- end
- conf
- end
- private :hash_kv
- module_function :hash_kv
-
- def array2tk_list(ary)
- ary.collect{|e|
- if e.kind_of? Array
- "{#{array2tk_list(e)}}"
- elsif e.kind_of? Hash
- "{#{e.to_a.collect{|ee| array2tk_list(ee)}.join(' ')}}"
- else
- s = _get_eval_string(e)
- (s.index(/\s/) || s.size == 0)? "{#{s}}": s
- end
- }.join(" ")
- end
- private :array2tk_list
- module_function :array2tk_list
-
- def bool(val)
- case val
- when "1", 1, 'yes', 'true'
- true
- else
- false
- end
- end
- def number(val)
- case val
- when /^-?\d+$/
- val.to_i
- when /^-?\d+\.?\d*(e[-+]?\d+)?$/
- val.to_f
- else
- fail(ArgumentError,
- Kernel.format('invalid value for Number:"%s"', val.to_s))
- end
- end
- def string(val)
- if val == "{}"
- ''
- elsif val[0] == ?{
- val[1..-2]
- else
- val
- end
- end
- def list(val)
- tk_split_list(val)
- end
- def simplelist(val)
- tk_split_simplelist(val)
- end
- def window(val)
- if val =~ /^\./
- #Tk_WINDOWS[val]? Tk_WINDOWS[val] : _genobj_for_tkwidget(val)
- TkCore::INTERP.tk_windows[val]?
- TkCore::INTERP.tk_windows[val] : _genobj_for_tkwidget(val)
- else
- nil
- end
- end
- def procedure(val)
- if val =~ /^rb_out (c\d+)/
- #Tk_CMDTBL[$1]
- #TkCore::INTERP.tk_cmd_tbl[$1]
- TkCore::INTERP.tk_cmd_tbl[$1].cmd
- else
- #nil
- val
- end
- end
- private :bool, :number, :string, :list, :simplelist, :window, :procedure
- module_function :bool, :number, :string, :list, :simplelist
- module_function :window, :procedure
-
- def _get_eval_string(str)
- return nil if str == None
- if str.kind_of?(String)
- # do nothing
- elsif str.kind_of?(Symbol)
- str = str.id2name
- elsif str.kind_of?(Hash)
- str = hash_kv(str).join(" ")
- elsif str.kind_of?(Array)
- str = array2tk_list(str)
- 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()
- else
- str = str.to_s() || ''
- unless str.kind_of? String
- fail RuntimeError, "fail to convert the object to a string"
- end
- str
- end
- return str
- end
- private :_get_eval_string
- module_function :_get_eval_string
-
- def ruby2tcl(v)
- if v.kind_of?(Hash)
- v = hash_kv(v)
- v.flatten!
- v.collect{|e|ruby2tcl(e)}
- else
- _get_eval_string(v)
- end
- end
- private :ruby2tcl
-
- def _curr_cmd_id
- #id = format("c%.4d", Tk_IDs[0])
- id = "c" + TkComm::Tk_IDs[0]
- end
- def _next_cmd_id
- id = _curr_cmd_id
- #Tk_IDs[0] += 1
- TkComm::Tk_IDs[0].succ!
- id
- end
- private :_curr_cmd_id, :_next_cmd_id
- module_function :_curr_cmd_id, :_next_cmd_id
-
- def install_cmd(cmd)
- return '' if cmd == ''
- id = _next_cmd_id
- #Tk_CMDTBL[id] = cmd
- TkCore::INTERP.tk_cmd_tbl[id] = TkCore::INTERP.get_cb_entry(cmd)
- @cmdtbl = [] unless defined? @cmdtbl
- @cmdtbl.taint unless @cmdtbl.tainted?
- @cmdtbl.push id
- return Kernel.format("rb_out %s", id);
- end
- def uninstall_cmd(id)
- id = $1 if /rb_out (c\d+)/ =~ id
- #Tk_CMDTBL.delete(id)
- TkCore::INTERP.tk_cmd_tbl.delete(id)
- end
- private :install_cmd, :uninstall_cmd
- module_function :install_cmd
-
- def install_win(ppath,name=nil)
- if !name or name == ''
- #name = format("w%.4d", Tk_IDs[1])
- #Tk_IDs[1] += 1
- name = "w" + Tk_IDs[1]
- Tk_IDs[1].succ!
- end
- if name[0] == ?.
- @path = name.dup
- elsif !ppath or ppath == "."
- @path = Kernel.format(".%s", name);
- else
- @path = Kernel.format("%s.%s", ppath, name)
- end
- #Tk_WINDOWS[@path] = self
- TkCore::INTERP.tk_windows[@path] = self
- end
-
- def uninstall_win()
- #Tk_WINDOWS.delete(@path)
- TkCore::INTERP.tk_windows.delete(@path)
- end
- private :install_win, :uninstall_win
-
- class Event
- module TypeNum
- KeyPress = 2
- KeyRelease = 3
- ButtonPress = 4
- ButtonRelease = 5
- MotionNotify = 6
- EnterNotify = 7
- LeaveNotify = 8
- FocusIn = 9
- FocusOut = 10
- KeymapNotify = 11
- Expose = 12
- GraphicsExpose = 13
- NoExpose = 14
- VisibilityNotify = 15
- CreateNotify = 16
- DestroyNotify = 17
- UnmapNotify = 18
- MapNotify = 19
- MapRequest = 20
- ReparentNotify = 21
- ConfigureNotify = 22
- ConfigureRequest = 23
- GravityNotify = 24
- ResizeRequest = 25
- CirculateNotify = 26
- CirculateRequest = 27
- PropertyNotify = 28
- SelectionClear = 29
- SelectionRequest = 30
- SelectionNotify = 31
- ColormapNotify = 32
- ClientMessage = 33
- MappingNotify = 34
- end
-
- EV_KEY = '#abcdfhikmopstwxyABDEKNRSTWXY'
- EV_TYPE = 'nsnnsbnsnsbsxnnnnsnnbsnssnwnn'
-
- def self.scan_args(arg_str, arg_val)
- arg_cnv = []
- arg_str.strip.split(/\s+/).each_with_index{|kwd,idx|
- if kwd =~ /^%(.)$/
- if num = EV_KEY.index($1)
- case EV_TYPE[num]
- when ?n
- begin
- val = TkComm::number(arg_val[idx])
- rescue ArgumentError
- # ignore --> no convert
- val = TkComm::string(arg_val[idx])
- end
- arg_cnv << val
- when ?s
- arg_cnv << TkComm::string(arg_val[idx])
- when ?b
- arg_cnv << TkComm::bool(arg_val[idx])
- when ?w
- arg_cnv << TkComm::window(arg_val[idx])
- when ?x
- begin
- arg_cnv << TkComm::number(arg_val[idx])
- rescue ArgumentError
- arg_cnv << arg_val[idx]
- end
- else
- arg_cnv << arg_val[idx]
- end
- else
- arg_cnv << arg_val[idx]
- end
- else
- arg_cnv << arg_val[idx]
- end
- }
- arg_cnv
- end
-
- def initialize(seq,a,b,c,d,f,h,i,k,m,o,p,s,t,w,x,y,
- aa,bb,dd,ee,kk,nn,rr,ss,tt,ww,xx,yy)
- @serial = seq
- @above = a
- @num = b
- @count = c
- @detail = d
- @focus = f
- @height = h
- @win_hex = i
- @keycode = k
- @mode = m
- @override = o
- @place = p
- @state = s
- @time = t
- @width = w
- @x = x
- @y = y
- @char = aa
- @borderwidth = bb
- @wheel_delta = dd
- @send_event = ee
- @keysym = kk
- @keysym_num = nn
- @rootwin_id = rr
- @subwindow = ss
- @type = tt
- @widget = ww
- @x_root = xx
- @y_root = yy
- end
- attr :serial
- attr :above
- attr :num
- attr :count
- attr :detail
- attr :focus
- attr :height
- attr :win_hex
- attr :keycode
- attr :mode
- attr :override
- attr :place
- attr :state
- attr :time
- attr :width
- attr :x
- attr :y
- attr :char
- attr :borderwidth
- attr :wheel_delta
- attr :send_event
- attr :keysym
- attr :keysym_num
- attr :rootwin_id
- attr :subwindow
- attr :type
- attr :widget
- attr :x_root
- attr :y_root
- end
-
- def install_bind(cmd, args=nil)
- if args
- id = install_cmd(proc{|*arg|
- TkUtil.eval_cmd(cmd, *Event.scan_args(args, arg))
- })
- id + " " + args
- else
- args = ' %# %a %b %c %d %f %h %i %k %m %o %p %s %t %w %x %y' +
- ' %A %B %D %E %K %N %R %S %T %W %X %Y'
- id = install_cmd(proc{|*arg|
- TkUtil.eval_cmd(cmd, Event.new(*Event.scan_args(args, arg)))
- })
- id + args
- end
- end
-
- def tk_event_sequence(context)
- if context.kind_of? TkVirtualEvent
- context = context.path
- end
- if context.kind_of? Array
- context = context.collect{|ev|
- if ev.kind_of? TkVirtualEvent
- ev.path
- else
- ev
- end
- }.join("><")
- end
- if /,/ =~ context
- context = context.split(/\s*,\s*/).join("><")
- else
- context
- end
- end
-
- def _bind_core(mode, what, context, cmd, args=nil)
- id = install_bind(cmd, args) if cmd
- begin
- tk_call(*(what + ["<#{tk_event_sequence(context)}>", mode + id]))
- rescue
- uninstall_cmd(id) if cmd
- fail
- end
- end
-
- def _bind(what, context, cmd, args=nil)
- _bind_core('', what, context, cmd, args)
- end
-
- def _bind_append(what, context, cmd, args=nil)
- _bind_core('+', what, context, cmd, args)
- end
-
- def _bind_remove(what, context)
- tk_call(*(what + ["<#{tk_event_sequence(context)}>", '']))
- end
-
- def _bindinfo(what, context=nil)
- if context
- tk_call(*what+["<#{tk_event_sequence(context)}>"]).collect {|cmdline|
- if cmdline =~ /^rb_out (c\d+)\s+(.*)$/
- #[Tk_CMDTBL[$1], $2]
- [TkCore::INTERP.tk_cmd_tbl[$1], $2]
- else
- cmdline
- end
- }
- else
- tk_split_simplelist(tk_call(*what)).collect!{|seq|
- 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
- }
- end
- end
- private :install_bind, :tk_event_sequence,
- :_bind_core, :_bind, :_bind_append, :_bind_remove, :_bindinfo
-
- def bind(tagOrClass, context, cmd=Proc.new, args=nil)
- _bind(["bind", tagOrClass], context, cmd, args)
- tagOrClass
- end
-
- def bind_append(tagOrClass, context, cmd=Proc.new, args=nil)
- _bind_append(["bind", tagOrClass], context, cmd, args)
- tagOrClass
- end
-
- def bind_remove(tagOrClass, context)
- _bind_remove(['bind', tagOrClass], context)
- tagOrClass
- end
-
- def bindinfo(tagOrClass, context=nil)
- _bindinfo(['bind', tagOrClass], context)
- end
-
- def bind_all(context, cmd=Proc.new, args=nil)
- _bind(['bind', 'all'], context, cmd, args)
- TkBindTag::ALL
- end
-
- def bind_append_all(context, cmd=Proc.new, args=nil)
- _bind_append(['bind', 'all'], context, cmd, args)
- TkBindTag::ALL
- end
-
- def bind_remove_all(context)
- _bind_remove(['bind', 'all'], context)
- TkBindTag::ALL
- end
-
- def bindinfo_all(context=nil)
- _bindinfo(['bind', 'all'], context)
- end
-
- def pack(*args)
- TkPack.configure(*args)
- end
-
- def grid(*args)
- TkGrid.configure(*args)
- end
-
- def update(idle=nil)
- if idle
- tk_call 'update', 'idletasks'
- else
- tk_call 'update'
- end
- end
-
-end
-
-module TkCore
- include TkComm
- extend TkComm
-
- unless self.const_defined? :INTERP
- if self.const_defined? :IP_NAME
- name = IP_NAME.to_s
- else
- name = nil
- end
- if self.const_defined? :IP_OPTS
- if IP_OPTS.kind_of?(Hash)
- opts = hash_kv(IP_OPTS).join(' ')
- else
- opts = IP_OPTS.to_s
- end
- else
- opts = ''
- end
-
- INTERP = TclTkIp.new(name, opts)
-
- def INTERP.__getip
- self
- end
-
- INTERP.instance_eval{
- @tk_cmd_tbl = {}.taint
- @tk_windows = {}.taint
-
- @tk_table_list = [].taint
-
- @init_ip_env = [].taint # table of Procs
- @add_tk_procs = [].taint # table of [name, args, body]
-
- @cb_entry_class = Class.new{|c|
- def initialize(ip, cmd)
- @ip = ip
- @cmd = cmd
- end
- attr_reader :ip, :cmd
- def call(*args)
- @ip.cb_eval(@cmd, *args)
- end
- }
- }
-
- def INTERP.tk_cmd_tbl
- @tk_cmd_tbl
- end
- def INTERP.tk_windows
- @tk_windows
- end
-
- def INTERP.tk_object_table(id)
- @tk_table_list[id]
- end
- def INTERP.create_table
- id = @tk_table_list.size
- (tbl = {}).tainted? || tbl.taint
- @tk_table_list << tbl
- obj = Object.new
- obj.instance_eval <<-EOD
- def self.method_missing(m, *args)
- TkCore::INTERP.tk_object_table(#{id}).send(m, *args)
- end
- EOD
- return obj
- end
-
- def INTERP.get_cb_entry(cmd)
- @cb_entry_class.new(__getip, cmd).freeze
- end
- def INTERP.cb_eval(cmd, *args)
- TkComm._get_eval_string(TkUtil.eval_cmd(cmd, *args))
- end
-
- def INTERP.init_ip_env(script = Proc.new)
- @init_ip_env << script
- script.call(self)
- end
- def INTERP.add_tk_procs(name, args = nil, body = nil)
- @add_tk_procs << [name, args, body]
- self._invoke('proc', name, args, body) if args && body
- 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
-
- INTERP.add_tk_procs('rb_out', 'args', <<-'EOL')
- regsub -all {!} $args {\\!} args
- regsub -all "{" $args "\\{" args
- if {[set st [catch {ruby [format "TkCore.callback %%Q!%s!" $args]} ret]] != 0} {
- return -code $st $ret
- } {
- return $ret
- }
- EOL
-
- EventFlag = TclTkLib::EventFlag
-
- def callback_break
- fail TkCallbackBreak, "Tk callback returns 'break' status"
- end
-
- def callback_continue
- fail TkCallbackContinue, "Tk callback returns 'continue' status"
- end
-
- def TkCore.callback(arg)
- # arg = tk_split_list(arg)
- arg = tk_split_simplelist(arg)
- #_get_eval_string(TkUtil.eval_cmd(Tk_CMDTBL[arg.shift], *arg))
- #_get_eval_string(TkUtil.eval_cmd(TkCore::INTERP.tk_cmd_tbl[arg.shift],
- # *arg))
- cb_obj = TkCore::INTERP.tk_cmd_tbl[arg.shift]
- unless $DEBUG
- cb_obj.call(*arg)
- else
- begin
- raise 'check backtrace'
- rescue
- # ignore backtrace before 'callback'
- pos = -($!.backtrace.size)
- end
- begin
- cb_obj.call(*arg)
- rescue
- trace = $!.backtrace
- raise $!, "\n#{trace[0]}: #{$!.message} (#{$!.class})\n" +
- "\tfrom #{trace[1..pos].join("\n\tfrom ")}"
- end
- end
- end
-
- def load_cmd_on_ip(tk_cmd)
- bool(tk_call('auto_load', tk_cmd))
- end
-
- def after(ms, cmd=Proc.new)
- myid = _curr_cmd_id
- cmdid = install_cmd(cmd)
- tk_call("after",ms,cmdid)
-# return
-# if false #defined? Thread
-# Thread.start do
-# ms = Float(ms)/1000
-# ms = 10 if ms == 0
-# sleep ms/1000
-# cmd.call
-# end
-# else
-# cmdid = install_cmd(cmd)
-# tk_call("after",ms,cmdid)
-# end
- end
-
- def after_idle(cmd=Proc.new)
- myid = _curr_cmd_id
- cmdid = install_cmd(cmd)
- tk_call('after','idle',cmdid)
- end
-
- def clock_clicks(ms=nil)
- if ms
- tk_call('clock','clicks','-milliseconds').to_i
- else
- tk_call('clock','clicks').to_i
- end
- end
-
- def clock_format(clk, form=nil)
- if form
- tk_call('clock','format',clk,'-format',form).to_i
- else
- tk_call('clock','format',clk).to_i
- end
- end
-
- def clock_formatGMT(clk, form=nil)
- if form
- tk_call('clock','format',clk,'-format',form,'-gmt','1').to_i
- else
- tk_call('clock','format',clk,'-gmt','1').to_i
- end
- end
-
- def clock_scan(str, base=nil)
- if base
- tk_call('clock','scan',str,'-base',base).to_i
- else
- tk_call('clock','scan',str).to_i
- end
- end
-
- def clock_scanGMT(str, base=nil)
- if base
- tk_call('clock','scan',str,'-base',base,'-gmt','1').to_i
- else
- tk_call('clock','scan',str,'-gmt','1').to_i
- end
- end
-
- def clock_seconds
- tk_call('clock','seconds').to_i
- end
-
- def windowingsystem
- tk_call('tk', 'windowingsystem')
- end
-
- def scaling(scale=nil)
- if scale
- tk_call('tk', 'scaling', scale)
- else
- Float(number(tk_call('tk', 'scaling')))
- end
- end
- def scaling_displayof(win, scale=nil)
- if scale
- tk_call('tk', 'scaling', '-displayof', win, scale)
- else
- Float(number(tk_call('tk', '-displayof', win, 'scaling')))
- end
- end
-
- def appname(name=None)
- tk_call('tk', 'appname', name)
- end
-
- def appsend(interp, async, *args)
- if async
- tk_call('send', '-async', '--', interp, *args)
- else
- tk_call('send', '--', interp, *args)
- end
- end
-
- def rb_appsend(interp, async, *args)
- args = args.collect!{|c| _get_eval_string(c).gsub(/[\[\]$"]/, '\\\\\&')}
- args.push(').to_s"')
- appsend(interp, async, 'ruby "(', *args)
- end
-
- def appsend_displayof(interp, win, async, *args)
- win = '.' if win == nil
- 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)
- args = args.collect!{|c| _get_eval_string(c).gsub(/[\[\]$"]/, '\\\\\&')}
- args.push(').to_s"')
- appsend_displayof(interp, win, async, 'ruby "(', *args)
- end
-
- def info(*args)
- tk_call('info', *args)
- end
-
- def mainloop(check_root = true)
- TclTkLib.mainloop(check_root)
- end
-
- def mainloop_watchdog(check_root = true)
- # watchdog restarts mainloop when mainloop is dead
- TclTkLib.mainloop_watchdog(check_root)
- end
-
- def do_one_event(flag = TclTkLib::EventFlag::ALL)
- 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
-
- def set_no_event_wait(wait)
- TclTkLib.set_no_even_wait(wait)
- end
-
- def get_no_event_wait()
- TclTkLib.get_no_eventloop_wait
- end
-
- 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
-
- def restart(app_name = nil, keys = {})
- TkCore::INTERP.init_ip_internal
-
- tk_call('set', 'argv0', app_name) if app_name
- if keys.kind_of?(Hash)
- # tk_call('set', 'argc', keys.size * 2)
- tk_call('set', 'argv', hash_kv(keys).join(' '))
- end
-
- INTERP.restart
- nil
- end
-
- def event_generate(window, context, keys=nil)
- window = window.path if window.kind_of? TkObject
- if keys
- tk_call('event', 'generate', window,
- "<#{tk_event_sequence(context)}>", *hash_kv(keys))
- else
- tk_call('event', 'generate', window, "<#{tk_event_sequence(context)}>")
- end
- end
-
- def messageBox(keys)
- tk_call 'tk_messageBox', *hash_kv(keys)
- end
-
- def getOpenFile(keys = nil)
- tk_call 'tk_getOpenFile', *hash_kv(keys)
- end
-
- def getSaveFile(keys = nil)
- tk_call 'tk_getSaveFile', *hash_kv(keys)
- end
-
- def chooseColor(keys = nil)
- tk_call 'tk_chooseColor', *hash_kv(keys)
- end
-
- def chooseDirectory(keys = nil)
- tk_call 'tk_chooseDirectory', *hash_kv(keys)
- end
-
- def ip_eval(cmd_string)
- res = INTERP._eval(cmd_string)
- if INTERP._return_value() != 0
- fail RuntimeError, res, error_at
- end
- return res
- end
-
- def ip_invoke(*args)
- res = INTERP._invoke(*args)
- if INTERP._return_value() != 0
- fail RuntimeError, res, error_at
- end
- return res
- end
-
- def tk_call(*args)
- puts args.inspect if $DEBUG
- args.collect! {|x|ruby2tcl(x)}
- args.compact!
- args.flatten!
- print "=> ", args.join(" ").inspect, "\n" if $DEBUG
- begin
- # res = INTERP._invoke(*args).taint
- res = INTERP._invoke(*args) # _invoke returns a TAINTED string
- rescue NameError => err
-# err = $!
- begin
- args.unshift "unknown"
- #res = INTERP._invoke(*args).taint
- res = INTERP._invoke(*args) # _invoke returns a TAINTED string
- rescue StandardError => err2
- fail err2 unless /^invalid command/ =~ err2
- fail err
- end
- end
- if INTERP._return_value() != 0
- fail RuntimeError, res, error_at
- end
- print "==> ", res.inspect, "\n" if $DEBUG
- return res
- end
-end
-
-module TkPackage
- include TkCore
- extend TkPackage
-
- TkCommandNames = ['package'.freeze].freeze
-
- def add_path(path)
- Tk::AUTO_PATH.value = Tk::AUTO_PATH.to_a << path
- end
-
- def forget(package)
- tk_call('package', 'forget', package)
- nil
- end
-
- def names
- tk_split_simplelist(tk_call('package', 'names'))
- end
-
- def provide(package, version=nil)
- if version
- tk_call('package', 'provide', package, version)
- nil
- else
- tk_call('package', 'provide', package)
- end
- end
-
- def present(package, version=None)
- tk_call('package', 'present', package, version)
- end
-
- def present_exact(package, version)
- tk_call('package', 'present', '-exact', package, version)
- end
-
- def require(package, version=None)
- tk_call('package', 'require', package, version)
- end
-
- def require_exact(package, version)
- tk_call('package', 'require', '-exact', package, version)
- end
-
- def versions(package)
- tk_split_simplelist(tk_call('package', 'versions', package))
- end
-
- def vcompare(version1, version2)
- Integer(tk_call('package', 'vcompare', version1, version2))
- end
-
- def vsatisfies(version1, version2)
- bool(tk_call('package', 'vsatisfies', version1, version2))
- end
-end
-
-module Tk
- include TkCore
- extend Tk
-
- TCL_VERSION = INTERP._invoke("info", "tclversion").freeze
- TCL_PATCHLEVEL = INTERP._invoke("info", "patchlevel").freeze
-
- TK_VERSION = INTERP._invoke("set", "tk_version").freeze
- TK_PATCHLEVEL = INTERP._invoke("set", "tk_patchLevel").freeze
-
- JAPANIZED_TK = (INTERP._invoke("info", "commands", "kanji") != "").freeze
-
- def Tk.const_missing(sym)
- case(sym)
- when :TCL_LIBRARY
- INTERP._invoke("set", "tcl_library").freeze
-
- when :TK_LIBRARY
- INTERP._invoke("set", "tk_library").freeze
-
- when :LIBRARY
- INTERP._invoke("info", "library").freeze
-
- #when :PKG_PATH, :PACKAGE_PATH, :TCL_PACKAGE_PATH
- # tk_split_simplelist(INTERP._invoke('set', 'tcl_pkgPath'))
-
- #when :LIB_PATH, :LIBRARY_PATH, :TCL_LIBRARY_PATH
- # tk_split_simplelist(INTERP._invoke('set', 'tcl_libPath'))
-
- when :PLATFORM, :TCL_PLATFORM
- Hash[*tk_split_simplelist(INTERP._invoke('array', 'get',
- 'tcl_platform'))]
-
- when :ENV
- 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
- Hash[*tk_split_simplelist(INTERP._invoke('array', 'get', 'auto_index'))]
-
- when :PRIV, :PRIVATE, :TK_PRIV
- priv = {}
- if INTERP._invoke('info', 'vars', 'tk::Priv') != ""
- var_nam = 'tk::Priv'
- else
- var_nam = 'tkPriv'
- end
- Hash[*tk_split_simplelist(INTERP._invoke('array', 'get',
- 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
- }
- priv
-
- else
- raise NameError, 'uninitialized constant Tk::' + sym.id2name
- end
- end
-
- def root
- TkRoot.new
- end
-
- def Tk.bell(nice = false)
- if nice
- tk_call 'bell', '-nice'
- else
- tk_call 'bell'
- end
- end
-
- def Tk.bell_on_display(win, nice = false)
- if nice
- tk_call('bell', '-displayof', win, '-nice')
- else
- tk_call('bell', '-displayof', win)
- end
- end
-
- def Tk.destroy(*wins)
- tk_call('destroy', *wins)
- end
-
- def Tk.exit
- tk_call('destroy', '.')
- end
-
- def Tk.current_grabs
- tk_split_list(tk_call('grab', 'current'))
- end
-
- def Tk.focus(display=nil)
- if display == nil
- window(tk_call('focus'))
- else
- window(tk_call('focus', '-displayof', display))
- end
- end
-
- def Tk.focus_lastfor(win)
- window(tk_call('focus', '-lastfor', win))
- end
-
- def Tk.focus_next(win)
- TkManageFocus.next(win)
- end
-
- def Tk.focus_prev(win)
- TkManageFocus.prev(win)
- end
-
- def Tk.strictMotif(bool=None)
- bool(tk_call('set', 'tk_strictMotif', bool))
- end
-
- 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
-
- def Tk.toUTF8(str,encoding)
- INTERP._toUTF8(str,encoding)
- end
-
- def Tk.fromUTF8(str,encoding)
- INTERP._fromUTF8(str,encoding)
- end
-
- module Scrollable
- def xscrollcommand(cmd=Proc.new)
- configure_cmd 'xscrollcommand', cmd
- end
- def yscrollcommand(cmd=Proc.new)
- configure_cmd 'yscrollcommand', cmd
- end
- def xview(*index)
- v = tk_send('xview', *index)
- list(v) if index.size == 0
- end
- def yview(*index)
- v = tk_send('yview', *index)
- list(v) if index.size == 0
- end
- def xscrollbar(bar=nil)
- if bar
- @xscrollbar = bar
- @xscrollbar.orient 'horizontal'
- self.xscrollcommand {|*arg| @xscrollbar.set(*arg)}
- @xscrollbar.command {|*arg| self.xview(*arg)}
- end
- @xscrollbar
- end
- def yscrollbar(bar=nil)
- if bar
- @yscrollbar = bar
- @yscrollbar.orient 'vertical'
- self.yscrollcommand {|*arg| @yscrollbar.set(*arg)}
- @yscrollbar.command {|*arg| self.yview(*arg)}
- end
- @yscrollbar
- end
- end
-
- module Wm
- include TkComm
-
- TkCommandNames = ['wm'.freeze].freeze
-
- def aspect(*args)
- w = tk_call('wm', 'aspect', path, *args)
- if args.length == 0
- list(w)
- else
- self
- end
- end
- def attributes(slot=nil,value=None)
- if slot == nil
- lst = tk_split_list(tk_call('wm', 'attributes', path))
- info = {}
- while key = lst.shift
- info[key[1..-1]] = lst.shift
- end
- info
- elsif slot.kind_of? Hash
- tk_call('wm', 'attributes', path, *hash_kv(slot))
- self
- elsif value == None
- tk_call('wm', 'attributes', path, "-#{slot}")
- else
- tk_call('wm', 'attributes', path, "-#{slot}", value)
- self
- end
- end
- def client(name=None)
- if name == None
- tk_call 'wm', 'client', path
- else
- name = '' if name == nil
- tk_call 'wm', 'client', path, name
- self
- end
- end
- def colormapwindows(*args)
- r = tk_call('wm', 'colormapwindows', path, *args)
- if args.size == 0
- list(r)
- else
- self
- end
- end
- def wm_command(value=nil)
- if value
- tk_call('wm', 'command', path, value)
- self
- else
- procedure(tk_call('wm', 'command', path))
- end
- end
- def deiconify(ex = true)
- tk_call('wm', 'deiconify', path) if ex
- self
- end
- def focusmodel(mode = nil)
- if mode
- tk_call 'wm', 'focusmodel', path, mode
- self
- else
- tk_call 'wm', 'focusmodel', path
- end
- end
- def frame
- tk_call('wm', 'frame', path)
- end
- def geometry(geom=nil)
- if geom
- tk_call('wm', 'geometry', path, geom)
- self
- else
- tk_call('wm', 'geometry', path)
- end
- end
- def grid(*args)
- w = tk_call('wm', 'grid', path, *args)
- if args.size == 0
- list(w)
- else
- self
- end
- end
- def group(*args)
- w = tk_call('wm', 'group', path, *args)
- if args.size == 0
- window(w)
- else
- self
- end
- end
- def iconbitmap(bmp=nil)
- if bmp
- tk_call 'wm', 'iconbitmap', path, bmp
- self
- else
- tk_call 'wm', 'iconbitmap', path
- end
- end
- def iconify(ex = true)
- tk_call('wm', 'iconify', path) if ex
- self
- end
- def iconmask(bmp=nil)
- if bmp
- tk_call 'wm', 'iconmask', path, bmp
- self
- else
- tk_call 'wm', 'iconmask', path
- end
- end
- def iconname(name=nil)
- if name
- tk_call 'wm', 'iconname', path, name
- self
- else
- tk_call 'wm', 'iconname', path
- end
- end
- def iconposition(*args)
- w = tk_call('wm', 'iconposition', path, *args)
- if args.size == 0
- list(w)
- else
- self
- end
- end
- def iconwindow(*args)
- w = tk_call('wm', 'iconwindow', path, *args)
- if args.size == 0
- window(w)
- else
- self
- end
- end
- def maxsize(*args)
- w = tk_call('wm', 'maxsize', path, *args)
- if args.size == 0
- list(w)
- else
- self
- end
- end
- def minsize(*args)
- w = tk_call('wm', 'minsize', path, *args)
- if args.size == 0
- list(w)
- else
- self
- end
- end
- def overrideredirect(bool=None)
- if bool == None
- bool(tk_call('wm', 'overrideredirect', path))
- else
- tk_call 'wm', 'overrideredirect', path, bool
- self
- end
- end
- def positionfrom(who=None)
- if who == None
- r = tk_call('wm', 'positionfrom', path)
- (r == "")? nil: r
- else
- tk_call('wm', 'positionfrom', path, who)
- self
- end
- end
- def protocol(name=nil, cmd=nil)
- if cmd
- tk_call('wm', 'protocol', path, name, cmd)
- self
- elsif name
- result = tk_call('wm', 'protocol', path, name)
- (result == "")? nil : tk_tcl2ruby(result)
- else
- tk_split_simplelist(tk_call('wm', 'protocol', path))
- end
- end
- def resizable(*args)
- w = tk_call('wm', 'resizable', path, *args)
- if args.length == 0
- list(w).collect{|e| bool(e)}
- else
- self
- end
- end
- def sizefrom(who=None)
- if who == None
- r = tk_call('wm', 'sizefrom', path)
- (r == "")? nil: r
- else
- tk_call('wm', 'sizefrom', path, who)
- self
- end
- end
- def stackorder
- list(tk_call('wm', 'stackorder', path))
- end
- def stackorder_isabove(win)
- bool(tk_call('wm', 'stackorder', path, 'isabove', win))
- end
- def stackorder_isbelow(win)
- bool(tk_call('wm', 'stackorder', path, 'isbelow', win))
- end
- def state(state=nil)
- if state
- tk_call 'wm', 'state', path, state
- self
- else
- tk_call 'wm', 'state', path
- end
- end
- def title(str=nil)
- if str
- tk_call('wm', 'title', path, str)
- self
- else
- tk_call('wm', 'title', path)
- end
- end
- def transient(master=nil)
- if master
- tk_call('wm', 'transient', path, master)
- self
- else
- window(tk_call('wm', 'transient', path, master))
- end
- end
- def withdraw(ex = true)
- tk_call('wm', 'withdraw', path) if ex
- self
- end
- end
-end
-
-###########################################
-# string with Tcl's encoding
-###########################################
-module Tk
- class EncodedString < String
- @@enc_buf = '__rb_encoding_buffer__'
-
- def self.tk_escape(str)
- s = '"' + str.gsub(/[\[\]$"]/, '\\\\\&') + '"'
- TkCore::INTERP.__eval(Kernel.format('global %s; set %s %s',
- @@enc_buf, @@enc_buf, s))
- end
-
- def self.new(str, enc = Tk.encoding_system)
- obj = super(self.tk_escape(str))
- obj.instance_eval{@enc = enc}
- obj
- end
-
- def self.new_without_escape(str, enc = Tk.encoding_system)
- obj = super(str)
- obj.instance_eval{@enc = enc}
- obj
- end
-
- def encoding
- @enc
- end
- end
- def Tk.EncodedString(str, enc = Tk.encoding_system)
- Tk::EncodedString.new(str, enc)
- end
-
- class UTF8_String < EncodedString
- def self.new(str)
- super(str, 'utf-8')
- end
- def self.new_without_escape(str)
- super(str, 'utf-8')
- end
- end
- def Tk.UTF8_String(str)
- Tk::UTF8_String.new(str)
- end
-end
-
-
-###########################################
-# convert kanji string to/from utf-8
-###########################################
-if /^8\.[1-9]/ =~ Tk::TCL_VERSION && !Tk::JAPANIZED_TK
- class TclTkIp
- # from tkencoding.rb by ttate@jaist.ac.jp
- alias __eval _eval
- alias __invoke _invoke
-
- attr_accessor :encoding
-
- def _eval(cmd)
- if defined? @encoding
- if cmd.kind_of?(Tk::EncodedString)
- _fromUTF8(__eval(_toUTF8(cmd, cmd.encoding)), @encoding)
- else
- _fromUTF8(__eval(_toUTF8(cmd, @encoding)), @encoding)
- end
- else
- __eval(cmd)
- end
- end
-
- def _invoke(*cmds)
- if defined? @encoding
- cmds = cmds.collect{|cmd|
- if cmd.kind_of?(Tk::EncodedString)
- _toUTF8(cmd, cmd.encoding)
- else
- _toUTF8(cmd, @encoding)
- end
- }
- _fromUTF8(__invoke(*cmds), @encoding)
- else
- __invoke(*cmds)
- end
- end
- end
-
- module Tk
- module Encoding
- extend Encoding
-
- TkCommandNames = ['encoding'.freeze].freeze
-
- def encoding=(name)
- TkCore::INTERP.encoding = name
- end
-
- def encoding
- TkCore::INTERP.encoding
- end
-
- def encoding_names
- tk_split_simplelist(tk_call('encoding', 'names'))
- end
-
- def encoding_system
- tk_call('encoding', 'system')
- end
-
- def encoding_system=(enc)
- tk_call('encoding', 'system', enc)
- end
-
- def encoding_convertfrom(str, enc=None)
- TkCore::INTERP.__invoke('encoding', 'convertfrom', enc, str)
- end
- alias encoding_convert_from encoding_convertfrom
-
- def encoding_convertto(str, enc=None)
- TkCore::INTERP.__invoke('encoding', 'convertto', enc, str)
- end
- alias encoding_convert_to encoding_convertto
- end
-
- extend Encoding
- end
-
- # estimate encoding
- case $KCODE
- when /^e/i # EUC
- Tk.encoding = 'euc-jp'
- when /^s/i # SJIS
- Tk.encoding = 'shiftjis'
- when /^u/i # UTF8
- Tk.encoding = 'utf-8'
- else # NONE
- begin
- Tk.encoding = Tk.encoding_system
- rescue StandardError, NameError
- Tk.encoding = 'utf-8'
- end
- end
-
-else
- # dummy methods
- class TclTkIp
- alias __eval _eval
- alias __invoke _invoke
- end
-
- module Tk
- module Encoding
- extend Encoding
-
- def encoding=(name)
- nil
- end
- def encoding
- nil
- end
- def encoding_names
- nil
- end
- def encoding_system
- nil
- end
- def encoding_system=(enc)
- nil
- end
-
- def encoding_convertfrom(str, enc=None)
- str
- end
- alias encoding_convert_from encoding_convertfrom
-
- def encoding_convertto(str, enc=None)
- str
- end
- alias encoding_convert_to encoding_convertto
- end
-
- extend Encoding
- end
-end
-
-module TkBindCore
- def bind(context, cmd=Proc.new, args=nil)
- Tk.bind(self, context, cmd, args)
- end
-
- def bind_append(context, cmd=Proc.new, args=nil)
- Tk.bind_append(self, context, cmd, args)
- end
-
- def bind_remove(context)
- Tk.bind_remove(self, context)
- end
-
- def bindinfo(context=nil)
- Tk.bindinfo(self, context)
- end
-end
-
-class TkBindTag
- include TkBindCore
-
- #BTagID_TBL = {}
- BTagID_TBL = TkCore::INTERP.create_table
- Tk_BINDTAG_ID = ["btag".freeze, "00000".taint].freeze
-
- TkCore::INTERP.init_ip_env{ BTagID_TBL.clear }
-
- def TkBindTag.id2obj(id)
- BTagID_TBL[id]? BTagID_TBL[id]: id
- end
-
- def TkBindTag.new_by_name(name, *args, &b)
- return BTagID_TBL[name] if BTagID_TBL[name]
- self.new(*args, &b).instance_eval{
- BTagID_TBL.delete @id
- @id = name
- BTagID_TBL[@id] = self
- }
- end
-
- def initialize(*args, &b)
- @id = Tk_BINDTAG_ID.join
- Tk_BINDTAG_ID[1].succ!
- BTagID_TBL[@id] = self
- bind(*args, &b) if args != []
- end
-
- ALL = self.new_by_name('all')
-
- def name
- @id
- end
-
- def to_eval
- @id
- end
-
- def inspect
- Kernel.format "#<TkBindTag: %s>", @id
- end
-end
-
-class TkBindTagAll<TkBindTag
- def TkBindTagAll.new(*args, &b)
- $stderr.puts "Warning: TkBindTagALL is obsolete. Use TkBindTag::ALL\n"
-
- TkBindTag::ALL.bind(*args, &b) if args != []
- TkBindTag::ALL
- end
-end
-
-class TkDatabaseClass<TkBindTag
- def self.new(name, *args, &b)
- return BTagID_TBL[name] if BTagID_TBL[name]
- super(name, *args, &b)
- end
-
- def initialize(name, *args, &b)
- @id = name
- BTagID_TBL[@id] = self
- bind(*args, &b) if args != []
- end
-
- def inspect
- Kernel.format "#<TkDatabaseClass: %s>", @id
- end
-end
-
-class TkVariable
- include Tk
- extend TkCore
-
- include Comparable
-
- #TkCommandNames = ['tkwait'.freeze].freeze
- TkCommandNames = ['vwait'.freeze].freeze
-
- #TkVar_CB_TBL = {}
- #TkVar_ID_TBL = {}
- TkVar_CB_TBL = TkCore::INTERP.create_table
- TkVar_ID_TBL = TkCore::INTERP.create_table
- Tk_VARIABLE_ID = ["v".freeze, "00000".taint].freeze
-
- TkCore::INTERP.add_tk_procs('rb_var', 'args',
- "ruby [format \"TkVariable.callback %%Q!%s!\" $args]")
-
- def TkVariable.callback(args)
- name1,name2,op = tk_split_list(args)
- if TkVar_CB_TBL[name1]
- _get_eval_string(TkVar_CB_TBL[name1].trace_callback(name2,op))
- else
- ''
- end
- end
-
- def initialize(val="")
- @id = Tk_VARIABLE_ID.join
- Tk_VARIABLE_ID[1].succ!
- TkVar_ID_TBL[@id] = self
-
- @trace_var = nil
- @trace_elem = nil
- @trace_opts = nil
-
-=begin
- if val == []
- # INTERP._eval(format('global %s; set %s(0) 0; unset %s(0)',
- # @id, @id, @id))
- elsif val.kind_of?(Array)
- a = []
- # val.each_with_index{|e,i| a.push(i); a.push(array2tk_list(e))}
- # s = '"' + a.join(" ").gsub(/[\[\]$"]/, '\\\\\&') + '"'
- val.each_with_index{|e,i| a.push(i); a.push(e)}
- s = '"' + array2tk_list(a).gsub(/[\[\]$"]/, '\\\\\&') + '"'
- INTERP._eval(format('global %s; array set %s %s', @id, @id, s))
- elsif val.kind_of?(Hash)
- s = '"' + val.to_a.collect{|e| array2tk_list(e)}.join(" ")\
- .gsub(/[\[\]$"]/, '\\\\\&') + '"'
- INTERP._eval(format('global %s; array set %s %s', @id, @id, s))
- else
- s = '"' + _get_eval_string(val).gsub(/[\[\]$"]/, '\\\\\&') + '"'
- INTERP._eval(format('global %s; set %s %s', @id, @id, s))
- end
-=end
- if val.kind_of?(Hash)
- s = '"' + val.to_a.collect{|e| array2tk_list(e)}.join(" ")\
- .gsub(/[\[\]$"]/, '\\\\\&') + '"'
- INTERP._eval(Kernel.format('global %s; array set %s %s', @id, @id, s))
- else
- s = '"' + _get_eval_string(val).gsub(/[\[\]$"]/, '\\\\\&') + '"'
- INTERP._eval(Kernel.format('global %s; set %s %s', @id, @id, s))
- end
- end
-
- def wait(on_thread = false, check_root = false)
- if $SAFE >= 4
- fail SecurityError, "can't wait variable at $SAFE >= 4"
- end
- if on_thread
- if check_root
- INTERP._thread_tkwait('variable', @id)
- else
- INTERP._thread_vwait(@id)
- end
- else
- if check_root
- INTERP._invoke('tkwait', 'variable', @id)
- else
- INTERP._invoke('vwait', @id)
- end
- end
- end
- def eventloop_wait(check_root = false)
- wait(false, check_root)
- end
- def thread_wait(check_root = false)
- wait(true, check_root)
- end
- def tkwait(on_thread = true)
- wait(on_thread, true)
- end
- def eventloop_tkwait
- wait(false, true)
- end
- def thread_tkwait
- wait(true, true)
- end
-
- def id
- @id
- end
-
- def value
- begin
- INTERP._eval(Kernel.format('global %s; set %s', @id, @id))
- rescue
- if INTERP._eval(Kernel.format('global %s; array exists %s',
- @id, @id)) != "1"
- fail
- else
- Hash[*tk_split_simplelist(INTERP._eval(Kernel.format('global %s; array get %s', @id, @id)))]
- end
- end
- end
-
- def value=(val)
- begin
- s = '"' + _get_eval_string(val).gsub(/[\[\]$"]/, '\\\\\&') + '"'
- INTERP._eval(Kernel.format('global %s; set %s %s', @id, @id, s))
- rescue
- if INTERP._eval(Kernel.format('global %s; array exists %s',
- @id, @id)) != "1"
- fail
- else
- if val == []
- INTERP._eval(Kernel.format('global %s; unset %s; set %s(0) 0; unset %s(0)', @id, @id, @id, @id))
- elsif val.kind_of?(Array)
- a = []
- val.each_with_index{|e,i| a.push(i); a.push(array2tk_list(e))}
- s = '"' + a.join(" ").gsub(/[\[\]$"]/, '\\\\\&') + '"'
- INTERP._eval(Kernel.format('global %s; unset %s; array set %s %s',
- @id, @id, @id, s))
- elsif val.kind_of?(Hash)
- s = '"' + val.to_a.collect{|e| array2tk_list(e)}.join(" ")\
- .gsub(/[\[\]$"]/, '\\\\\&') + '"'
- INTERP._eval(Kernel.format('global %s; unset %s; array set %s %s',
- @id, @id, @id, s))
- else
- fail
- end
- end
- end
- end
-
- def [](index)
- INTERP._eval(Kernel.format('global %s; set %s(%s)',
- @id, @id, _get_eval_string(index)))
- end
-
- def []=(index,val)
- INTERP._eval(Kernel.format('global %s; set %s(%s) %s', @id, @id,
- _get_eval_string(index), _get_eval_string(val)))
- end
-
- def numeric
- number(value)
- end
- def numeric=(val)
- case val
- when Numeric
- self.value=(val)
- when TkVariable
- self.value=(val.numeric)
- else
- raise ArgumentError, "Numeric is expected"
- end
- end
-
- def to_i
- number(value).to_i
- end
-
- def to_f
- number(value).to_f
- end
-
- def to_s
- string(value).to_s
- end
-
- def to_sym
- value.intern
- end
-
- def list
- tk_split_list(value)
- end
- alias to_a list
-
- def list=(val)
- case val
- when Array
- self.value=(val)
- when TkVariable
- self.value=(val.list)
- else
- raise ArgumentError, "Array is expected"
- end
- end
-
- def inspect
- Kernel.format "#<TkVariable: %s>", @id
- end
-
- def coerce(other)
- case other
- when TkVariable
- [other.value, self.value]
- when String
- [other, self.to_s]
- when Symbol
- [other, self.to_sym]
- when Integer
- [other, self.to_i]
- when Float
- [other, self.to_f]
- when Array
- [other, self.to_a]
- else
- [other, self.value]
- end
- end
-
- def &(other)
- if other.kind_of?(Array)
- self.to_a & other.to_a
- else
- self.to_i & other.to_i
- end
- end
- def |(other)
- if other.kind_of?(Array)
- self.to_a | other.to_a
- else
- self.to_i | other.to_i
- end
- end
- def +(other)
- case other
- when Array
- self.to_a + other
- when String
- self.value + other
- else
- begin
- number(self.value) + other
- rescue
- self.value + other.to_s
- end
- end
- end
- def -(other)
- if other.kind_of?(Array)
- self.to_a - other
- else
- number(self.value) - other
- end
- end
- def *(other)
- begin
- number(self.value) * other
- rescue
- self.value * other
- end
- end
- def /(other)
- number(self.value) / other
- end
- def %(other)
- begin
- number(self.value) % other
- rescue
- self.value % other
- end
- end
- def **(other)
- number(self.value) ** other
- end
- def =~(other)
- self.value =~ other
- end
-
- def ==(other)
- case other
- when TkVariable
- self.equal?(other)
- when String
- self.to_s == other
- when Symbol
- self.to_sym == other
- when Integer
- self.to_i == other
- when Float
- self.to_f == other
- when Array
- self.to_a == other
- when Hash
- self.value == other
- else
- false
- end
- end
-
- def zero?
- numeric.zero?
- end
- def nonzero?
- !(numeric.zero?)
- end
-
- def <=>(other)
- if other.kind_of?(TkVariable)
- begin
- val = other.numeric
- other = val
- rescue
- other = other.value
- end
- end
- if other.kind_of?(Numeric)
- begin
- return self.numeric <=> other
- rescue
- return self.value <=> other.to_s
- end
- else
- return self.value <=> other
- end
- end
-
- def to_eval
- @id
- end
-
- def unset(elem=nil)
- if elem
- INTERP._eval(Kernel.format('global %s; unset %s(%s)',
- @id, @id, tk_tcl2ruby(elem)))
- else
- INTERP._eval(Kernel.format('global %s; unset %s', @id, @id))
- end
- end
- alias remove unset
-
- def trace_callback(elem, op)
- if @trace_var.kind_of? Array
- @trace_var.each{|m,e| e.call(self,elem,op) if m.index(op)}
- end
- if elem.kind_of? String
- if @trace_elem[elem].kind_of? Array
- @trace_elem[elem].each{|m,e| e.call(self,elem,op) if m.index(op)}
- end
- end
- end
-
- def trace(opts, cmd)
- @trace_var = [] if @trace_var == nil
- opts = ['r','w','u'].find_all{|c| opts.index(c)}.join('')
- @trace_var.unshift([opts,cmd])
- if @trace_opts == nil
- TkVar_CB_TBL[@id] = self
- @trace_opts = opts
- Tk.tk_call('trace', 'variable', @id, @trace_opts, 'rb_var')
- else
- newopts = @trace_opts.dup
- opts.each_byte{|c| newopts += c.chr unless newopts.index(c)}
- if newopts != @trace_opts
- Tk.tk_call('trace', 'vdelete', @id, @trace_opts, 'rb_var')
- @trace_opts.replace(newopts)
- Tk.tk_call('trace', 'variable', @id, @trace_opts, 'rb_var')
- end
- end
- end
-
- def trace_element(elem, opts, cmd)
- @trace_elem = {} if @trace_elem == nil
- @trace_elem[elem] = [] if @trace_elem[elem] == nil
- opts = ['r','w','u'].find_all{|c| opts.index(c)}.join('')
- @trace_elem[elem].unshift([opts,cmd])
- if @trace_opts == nil
- TkVar_CB_TBL[@id] = self
- @trace_opts = opts
- Tk.tk_call('trace', 'variable', @id, @trace_opts, 'rb_var')
- else
- newopts = @trace_opts.dup
- opts.each_byte{|c| newopts += c.chr unless newopts.index(c)}
- if newopts != @trace_opts
- Tk.tk_call('trace', 'vdelete', @id, @trace_opts, 'rb_var')
- @trace_opts.replace(newopts)
- Tk.tk_call('trace', 'variable', @id, @trace_opts, 'rb_var')
- end
- end
- end
-
- def trace_vinfo
- return [] unless @trace_var
- @trace_var.dup
- end
- def trace_vinfo_for_element(elem)
- return [] unless @trace_elem
- return [] unless @trace_elem[elem]
- @trace_elem[elem].dup
- end
-
- def trace_vdelete(opts,cmd)
- return unless @trace_var.kind_of? Array
- opts = ['r','w','u'].find_all{|c| opts.index(c)}.join('')
- idx = -1
- newopts = ''
- @trace_var.each_with_index{|e,i|
- if idx < 0 && e[0] == opts && e[1] == cmd
- idx = i
- next
- end
- e[0].each_byte{|c| newopts += c.chr unless newopts.index(c)}
- }
- if idx >= 0
- @trace_var.delete_at(idx)
- else
- return
- end
-
- @trace_elem.each{|elem|
- @trace_elem[elem].each{|e|
- e[0].each_byte{|c| newopts += c.chr unless newopts.index(c)}
- }
- }
-
- newopts = ['r','w','u'].find_all{|c| newopts.index(c)}.join('')
- if newopts != @trace_opts
- Tk.tk_call('trace', 'vdelete', @id, @trace_opts, 'rb_var')
- @trace_opts.replace(newopts)
- if @trace_opts != ''
- Tk.tk_call('trace', 'variable', @id, @trace_opts, 'rb_var')
- end
- end
- end
-
- def trace_vdelete_for_element(elem,opts,cmd)
- return unless @trace_elem.kind_of? Hash
- return unless @trace_elem[elem].kind_of? Array
- opts = ['r','w','u'].find_all{|c| opts.index(c)}.join('')
- idx = -1
- @trace_elem[elem].each_with_index{|e,i|
- if idx < 0 && e[0] == opts && e[1] == cmd
- idx = i
- next
- end
- }
- if idx >= 0
- @trace_elem[elem].delete_at(idx)
- else
- return
- end
-
- newopts = ''
- @trace_var.each{|e|
- e[0].each_byte{|c| newopts += c.chr unless newopts.index(c)}
- }
- @trace_elem.each{|elem|
- @trace_elem[elem].each{|e|
- e[0].each_byte{|c| newopts += c.chr unless newopts.index(c)}
- }
- }
-
- newopts = ['r','w','u'].find_all{|c| newopts.index(c)}.join('')
- if newopts != @trace_opts
- Tk.tk_call('trace', 'vdelete', @id, @trace_opts, 'rb_var')
- @trace_opts.replace(newopts)
- if @trace_opts != ''
- Tk.tk_call('trace', 'variable', @id, @trace_opts, 'rb_var')
- end
- end
- end
-end
-
-class TkVarAccess<TkVariable
- def self.new(name, *args)
- return TkVar_ID_TBL[name] if TkVar_ID_TBL[name]
- super(name, *args)
- end
-
- def initialize(varname, val=nil)
- @id = varname
- TkVar_ID_TBL[@id] = self
- if val
- s = '"' + _get_eval_string(val).gsub(/[\[\]$"]/, '\\\\\&') + '"' #"
- INTERP._eval(Kernel.format('global %s; set %s %s', @id, @id, s))
- end
- end
-end
-
-module Tk
- begin
- auto_path = INTERP._invoke('set', 'auto_path')
- rescue
- begin
- auto_path = INTERP._invoke('set', 'env(TCLLIBPATH)')
- rescue
- auto_path = Tk::LIBRARY
- end
- end
-
- AUTO_PATH = TkVarAccess.new('auto_path', auto_path)
-
-=begin
- AUTO_OLDPATH = tk_split_simplelist(INTERP._invoke('set', 'auto_oldpath'))
- AUTO_OLDPATH.each{|s| s.freeze}
- AUTO_OLDPATH.freeze
-=end
-
- TCL_PACKAGE_PATH = TkVarAccess.new('tcl_pkgPath')
- PACKAGE_PATH = TCL_PACKAGE_PATH
-
- TCL_LIBRARY_PATH = TkVarAccess.new('tcl_libPath')
- LIBRARY_PATH = TCL_LIBRARY_PATH
-
- TCL_PRECISION = TkVarAccess.new('tcl_precision')
-end
-
-module TkSelection
- include Tk
- extend Tk
-
- TkCommandNames = ['selection'.freeze].freeze
-
- def self.clear(sel=nil)
- if sel
- tk_call 'selection', 'clear', '-selection', sel
- else
- tk_call 'selection', 'clear'
- end
- end
- def self.clear_on_display(win, sel=nil)
- if sel
- tk_call 'selection', 'clear', '-displayof', win, '-selection', sel
- else
- tk_call 'selection', 'clear', '-displayof', win
- end
- end
- def clear(sel=nil)
- TkSelection.clear_on_display(self, sel)
- self
- end
-
- def self.get(keys=nil)
- tk_call 'selection', 'get', *hash_kv(keys)
- end
- def self.get_on_display(win, keys=nil)
- tk_call 'selection', 'get', '-displayof', win, *hash_kv(keys)
- end
- def get(keys=nil)
- TkSelection.get_on_display(self, sel)
- end
-
- def self.handle(win, func=Proc.new, keys=nil, &b)
- if func.kind_of?(Hash) && keys == nil
- keys = func
- func = Proc.new(&b)
- end
- args = ['selection', 'handle']
- args += hash_kv(keys)
- args += [win, func]
- tk_call(*args)
- end
- def handle(func=Proc.new, keys=nil, &b)
- TkSelection.handle(self, func, keys, &b)
- end
-
- def self.get_owner(sel=nil)
- if sel
- window(tk_call('selection', 'own', '-selection', sel))
- else
- window(tk_call('selection', 'own'))
- end
- end
- def self.get_owner_on_display(win, sel=nil)
- if sel
- window(tk_call('selection', 'own', '-displayof', win, '-selection', sel))
- else
- window(tk_call('selection', 'own', '-displayof', win))
- end
- end
- def get_owner(sel=nil)
- TkSelection.get_owner_on_display(self, sel)
- self
- end
-
- def self.set_owner(win, keys=nil)
- tk_call('selection', 'own', *(hash_kv(keys) << win))
- end
- def set_owner(keys=nil)
- TkSelection.set_owner(self, keys)
- self
- end
-end
-
-module TkKinput
- include Tk
- extend Tk
-
- TkCommandNames = [
- 'kinput_start'.freeze,
- 'kinput_send_spot'.freeze,
- 'kanjiInput'.freeze
- ].freeze
-
- def TkKinput.start(window, style=None)
- tk_call 'kinput_start', window.path, style
- end
- def kinput_start(style=None)
- TkKinput.start(self, style)
- end
-
- def TkKinput.send_spot(window)
- tk_call 'kinput_send_spot', window.path
- end
- def kinput_send_spot
- TkKinput.send_spot(self)
- end
-
- def TkKinput.input_start(window, keys=nil)
- tk_call 'kanjiInput', 'start', window.path, *hash_kv(keys)
- end
- def kanji_input_start(keys=nil)
- TkKinput.input_start(self, keys)
- end
-
- def TkKinput.attribute_config(window, slot, value=None)
- if slot.kind_of? Hash
- tk_call 'kanjiInput', 'attribute', window.path, *hash_kv(slot)
- else
- tk_call 'kanjiInput', 'attribute', window.path, "-#{slot}", value
- end
- end
- def kinput_attribute_config(slot, value=None)
- TkKinput.attribute_config(self, slot, value)
- end
-
- def TkKinput.attribute_info(window, slot=nil)
- if slot
- conf = tk_split_list(tk_call('kanjiInput', 'attribute',
- window.path, "-#{slot}"))
- conf[0] = conf[0][1..-1]
- conf
- else
- tk_split_list(tk_call('kanjiInput', 'attribute',
- window.path)).collect{|conf|
- conf[0] = conf[0][1..-1]
- conf
- }
- end
- end
- def kinput_attribute_info(slot=nil)
- TkKinput.attribute_info(self, slot)
- end
-
- def TkKinput.input_end(window)
- tk_call 'kanjiInput', 'end', window.path
- end
- def kanji_input_end
- TkKinput.input_end(self)
- end
-end
-
-module TkXIM
- include Tk
- extend Tk
-
- TkCommandNames = ['imconfigure'.freeze].freeze
-
- def TkXIM.useinputmethods(window=nil, value=nil)
- if window
- if value
- tk_call 'tk', 'useinputmethods', '-displayof', window.path, value
- else
- tk_call 'tk', 'useinputmethods', '-displayof', window.path
- end
- else
- if value
- tk_call 'tk', 'useinputmethods', value
- else
- tk_call 'tk', 'useinputmethods'
- end
- end
- end
-
- def TkXIM.caret(window, keys=nil)
- if keys
- tk_call('tk', 'caret', window, *hash_kv(keys))
- self
- else
- lst = tk_split_list(tk_call('tk', 'caret', window))
- info = {}
- while key = lst.shift
- info[key[1..-1]] = lst.shift
- end
- info
- end
- end
-
- def TkXIM.configure(window, slot, value=None)
- begin
- if /^8\.*/ === Tk::TK_VERSION && JAPANIZED_TK
- if slot.kind_of? Hash
- tk_call 'imconfigure', window.path, *hash_kv(slot)
- else
- tk_call 'imconfigure', window.path, "-#{slot}", value
- end
- end
- rescue
- end
- end
-
- def TkXIM.configinfo(window, slot=nil)
- begin
- if /^8\.*/ === Tk::TK_VERSION && JAPANIZED_TK
- if slot
- conf = tk_split_list(tk_call('imconfigure', window.path, "-#{slot}"))
- conf[0] = conf[0][1..-1]
- conf
- else
- tk_split_list(tk_call('imconfigure', window.path)).collect{|conf|
- conf[0] = conf[0][1..-1]
- conf
- }
- end
- else
- []
- end
- rescue
- []
- end
- end
-
- def useinputmethods(value=nil)
- TkXIM.useinputmethods(self, value)
- end
-
- def caret(keys=nil)
- TkXIM.caret(self, keys=nil)
- end
-
- def imconfigure(slot, value=None)
- TkXIM.configinfo(self, slot, value)
- end
-
- def imconfiginfo(slot=nil)
- TkXIM.configinfo(self, slot)
- end
-end
-
-module TkWinfo
- include Tk
- extend Tk
-
- TkCommandNames = ['winfo'.freeze].freeze
-
- def TkWinfo.atom(name, win=nil)
- if win
- number(tk_call('winfo', 'atom', '-displayof', win, name))
- else
- number(tk_call('winfo', 'atom', name))
- end
- end
- def winfo_atom(name)
- TkWinfo.atom(name, self)
- end
-
- def TkWinfo.atomname(id, win=nil)
- if win
- tk_call('winfo', 'atomname', '-displayof', win, id)
- else
- tk_call('winfo', 'atomname', id)
- end
- end
- def winfo_atomname(id)
- TkWinfo.atomname(id, self)
- end
-
- def TkWinfo.cells(window)
- number(tk_call('winfo', 'cells', window.path))
- end
- def winfo_cells
- TkWinfo.cells self
- end
-
- def TkWinfo.children(window)
- c = tk_call('winfo', 'children', window.path)
- list(c)
- end
- def winfo_children
- TkWinfo.children self
- end
-
- def TkWinfo.classname(window)
- tk_call 'winfo', 'class', window.path
- end
- def winfo_classname
- TkWinfo.classname self
- end
- alias winfo_class winfo_classname
-
- def TkWinfo.colormapfull(window)
- bool(tk_call('winfo', 'colormapfull', window.path))
- end
- def winfo_colormapfull
- TkWinfo.colormapfull self
- end
-
- def TkWinfo.containing(rootX, rootY, win=nil)
- if win
- window(tk_call('winfo', 'containing', '-displayof', win, rootX, rootY))
- else
- window(tk_call('winfo', 'containing', rootX, rootY))
- end
- end
- def winfo_containing(x, y)
- TkWinfo.containing(x, y, self)
- end
-
- def TkWinfo.depth(window)
- number(tk_call('winfo', 'depth', window.path))
- end
- def winfo_depth
- TkWinfo.depth self
- end
-
- def TkWinfo.exist?(window)
- bool(tk_call('winfo', 'exists', window.path))
- end
- def winfo_exist?
- TkWinfo.exist? self
- end
-
- def TkWinfo.fpixels(window, dist)
- number(tk_call('winfo', 'fpixels', window.path, dist))
- end
- def winfo_fpixels(dist)
- TkWinfo.fpixels self, dist
- end
-
- def TkWinfo.geometry(window)
- tk_call('winfo', 'geometry', window.path)
- end
- def winfo_geometry
- TkWinfo.geometry self
- end
-
- def TkWinfo.height(window)
- number(tk_call('winfo', 'height', window.path))
- end
- def winfo_height
- TkWinfo.height self
- end
-
- def TkWinfo.id(window)
- tk_call('winfo', 'id', window.path)
- end
- def winfo_id
- TkWinfo.id self
- end
-
- def TkWinfo.interps(window=nil)
- if window
- tk_split_simplelist(tk_call('winfo', 'interps',
- '-displayof', window.path))
- else
- tk_split_simplelist(tk_call('winfo', 'interps'))
- end
- end
- def winfo_interps
- TkWinfo.interps self
- end
-
- def TkWinfo.mapped?(window)
- bool(tk_call('winfo', 'ismapped', window.path))
- end
- def winfo_mapped?
- TkWinfo.mapped? self
- end
-
- def TkWinfo.manager(window)
- tk_call('winfo', 'manager', window.path)
- end
- def winfo_manager
- TkWinfo.manager self
- end
-
- def TkWinfo.appname(window)
- tk_call('winfo', 'name', window.path)
- end
- def winfo_appname
- TkWinfo.appname self
- end
-
- def TkWinfo.parent(window)
- window(tk_call('winfo', 'parent', window.path))
- end
- def winfo_parent
- TkWinfo.parent self
- end
-
- def TkWinfo.widget(id, win=nil)
- if win
- window(tk_call('winfo', 'pathname', '-displayof', win, id))
- else
- window(tk_call('winfo', 'pathname', id))
- end
- end
- def winfo_widget(id)
- TkWinfo.widget id, self
- end
-
- def TkWinfo.pixels(window, dist)
- number(tk_call('winfo', 'pixels', window.path, dist))
- end
- def winfo_pixels(dist)
- TkWinfo.pixels self, dist
- end
-
- def TkWinfo.reqheight(window)
- number(tk_call('winfo', 'reqheight', window.path))
- end
- def winfo_reqheight
- TkWinfo.reqheight self
- end
-
- def TkWinfo.reqwidth(window)
- number(tk_call('winfo', 'reqwidth', window.path))
- end
- def winfo_reqwidth
- TkWinfo.reqwidth self
- end
-
- def TkWinfo.rgb(window, color)
- list(tk_call('winfo', 'rgb', window.path, color))
- end
- def winfo_rgb(color)
- TkWinfo.rgb self, color
- end
-
- def TkWinfo.rootx(window)
- number(tk_call('winfo', 'rootx', window.path))
- end
- def winfo_rootx
- TkWinfo.rootx self
- end
-
- def TkWinfo.rooty(window)
- number(tk_call('winfo', 'rooty', window.path))
- end
- def winfo_rooty
- TkWinfo.rooty self
- end
-
- def TkWinfo.screen(window)
- tk_call 'winfo', 'screen', window.path
- end
- def winfo_screen
- TkWinfo.screen self
- end
-
- def TkWinfo.screencells(window)
- number(tk_call('winfo', 'screencells', window.path))
- end
- def winfo_screencells
- TkWinfo.screencells self
- end
-
- def TkWinfo.screendepth(window)
- number(tk_call('winfo', 'screendepth', window.path))
- end
- def winfo_screendepth
- TkWinfo.screendepth self
- end
-
- def TkWinfo.screenheight (window)
- number(tk_call('winfo', 'screenheight', window.path))
- end
- def winfo_screenheight
- TkWinfo.screenheight self
- end
-
- def TkWinfo.screenmmheight(window)
- number(tk_call('winfo', 'screenmmheight', window.path))
- end
- def winfo_screenmmheight
- TkWinfo.screenmmheight self
- end
-
- def TkWinfo.screenmmwidth(window)
- number(tk_call('winfo', 'screenmmwidth', window.path))
- end
- def winfo_screenmmwidth
- TkWinfo.screenmmwidth self
- end
-
- def TkWinfo.screenvisual(window)
- tk_call('winfo', 'screenvisual', window.path)
- end
- def winfo_screenvisual
- TkWinfo.screenvisual self
- end
-
- def TkWinfo.screenwidth(window)
- number(tk_call('winfo', 'screenwidth', window.path))
- end
- def winfo_screenwidth
- TkWinfo.screenwidth self
- end
-
- def TkWinfo.server(window)
- tk_call 'winfo', 'server', window.path
- end
- def winfo_server
- TkWinfo.server self
- end
-
- def TkWinfo.toplevel(window)
- window(tk_call('winfo', 'toplevel', window.path))
- end
- def winfo_toplevel
- TkWinfo.toplevel self
- end
-
- def TkWinfo.visual(window)
- tk_call('winfo', 'visual', window.path)
- end
- def winfo_visual
- TkWinfo.visual self
- end
-
- def TkWinfo.visualid(window)
- tk_call('winfo', 'visualid', window.path)
- end
- def winfo_visualid
- TkWinfo.visualid self
- end
-
- def TkWinfo.visualsavailable(window, includeids=false)
- if includeids
- list(tk_call('winfo', 'visualsavailable', window.path, "includeids"))
- else
- list(tk_call('winfo', 'visualsavailable', window.path))
- end
- end
- def winfo_visualsavailable(includeids=false)
- TkWinfo.visualsavailable self, includeids
- end
-
- def TkWinfo.vrootheight(window)
- number(tk_call('winfo', 'vrootheight', window.path))
- end
- def winfo_vrootheight
- TkWinfo.vrootheight self
- end
-
- def TkWinfo.vrootwidth(window)
- number(tk_call('winfo', 'vrootwidth', window.path))
- end
- def winfo_vrootwidth
- TkWinfo.vrootwidth self
- end
-
- def TkWinfo.vrootx(window)
- number(tk_call('winfo', 'vrootx', window.path))
- end
- def winfo_vrootx
- TkWinfo.vrootx self
- end
-
- def TkWinfo.vrooty(window)
- number(tk_call('winfo', 'vrooty', window.path))
- end
- def winfo_vrooty
- TkWinfo.vrooty self
- end
-
- def TkWinfo.width(window)
- number(tk_call('winfo', 'width', window.path))
- end
- def winfo_width
- TkWinfo.width self
- end
-
- def TkWinfo.x(window)
- number(tk_call('winfo', 'x', window.path))
- end
- def winfo_x
- TkWinfo.x self
- end
-
- def TkWinfo.y(window)
- number(tk_call('winfo', 'y', window.path))
- end
- def winfo_y
- TkWinfo.y self
- end
-
- def TkWinfo.viewable(window)
- bool(tk_call('winfo', 'viewable', window.path))
- end
- def winfo_viewable
- TkWinfo.viewable self
- end
-
- def TkWinfo.pointerx(window)
- number(tk_call('winfo', 'pointerx', window.path))
- end
- def winfo_pointerx
- TkWinfo.pointerx self
- end
-
- def TkWinfo.pointery(window)
- number(tk_call('winfo', 'pointery', window.path))
- end
- def winfo_pointery
- TkWinfo.pointery self
- end
-
- def TkWinfo.pointerxy(window)
- list(tk_call('winfo', 'pointerxy', window.path))
- end
- def winfo_pointerxy
- TkWinfo.pointerxy self
- end
-end
-
-module TkPack
- include Tk
- extend Tk
-
- TkCommandNames = ['pack'.freeze].freeze
-
- def configure(win, *args)
- if args[-1].kind_of?(Hash)
- keys = args.pop
- end
- wins = [win.epath]
- for i in args
- wins.push i.epath
- end
- tk_call "pack", 'configure', *(wins+hash_kv(keys))
- end
-
- def forget(*args)
- tk_call 'pack', 'forget' *args
- end
-
- def info(slave)
- ilist = list(tk_call('pack', 'info', slave.epath))
- info = {}
- while key = ilist.shift
- info[key[1..-1]] = ilist.shift
- end
- return info
- end
-
- def propagate(master, bool=None)
- if bool == None
- bool(tk_call('pack', 'propagate', master.epath))
- else
- tk_call('pack', 'propagate', master.epath, bool)
- end
- end
-
- def slaves(master)
- list(tk_call('pack', 'slaves', master.epath))
- end
-
- module_function :configure, :forget, :info, :propagate, :slaves
-end
-
-module TkGrid
- include Tk
- extend Tk
-
- TkCommandNames = ['grid'.freeze].freeze
-
- def bbox(*args)
- list(tk_call('grid', 'bbox', *args))
- end
-
- def configure(widget, *args)
- if args[-1].kind_of?(Hash)
- keys = args.pop
- end
- wins = []
- args.unshift(widget)
- for i in args
- case i
- when '-', 'x', '^' # RELATIVE PLACEMENT
- wins.push(i)
- else
- wins.push(i.epath)
- end
- end
- tk_call "grid", 'configure', *(wins+hash_kv(keys))
- end
-
- def columnconfigure(master, index, args)
- tk_call "grid", 'columnconfigure', master, index, *hash_kv(args)
- end
-
- def rowconfigure(master, index, args)
- tk_call "grid", 'rowconfigure', master, index, *hash_kv(args)
- end
-
- def columnconfiginfo(master, index, slot=nil)
- if slot
- tk_call('grid', 'columnconfigure', master, index, "-#{slot}").to_i
- else
- ilist = list(tk_call('grid', 'columnconfigure', master, index))
- info = {}
- while key = ilist.shift
- info[key[1..-1]] = ilist.shift
- end
- info
- end
- end
-
- def rowconfiginfo(master, index, slot=nil)
- if slot
- tk_call('grid', 'rowconfigure', master, index, "-#{slot}").to_i
- else
- ilist = list(tk_call('grid', 'rowconfigure', master, index))
- info = {}
- while key = ilist.shift
- info[key[1..-1]] = ilist.shift
- end
- info
- end
- end
-
- def add(widget, *args)
- configure(widget, *args)
- end
-
- def forget(*args)
- tk_call 'grid', 'forget', *args
- end
-
- def info(slave)
- list(tk_call('grid', 'info', slave))
- end
-
- def location(master, x, y)
- list(tk_call('grid', 'location', master, x, y))
- end
-
- def propagate(master, bool=None)
- if bool == None
- bool(tk_call('grid', 'propagate', master.epath))
- else
- tk_call('grid', 'propagate', master.epath, bool)
- end
- end
-
- def remove(*args)
- tk_call 'grid', 'remove', *args
- end
-
- def size(master)
- tk_call 'grid', 'size', master
- end
-
- def slaves(master, args)
- list(tk_call('grid', 'slaves', master, *hash_kv(args)))
- end
-
- module_function :bbox, :forget, :propagate, :info
- module_function :remove, :size, :slaves, :location
- module_function :configure, :columnconfigure, :rowconfigure
- module_function :columnconfiginfo, :rowconfiginfo
-end
-
-module TkPlace
- include Tk
- extend Tk
-
- TkCommandNames = ['place'.freeze].freeze
-
- def configure(win, slot, value=None)
- if slot.kind_of? Hash
- tk_call 'place', 'configure', win.epath, *hash_kv(slot)
- else
- tk_call 'place', 'configure', win.epath, "-#{slot}", value
- end
- end
-
- def configinfo(win, slot = nil)
- # for >= Tk8.4a2 ?
- if slot
- conf = tk_split_list(tk_call('place', 'configure',
- win.epath, "-#{slot}") )
- conf[0] = conf[0][1..-1]
- conf
- else
- tk_split_simplelist(tk_call('place', 'configure',
- win.epath)).collect{|conflist|
- conf = tk_split_simplelist(conflist)
- conf[0] = conf[0][1..-1]
- conf
- }
- end
- end
-
- def forget(win)
- tk_call 'place', 'forget', win
- end
-
- def info(win)
- ilist = list(tk_call('place', 'info', win.epath))
- info = {}
- while key = ilist.shift
- info[key[1..-1]] = ilist.shift
- end
- return info
- end
-
- def slaves(master)
- list(tk_call('place', 'slaves', master.epath))
- end
-
- module_function :configure, :configinfo, :forget, :info, :slaves
-end
-
-module TkOptionDB
- include Tk
- extend Tk
-
- TkCommandNames = ['option'.freeze].freeze
-
- module Priority
- WidgetDefault = 20
- StartupFile = 40
- UserDefault = 60
- Interactive = 80
- end
-
- def add(pat, value, pri=None)
- if $SAFE >= 4
- fail SecurityError, "can't call 'TkOptionDB.add' at $SAFE >= 4"
- end
- tk_call 'option', 'add', pat, value, pri
- end
- def clear
- if $SAFE >= 4
- fail SecurityError, "can't call 'TkOptionDB.crear' at $SAFE >= 4"
- end
- tk_call 'option', 'clear'
- end
- def get(win, name, klass)
- tk_call('option', 'get', win ,name, klass)
- end
- def readfile(file, pri=None)
- tk_call 'option', 'readfile', file, pri
- end
- module_function :add, :clear, :get, :readfile
-
- def read_entries(file, f_enc=nil)
- if TkCore::INTERP.safe?
- fail SecurityError,
- "can't call 'TkOptionDB.read_entries' on a safe interpreter"
- end
-
- i_enc = Tk.encoding()
-
- unless f_enc
- f_enc = i_enc
- end
-
- ent = []
- cline = ''
- open(file, 'r') {|f|
- while line = f.gets
- cline += line.chomp!
- case cline
- when /\\$/ # continue
- cline.chop!
- next
- when /^!/ # coment
- cline = ''
- next
- when /^([^:]+):\s(.*)$/
- pat = $1
- val = $2
- p "ResourceDB: #{[pat, val].inspect}" if $DEBUG
- pat = TkCore::INTERP._toUTF8(pat, f_enc)
- pat = TkCore::INTERP._fromUTF8(pat, i_enc)
- val = TkCore::INTERP._toUTF8(val, f_enc)
- val = TkCore::INTERP._fromUTF8(val, i_enc)
- ent << [pat, val]
- cline = ''
- else # unknown --> ignore
- cline = ''
- next
- end
- end
- }
- ent
- end
- module_function :read_entries
-
- def read_with_encoding(file, f_enc=nil, pri=None)
- # try to read the file as an OptionDB file
- readfile(file, pri).each{|pat, val|
- add(pat, val, pri)
- }
-
-=begin
- i_enc = Tk.encoding()
-
- unless f_enc
- f_enc = i_enc
- end
-
- cline = ''
- open(file, 'r') {|f|
- while line = f.gets
- cline += line.chomp!
- case cline
- when /\\$/ # continue
- cline.chop!
- next
- when /^!/ # coment
- cline = ''
- next
- when /^([^:]+):\s(.*)$/
- pat = $1
- val = $2
- p "ResourceDB: #{[pat, val].inspect}" if $DEBUG
- pat = TkCore::INTERP._toUTF8(pat, f_enc)
- pat = TkCore::INTERP._fromUTF8(pat, i_enc)
- val = TkCore::INTERP._toUTF8(val, f_enc)
- val = TkCore::INTERP._fromUTF8(val, i_enc)
- add(pat, val, pri)
- cline = ''
- else # unknown --> ignore
- cline = ''
- next
- end
- end
- }
-=end
- end
- module_function :read_with_encoding
-
- # support procs on the resource database
- @@resource_proc_class = Class.new
- class << @@resource_proc_class
- private :new
-
- CARRIER = '.'.freeze
- METHOD_TBL = TkCore::INTERP.create_table
- ADD_METHOD = false
- SAFE_MODE = 4
-
- def __closed_block_check__(str)
- depth = 0
- str.scan(/[{}]/){|x|
- if x == "{"
- depth += 1
- elsif x == "}"
- depth -= 1
- end
- if depth <= 0 && !($' =~ /\A\s*\Z/)
- fail RuntimeError, "bad string for procedure : #{str.inspect}"
- end
- }
- str
- end
-
- def __check_proc_string__(str)
- # If you want to check the proc_string, do it in this method.
- # Please define this in the block given to 'new_proc_class' method.
- str
- end
-
- def method_missing(id, *args)
- res_proc = self::METHOD_TBL[id]
- unless res_proc.kind_of? Proc
- if id == :new || !(self::METHOD_TBL.has_key?(id) || self::ADD_METHOD)
- raise NoMethodError,
- "not support resource-proc '#{id.id2name}' for #{self.name}"
- end
- proc_str = TkOptionDB.get(self::CARRIER, id.id2name, '').strip
- proc_str = '{' + proc_str + '}' unless /\A\{.*\}\Z/ =~ proc_str
- proc_str = __closed_block_check__(proc_str)
- proc_str = __check_proc_string__(proc_str)
- res_proc = eval('Proc.new' + proc_str)
- self::METHOD_TBL[id] = res_proc
- end
- proc{
- $SAFE = self::SAFE_MODE
- res_proc.call(*args)
- }.call
- end
-
- private :__closed_block_check__, :__check_proc_string__, :method_missing
- end
- @@resource_proc_class.freeze
-
- def __create_new_class(klass, func, safe = 4, add = false, parent = nil)
- klass = klass.to_s if klass.kind_of? Symbol
- unless (?A..?Z) === klass[0]
- fail ArgumentError, "bad string '#{klass}' for class name"
- end
- unless func.kind_of? Array
- fail ArgumentError, "method-list must be Array"
- end
- func_str = func.join(' ')
- if parent == nil
- install_win(parent)
- elsif parent <= @@resource_proc_class
- install_win(parent::CARRIER)
- else
- fail ArgumentError, "parent must be Resource-Proc class"
- end
- carrier = Tk.tk_call('frame', @path, '-class', klass)
-
- body = <<-"EOD"
- class #{klass} < TkOptionDB.module_eval('@@resource_proc_class')
- CARRIER = '#{carrier}'.freeze
- METHOD_TBL = TkCore::INTERP.create_table
- ADD_METHOD = #{add}
- SAFE_MODE = #{safe}
- %w(#{func_str}).each{|f| METHOD_TBL[f.intern] = nil }
- end
- EOD
-
- if parent.kind_of?(Class) && parent <= @@resource_proc_class
- parent.class_eval(body)
- eval(parent.name + '::' + klass)
- else
- eval(body)
- eval('TkOptionDB::' + klass)
- end
- end
- module_function :__create_new_class
- private_class_method :__create_new_class
-
- def __remove_methods_of_proc_class(klass)
- # for security, make these methods invalid
- class << klass
- attr_reader :class_eval, :name, :superclass,
- :ancestors, :const_defined?, :const_get, :const_set,
- :constants, :included_modules, :instance_methods,
- :method_defined?, :module_eval, :private_instance_methods,
- :protected_instance_methods, :public_instance_methods,
- :remove_const, :remove_method, :undef_method,
- :to_s, :inspect, :display, :method, :methods,
- :instance_eval, :instance_variables, :kind_of?, :is_a?,
- :private_methods, :protected_methods, :public_methods
- end
- end
- module_function :__remove_methods_of_proc_class
- private_class_method :__remove_methods_of_proc_class
-
- RAND_BASE_CNT = [0]
- RAND_BASE_HEAD = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
- RAND_BASE_CHAR = RAND_BASE_HEAD + 'abcdefghijklmnopqrstuvwxyz0123456789_'
- def __get_random_basename
- name = '%s%03d' % [RAND_BASE_HEAD[rand(RAND_BASE_HEAD.size),1],
- RAND_BASE_CNT[0]]
- len = RAND_BASE_CHAR.size
- (6+rand(10)).times{
- name << RAND_BASE_CHAR[rand(len),1]
- }
- RAND_BASE_CNT[0] = RAND_BASE_CNT[0] + 1
- name
- end
- module_function :__get_random_basename
- private_class_method :__get_random_basename
-
- # define new proc class :
- # If you want to modify the new class or create a new subclass,
- # you must do such operation in the block parameter.
- # Because the created class is flozen after evaluating the block.
- def new_proc_class(klass, func, safe = 4, add = false, parent = nil, &b)
- new_klass = __create_new_class(klass, func, safe, add, parent)
- new_klass.class_eval(&b) if block_given?
- __remove_methods_of_proc_class(new_klass)
- new_klass.freeze
- new_klass
- end
- module_function :new_proc_class
-
- def eval_under_random_base(parent = nil, &b)
- new_klass = __create_new_class(__get_random_basename(),
- [], 4, false, parent)
- ret = new_klass.class_eval(&b) if block_given?
- __remove_methods_of_proc_class(new_klass)
- new_klass.freeze
- ret
- end
- module_function :eval_under_random_base
-
- def new_proc_class_random(klass, func, safe = 4, add = false, &b)
- eval_under_random_base(){
- TkOption.new_proc_class(klass, func, safe, add, self, &b)
- }
- end
- module_function :new_proc_class_random
-end
-TkOption = TkOptionDB
-TkResourceDB = TkOptionDB
-
-module TkTreatFont
- def font_configinfo(name = nil)
- ret = TkFont.used_on(self.path)
- if ret == nil
-=begin
- if name
- ret = name
- else
- ret = TkFont.init_widget_font(self.path, self.path, 'configure')
- end
-=end
- ret = TkFont.init_widget_font(self.path, self.path, 'configure')
- end
- ret
- end
- alias fontobj font_configinfo
-
- def font_configure(slot)
- slot = _symbolkey2str(slot)
-
- if slot.key?('font')
- fnt = slot.delete('font')
- if fnt.kind_of? TkFont
- return fnt.call_font_configure(self.path, self.path,'configure',slot)
- else
- if fnt
- if (slot.key?('kanjifont') ||
- slot.key?('latinfont') ||
- slot.key?('asciifont'))
- fnt = TkFont.new(fnt)
-
- lfnt = slot.delete('latinfont')
- lfnt = slot.delete('asciifont') if slot.key?('asciifont')
- kfnt = slot.delete('kanjifont')
-
- fnt.latin_replace(lfnt) if lfnt
- fnt.kanji_replace(kfnt) if kfnt
- else
- slot['font'] = fnt
- tk_call(self.path, 'configure', *hash_kv(slot))
- end
- end
- return self
- end
- end
-
- lfnt = slot.delete('latinfont')
- lfnt = slot.delete('asciifont') if slot.key?('asciifont')
- kfnt = slot.delete('kanjifont')
-
- if lfnt && kfnt
- return TkFont.new(lfnt, kfnt).call_font_configure(self.path, self.path,
- 'configure', slot)
- end
-
- latinfont_configure(lfnt) if lfnt
- kanjifont_configure(kfnt) if kfnt
-
- tk_call(self.path, 'configure', *hash_kv(slot)) if slot != {}
- self
- end
-
- def latinfont_configure(ltn, keys=nil)
- if (fobj = TkFont.used_on(self.path))
- fobj = TkFont.new(fobj) # create a new TkFont object
- elsif Tk::JAPANIZED_TK
- fobj = fontobj # create a new TkFont object
- else
- tk_call(self.path, 'configure', '-font', ltn)
- return self
- end
-
- if fobj.kind_of?(TkFont)
- 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
- end
-
- return fobj.call_font_configure(self.path, self.path, 'configure', {})
- end
- alias asciifont_configure latinfont_configure
-
- def kanjifont_configure(knj, keys=nil)
- if (fobj = TkFont.used_on(self.path))
- fobj = TkFont.new(fobj) # create a new TkFont object
- elsif Tk::JAPANIZED_TK
- fobj = fontobj # create a new TkFont object
- else
- tk_call(self.path, 'configure', '-font', knj)
- return self
- end
-
- if fobj.kind_of?(TkFont)
- 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
- end
-
- return fobj.call_font_configure(self.path, self.path, 'configure', {})
- end
-
- def font_copy(window, tag=nil)
- if tag
- fnt = window.tagfontobj(tag).dup
- else
- fnt = window.fontobj.dup
- end
- fnt.call_font_configure(self.path, self.path, 'configure', {})
- self
- end
-
- def latinfont_copy(window, tag=nil)
- fontobj.dup.call_font_configure(self.path, self.path, 'configure', {})
- if tag
- fontobj.latin_replace(window.tagfontobj(tag).latin_font_id)
- else
- fontobj.latin_replace(window.fontobj.latin_font_id)
- end
- self
- end
- alias asciifont_copy latinfont_copy
-
- def kanjifont_copy(window, tag=nil)
- fontobj.dup.call_font_configure(self.path, self.path, 'configure', {})
- if tag
- fontobj.kanji_replace(window.tagfontobj(tag).kanji_font_id)
- else
- fontobj.kanji_replace(window.fontobj.kanji_font_id)
- end
- self
- end
-end
-
-module TkTreatItemFont
- def __conf_cmd(idx)
- raise NotImplementedError, "need to define `__conf_cmd'"
- end
- def __item_pathname(tagOrId)
- raise NotImplementedError, "need to define `__item_pathname'"
- end
- private :__conf_cmd, :__item_pathname
-
- def tagfont_configinfo(tagOrId, name = nil)
- pathname = __item_pathname(tagOrId)
- ret = TkFont.used_on(pathname)
- if ret == nil
-=begin
- if name
- ret = name
- else
- ret = TkFont.init_widget_font(pathname, self.path,
- __conf_cmd(0), __conf_cmd(1), tagOrId)
- end
-=end
- ret = TkFont.init_widget_font(pathname, self.path,
- __conf_cmd(0), __conf_cmd(1), tagOrId)
- end
- ret
- end
- alias tagfontobj tagfont_configinfo
-
- def tagfont_configure(tagOrId, slot)
- pathname = __item_pathname(tagOrId)
- slot = _symbolkey2str(slot)
-
- if slot.key?('font')
- fnt = slot.delete('font')
- if fnt.kind_of? TkFont
- return fnt.call_font_configure(pathname, self.path,
- __conf_cmd(0), __conf_cmd(1),
- tagOrId, slot)
- else
- if fnt
- if (slot.key?('kanjifont') ||
- slot.key?('latinfont') ||
- slot.key?('asciifont'))
- fnt = TkFont.new(fnt)
-
- lfnt = slot.delete('latinfont')
- lfnt = slot.delete('asciifont') if slot.key?('asciifont')
- kfnt = slot.delete('kanjifont')
-
- fnt.latin_replace(lfnt) if lfnt
- fnt.kanji_replace(kfnt) if kfnt
- end
-
- slot['font'] = fnt
- tk_call(self.path, __conf_cmd(0), __conf_cmd(1),
- tagOrId, *hash_kv(slot))
- end
- return self
- end
- end
-
- lfnt = slot.delete('latinfont')
- lfnt = slot.delete('asciifont') if slot.key?('asciifont')
- kfnt = slot.delete('kanjifont')
-
- if lfnt && kfnt
- return TkFont.new(lfnt, kfnt).call_font_configure(pathname, self.path,
- __conf_cmd(0),
- __conf_cmd(1),
- tagOrId, slot)
- end
-
- latintagfont_configure(tagOrId, lfnt) if lfnt
- kanjitagfont_configure(tagOrId, kfnt) if kfnt
-
- tk_call(self.path, __conf_cmd(0), __conf_cmd(1),
- tagOrId, *hash_kv(slot)) if slot != {}
- self
- end
-
- def latintagfont_configure(tagOrId, ltn, keys=nil)
- pathname = __item_pathname(tagOrId)
- if (fobj = TkFont.used_on(pathname))
- fobj = TkFont.new(fobj) # create a new TkFont object
- elsif Tk::JAPANIZED_TK
- fobj = tagfontobj(tagOrId) # create a new TkFont object
- else
- tk_call(self.path, __conf_cmd(0), __conf_cmd(1), tagOrId, '-font', ltn)
- return self
- end
-
- if fobj.kind_of?(TkFont)
- 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
- end
-
- return fobj.call_font_configure(pathname, self.path,
- __conf_cmd(0), __conf_cmd(1), tagOrId, {})
- end
- alias asciitagfont_configure latintagfont_configure
-
- def kanjitagfont_configure(tagOrId, knj, keys=nil)
- pathname = __item_pathname(tagOrId)
- if (fobj = TkFont.used_on(pathname))
- fobj = TkFont.new(fobj) # create a new TkFont object
- elsif Tk::JAPANIZED_TK
- fobj = tagfontobj(tagOrId) # create a new TkFont object
- else
- tk_call(self.path, __conf_cmd(0), __conf_cmd(1), tagOrId, '-font', knj)
- return self
- end
-
- if fobj.kind_of?(TkFont)
- 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
- end
-
- return fobj.call_font_configure(pathname, self.path,
- __conf_cmd(0), __conf_cmd(1), tagOrId, {})
- end
-
- def tagfont_copy(tagOrId, window, wintag=nil)
- pathname = __item_pathname(tagOrId)
- if wintag
- fnt = window.tagfontobj(wintag).dup
- else
- fnt = window.fontobj.dup
- end
- fnt.call_font_configure(pathname, self.path,
- __conf_cmd(0), __conf_cmd(1), tagOrId, {})
- return self
- end
-
- def latintagfont_copy(tagOrId, window, wintag=nil)
- pathname = __item_pathname(tagOrId)
- tagfontobj(tagOrId).dup.call_font_configure(pathname, self.path,
- __conf_cmd(0), __conf_cmd(1),
- tagOrId, {})
- if wintag
- tagfontobj(tagOrId).
- latin_replace(window.tagfontobj(wintag).latin_font_id)
- else
- tagfontobj(tagOrId).latin_replace(window.fontobj.latin_font_id)
- end
- self
- end
- alias asciitagfont_copy latintagfont_copy
-
- def kanjitagfont_copy(tagOrId, window, wintag=nil)
- pathname = __item_pathname(tagOrId)
- tagfontobj(tagOrId).dup.call_font_configure(pathname, self.path,
- __conf_cmd(0), __conf_cmd(1),
- tagOrId, {})
- if wintag
- tagfontobj(tagOrId).
- kanji_replace(window.tagfontobj(wintag).kanji_font_id)
- else
- tagfontobj(tagOrId).kanji_replace(window.fontobj.kanji_font_id)
- end
- self
- end
-end
-
-class TkObject<TkKernel
- include Tk
- include TkTreatFont
- include TkBindCore
-
- def path
- return @path
- end
-
- def epath
- return @path
- end
-
- def to_eval
- @path
- end
-
- def tk_send(cmd, *rest)
- tk_call path, cmd, *rest
- end
- private :tk_send
-
- def method_missing(id, *args)
- name = id.id2name
- case args.length
- when 1
- configure name, args[0]
- when 0
- begin
- cget name
- rescue
- fail NameError,
- "undefined local variable or method `#{name}' for #{self.to_s}",
- error_at
- end
- else
- fail NameError, "undefined method `#{name}' for #{self.to_s}", error_at
- end
- end
-
- def [](id)
- cget id
- end
-
- def []=(id, val)
- configure id, val
- end
-
- def cget(slot)
- case slot.to_s
- when 'text', 'label', 'show', 'data', 'file'
- tk_call path, 'cget', "-#{slot}"
- when 'font', 'kanjifont'
- #fnt = tk_tcl2ruby(tk_call(path, 'cget', "-#{slot}"))
- fnt = tk_tcl2ruby(tk_call(path, 'cget', "-font"))
- unless fnt.kind_of?(TkFont)
- fnt = fontobj(fnt)
- end
- if slot == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
- # obsolete; just for compatibility
- fnt.kanji_font
- else
- fnt
- end
- else
- tk_tcl2ruby tk_call(path, 'cget', "-#{slot}")
- end
- end
-
- def configure(slot, value=None)
- if slot.kind_of? Hash
- if (slot['font'] || slot[:font] ||
- slot['kanjifont'] || slot[:kanjifont] ||
- slot['latinfont'] || slot[:latinfont] ||
- slot['asciifont'] || slot[:asciifont] )
- font_configure(slot)
- elsif slot.size > 0
- tk_call path, 'configure', *hash_kv(slot)
- end
-
- else
- if (slot == 'font' || slot == :font ||
- slot == 'kanjifont' || slot == :kanjifont ||
- slot == 'latinfont' || slot == :latinfont ||
- slot == 'asciifont' || slot == :asciifont )
- if value == None
- fontobj
- else
- font_configure({slot=>value})
- end
- else
- tk_call path, 'configure', "-#{slot}", value
- end
- end
- self
- end
-
- def configure_cmd(slot, value)
- configure slot, install_cmd(value)
- end
-
- def configinfo(slot = nil)
- if slot == 'font' || slot == :font ||
- slot == 'kanjifont' || slot == :kanjifont
- conf = tk_split_simplelist(tk_send('configure', "-#{slot}") )
- conf[0] = conf[0][1..-1]
- conf[4] = fontobj(conf[4])
- conf
- else
- if slot
- case slot.to_s
- when 'text', 'label', 'show', 'data', 'file'
- conf = tk_split_simplelist(tk_send('configure', "-#{slot}") )
- else
- conf = tk_split_list(tk_send('configure', "-#{slot}") )
- end
- conf[0] = conf[0][1..-1]
- conf
- else
- ret = tk_split_simplelist(tk_send('configure') ).collect{|conflist|
- conf = tk_split_simplelist(conflist)
- conf[0] = conf[0][1..-1]
- case conf[0]
- when 'text', 'label', 'show', 'data', 'file'
- else
- if conf[3]
- if conf[3].index('{')
- conf[3] = tk_split_list(conf[3])
- else
- conf[3] = tk_tcl2ruby(conf[3])
- end
- end
- if conf[4]
- if conf[4].index('{')
- conf[4] = tk_split_list(conf[4])
- else
- conf[4] = tk_tcl2ruby(conf[4])
- end
- end
- end
- conf
- }
- fontconf = ret.assoc('font')
- if fontconf
- ret.delete_if{|item| item[0] == 'font' || item[0] == 'kanjifont'}
- fontconf[4] = fontobj(fontconf[4])
- ret.push(fontconf)
- else
- ret
- end
- end
- end
- end
-
- def event_generate(context, keys=nil)
- if keys
- tk_call('event', 'generate', path,
- "<#{tk_event_sequence(context)}>", *hash_kv(keys))
- else
- tk_call('event', 'generate', path, "<#{tk_event_sequence(context)}>")
- end
- end
-
- def tk_trace_variable(v)
- unless v.kind_of?(TkVariable)
- fail(ArgumentError,
- Kernel.format("type error (%s); must be TkVariable object",
- v.class))
- end
- v
- end
- private :tk_trace_variable
-
- def destroy
- # tk_call 'trace', 'vdelete', @tk_vn, 'w', @var_id if @var_id
- end
-end
-
-class TkWindow<TkObject
- include TkWinfo
- extend TkBindCore
-
- WidgetClassName = ''.freeze
- 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')
- if without_creating && !widgetname
- fail ArgumentError,
- "if set 'without_creating' to true, need to define 'widgetname'"
- end
- elsif keys
- keys = _symbolkey2str(keys)
- widgetname = keys.delete('widgetname')
- install_win(if parent then parent.path end, widgetname)
- without_creating = keys.delete('without_creating')
- if without_creating && !widgetname
- fail ArgumentError,
- "if set 'without_creating' to true, need to define 'widgetname'"
- end
- 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
- else
- p 'create_self has args' if $DEBUG
- fontkeys = {}
- if keys
- ['font', 'kanjifont', 'latinfont', 'asciifont'].each{|key|
- fontkeys[key] = keys.delete(key) if keys.key?(key)
- }
- end
- if without_creating && keys
- configure(keys)
- else
- create_self(keys)
- end
- font_configure(fontkeys) unless fontkeys.empty?
- end
- end
-
- def create_self
- fail RuntimeError, "TkWindow is an abstract class"
- end
- private :create_self
-
- def bind_class
- @db_class || self.class()
- end
-
- def database_classname
- TkWinfo.classname(self)
- end
- def database_class
- name = database_classname()
- if WidgetClassNames[name]
- WidgetClassNames[name]
- else
- TkDatabaseClass.new(name)
- end
- end
- def self.database_classname
- self::WidgetClassName
- end
- def self.database_class
- WidgetClassNames[self::WidgetClassName]
- end
-
- def pack(keys = nil)
- tk_call 'pack', epath, *hash_kv(keys)
- self
- end
-
- 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)
- self
- end
-
- def unpack
- tk_call 'pack', 'forget', epath
- self
- end
- alias pack_forget unpack
-
- 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
- end
-
- def pack_info()
- ilist = list(tk_call('pack', 'info', epath))
- info = {}
- while key = ilist.shift
- info[key[1..-1]] = ilist.shift
- end
- return info
- end
-
- def pack_propagate(mode=None)
- if mode == None
- tk_call('pack', 'propagate', epath, mode)
- else
- bool(tk_call('pack', 'propagate', epath))
- end
- end
-
- def pack_slaves()
- list(tk_call('pack', 'slaves', epath))
- end
-
- def grid(keys = nil)
- tk_call 'grid', epath, *hash_kv(keys)
- self
- end
-
- def grid_in(target, keys = nil)
- if keys
- keys = keys.dup
- keys['in'] = target
- else
- keys = {'in'=>target}
- end
- tk_call 'grid', epath, *hash_kv(keys)
- self
- end
-
- def ungrid
- tk_call 'grid', 'forget', epath
- self
- end
- alias grid_forget ungrid
-
- def grid_bbox(*args)
- list(tk_call('grid', 'bbox', epath, *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
- end
-
- def grid_columnconfig(index, keys)
- tk_call('grid', 'columnconfigure', epath, index, *hash_kv(keys))
- end
-
- def grid_rowconfig(index, keys)
- tk_call('grid', 'rowconfigure', epath, index, *hash_kv(keys))
- end
-
- 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
- info[key[1..-1]] = ilist.shift
- end
- info
- end
- end
-
- 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
- info[key[1..-1]] = ilist.shift
- end
- info
- end
- end
-
- def grid_info()
- list(tk_call('grid', 'info', epath))
- end
-
- def grid_location(x, y)
- list(tk_call('grid', 'location', epath, x, y))
- end
-
- def grid_propagate(mode=None)
- if mode == None
- tk_call('grid', 'propagate', epath, mode)
- else
- bool(tk_call('grid', 'propagate', epath))
- end
- end
-
- def grid_remove()
- tk_call 'grid', 'remove', epath
- end
-
- def grid_size()
- tk_call 'grid', 'size', epath
- end
-
- def grid_slaves(args)
- list(tk_call('grid', 'slaves', epath, *hash_kv(args)))
- end
-
- def place(keys = nil)
- tk_call 'place', epath, *hash_kv(keys)
- self
- end
-
- 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)
- self
- end
-
- def unplace
- tk_call 'place', 'forget', epath
- self
- end
- alias place_forget unplace
-
- 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
- end
-
- 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',
- 'configure', epath)).collect{|conflist|
- conf = tk_split_simplelist(conflist)
- conf[0] = conf[0][1..-1]
- conf
- }
- end
- end
-
- def place_info()
- ilist = list(tk_call('place', 'info', epath))
- info = {}
- while key = ilist.shift
- info[key[1..-1]] = ilist.shift
- end
- return info
- end
-
- def place_slaves()
- list(tk_call('place', 'slaves', epath))
- end
-
- def focus(force=false)
- if force
- tk_call 'focus', '-force', path
- else
- tk_call 'focus', path
- end
- self
- end
-
- def grab(*args)
- if !args or args.length == 0
- tk_call 'grab', 'set', path
- self
- elsif args.length == 1
- case args[0]
- when 'global', :global
- #return(tk_call('grab', 'set', '-global', path))
- tk_call('grab', 'set', '-global', path)
- return self
- when 'release', :release
- #return tk_call('grab', 'release', path)
- tk_call('grab', 'release', path)
- return self
- else
- val = tk_call('grab', args[0], path)
- end
- case args[0]
- when 'current', :current
- return window(val)
- when 'status', :status
- return val
- end
- self
- else
- fail ArgumentError, 'wrong # of args'
- end
- end
-
- def grab_current
- grab('current')
- end
- def grab_release
- grab('release')
- end
- def grab_set
- grab('set')
- end
- def grab_set_global
- grab('global')
- end
- def grab_status
- grab('status')
- end
-
- def lower(below=None)
- tk_call 'lower', epath, below
- self
- end
- def raise(above=None)
- tk_call 'raise', epath, above
- self
- end
-
- def command(cmd=Proc.new)
- configure_cmd 'command', cmd
- end
-
- def colormodel model=None
- tk_call 'tk', 'colormodel', path, model
- self
- end
-
- def caret(keys=nil)
- TkXIM.caret(path, keys)
- end
-
- 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
- uninstall_cmd id
- end
- end
-
- children.each{|path, obj|
- if defined?(@cmdtbl)
- for id in @cmdtbl
- uninstall_cmd id
- end
- end
- TkCore::INTERP.tk_windows.delete(path)
- }
-
- begin
- tk_call 'destroy', epath
- rescue
- end
- uninstall_win
- end
-
- def wait_visibility(on_thread = true)
- if $SAFE >= 4
- fail SecurityError, "can't wait visibility at $SAFE >= 4"
- end
- if on_thread
- INTERP._thread_tkwait('visibility', path)
- else
- INTERP._invoke('tkwait', 'visibility', path)
- end
- end
- def eventloop_wait_visibility
- wait_visibility(false)
- end
- def thread_wait_visibility
- wait_visibility(true)
- end
- 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
-
- def wait_destroy(on_thread = true)
- if $SAFE >= 4
- fail SecurityError, "can't wait destroy at $SAFE >= 4"
- end
- if on_thread
- INTERP._thread_tkwait('window', epath)
- else
- INTERP._invoke('tkwait', 'window', epath)
- end
- end
- def eventloop_wait_destroy
- wait_destroy(false)
- end
- def thread_wait_destroy
- wait_destroy(true)
- end
- alias tkwait_destroy wait_destroy
- alias eventloop_tkwait_destroy eventloop_wait_destroy
- alias thread_tkwait_destroy thread_wait_destroy
-
- 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|
- if tag.kind_of?(String)
- if cls = WidgetClassNames[tag]
- cls
- elsif btag = TkBindTag.id2obj(tag)
- btag
- else
- tag
- end
- else
- tag
- end
- }
- end
- end
-
- def bindtags=(taglist)
- bindtags(taglist)
- end
-
- def bindtags_shift
- taglist = bindtags
- tag = taglist.shift
- bindtags(taglist)
- tag
- end
-
- def bindtags_unshift(tag)
- bindtags(bindtags().unshift(tag))
- end
-end
-
-class TkRoot<TkWindow
- include Wm
-
-=begin
- ROOT = []
- def TkRoot.new(keys=nil)
- if ROOT[0]
- Tk_WINDOWS["."] = ROOT[0]
- return ROOT[0]
- end
- new = super(:without_creating=>true, :widgetname=>'.')
- if keys # wm commands
- keys.each{|k,v|
- if v.kind_of? Array
- new.send(k,*v)
- else
- new.send(k,v)
- end
- }
- end
- ROOT[0] = new
- Tk_WINDOWS["."] = new
- end
-=end
- def TkRoot.new(keys=nil, &b)
- unless TkCore::INTERP.tk_windows['.']
- TkCore::INTERP.tk_windows['.'] =
- super(:without_creating=>true, :widgetname=>'.')
- end
- root = TkCore::INTERP.tk_windows['.']
- if keys # wm commands
- keys.each{|k,v|
- if v.kind_of? Array
- root.send(k,*v)
- else
- root.send(k,v)
- end
- }
- end
- root.instance_eval(&b) if block_given?
- root
- end
-
- WidgetClassName = 'Tk'.freeze
- WidgetClassNames[WidgetClassName] = self
-
- def create_self
- @path = '.'
- end
- private :create_self
-
- def path
- "."
- end
-
- def TkRoot.destroy
- TkCore::INTERP._invoke('destroy', '.')
- end
-end
-
-class TkToplevel<TkWindow
- include Wm
-
- TkCommandNames = ['toplevel'.freeze].freeze
- WidgetClassName = 'Toplevel'.freeze
- WidgetClassNames[WidgetClassName] = self
-
-################# old version
-# def initialize(parent=nil, screen=nil, classname=nil, keys=nil)
-# if screen.kind_of? Hash
-# keys = screen.dup
-# else
-# @screen = screen
-# end
-# @classname = classname
-# if keys.kind_of? Hash
-# keys = keys.dup
-# @classname = keys.delete('classname') if keys.key?('classname')
-# @colormap = keys.delete('colormap') if keys.key?('colormap')
-# @container = keys.delete('container') if keys.key?('container')
-# @screen = keys.delete('screen') if keys.key?('screen')
-# @use = keys.delete('use') if keys.key?('use')
-# @visual = keys.delete('visual') if keys.key?('visual')
-# end
-# super(parent, keys)
-# end
-#
-# def create_self
-# s = []
-# s << "-class" << @classname if @classname
-# s << "-colormap" << @colormap if @colormap
-# s << "-container" << @container if @container
-# s << "-screen" << @screen if @screen
-# s << "-use" << @use if @use
-# s << "-visual" << @visual if @visual
-# tk_call 'toplevel', @path, *s
-# end
-#################
-
- def _wm_command_option_chk(keys)
- keys = {} unless keys
- new_keys = {}
- wm_cmds = {}
- keys.each{|k,v|
- if Wm.method_defined?(k)
- case k
- when 'screen','class','colormap','container','use','visual'
- new_keys[k] = v
- else
- case self.method(k).arity
- when -1,1
- wm_cmds[k] = v
- else
- new_keys[k] = v
- end
- end
- else
- new_keys[k] = v
- end
- }
- [new_keys, wm_cmds]
- end
- private :_wm_command_option_chk
-
- def initialize(parent=nil, screen=nil, classname=nil, keys=nil)
- my_class_name = nil
- if self.class < WidgetClassNames[WidgetClassName]
- my_class_name = self.class.name
- my_class_name = nil if my_class_name == ''
- end
- if parent.kind_of? Hash
- keys = _symbolkey2str(parent)
- if keys.key?('classname')
- keys['class'] = keys.delete('classname')
- end
- @classname = keys['class']
- @colormap = keys['colormap']
- @container = keys['container']
- @screen = keys['screen']
- @use = keys['use']
- @visual = keys['visual']
- if !@classname && my_class_name
- keys['class'] = @classname = my_class_name
- end
- if @classname.kind_of? TkBindTag
- @db_class = @classname
- @classname = @classname.id
- elsif @classname
- @db_class = TkDatabaseClass.new(@classname)
- else
- @db_class = self.class
- @classname = @db_class::WidgetClassName
- end
- keys, cmds = _wm_command_option_chk(keys)
- super(keys)
- cmds.each{|k,v|
- if v.kind_of? Array
- self.send(k,*v)
- else
- self.send(k,v)
- end
- }
- return
- end
-
- if screen.kind_of? Hash
- keys = screen
- else
- @screen = screen
- if classname.kind_of? Hash
- keys = classname
- else
- @classname = classname
- end
- end
- if keys.kind_of? Hash
- keys = _symbolkey2str(keys)
- if keys.key?('classname')
- keys['class'] = keys.delete('classname')
- end
- @classname = keys['class'] unless @classname
- @colormap = keys['colormap']
- @container = keys['container']
- @screen = keys['screen'] unless @screen
- @use = keys['use']
- @visual = keys['visual']
- else
- keys = {}
- end
- if !@classname && my_class_name
- keys['class'] = @classname = my_class_name
- end
- if @classname.kind_of? TkBindTag
- @db_class = @classname
- @classname = @classname.id
- elsif @classname
- @db_class = TkDatabaseClass.new(@classname)
- else
- @db_class = self.class
- @classname = @db_class::WidgetClassName
- end
- keys, cmds = _wm_command_option_chk(keys)
- super(parent, keys)
- cmds.each{|k,v|
- if v.kind_of? Array
- self.send(k,*v)
- else
- self.send(k,v)
- end
- }
- end
-
- def create_self(keys)
- if keys and keys != None
- tk_call 'toplevel', @path, *hash_kv(keys)
- else
- tk_call 'toplevel', @path
- end
- end
- private :create_self
-
- def specific_class
- @classname
- end
-
- def self.database_class
- if self == WidgetClassNames[WidgetClassName] || self.name == ''
- self
- else
- TkDatabaseClass.new(self.name)
- end
- end
- def self.database_classname
- self.database_class.name
- end
-
- def self.bind(*args)
- if self == WidgetClassNames[WidgetClassName] || self.name == ''
- super(*args)
- else
- TkDatabaseClass.new(self.name).bind(*args)
- end
- end
- def self.bind_append(*args)
- if self == WidgetClassNames[WidgetClassName] || self.name == ''
- super(*args)
- else
- TkDatabaseClass.new(self.name).bind_append(*args)
- end
- end
- def self.bind_remove(*args)
- if self == WidgetClassNames[WidgetClassName] || self.name == ''
- super(*args)
- else
- TkDatabaseClass.new(self.name).bind_remove(*args)
- end
- end
- def self.bindinfo(*args)
- if self == WidgetClassNames[WidgetClassName] || self.name == ''
- super(*args)
- else
- TkDatabaseClass.new(self.name).bindinfo(*args)
- end
- end
-end
-
-class TkFrame<TkWindow
- TkCommandNames = ['frame'.freeze].freeze
- WidgetClassName = 'Frame'.freeze
- WidgetClassNames[WidgetClassName] = self
-
-################# old version
-# def initialize(parent=nil, keys=nil)
-# if keys.kind_of? Hash
-# keys = keys.dup
-# @classname = keys.delete('classname') if keys.key?('classname')
-# @colormap = keys.delete('colormap') if keys.key?('colormap')
-# @container = keys.delete('container') if keys.key?('container')
-# @visual = keys.delete('visual') if keys.key?('visual')
-# end
-# super(parent, keys)
-# end
-#
-# def create_self
-# s = []
-# s << "-class" << @classname if @classname
-# s << "-colormap" << @colormap if @colormap
-# s << "-container" << @container if @container
-# s << "-visual" << @visual if @visual
-# tk_call 'frame', @path, *s
-# end
-#################
-
- def initialize(parent=nil, keys=nil)
- my_class_name = nil
- if self.class < WidgetClassNames[WidgetClassName]
- my_class_name = self.class.name
- my_class_name = nil if my_class_name == ''
- end
- if parent.kind_of? Hash
- keys = _symbolkey2str(parent)
- else
- if keys
- keys = _symbolkey2str(keys)
- keys['parent'] = parent
- else
- keys = {'parent'=>parent}
- end
- end
- if keys.key?('classname')
- keys['class'] = keys.delete('classname')
- end
- @classname = keys['class']
- @colormap = keys['colormap']
- @container = keys['container']
- @visual = keys['visual']
- if !@classname && my_class_name
- keys['class'] = @classname = my_class_name
- end
- if @classname.kind_of? TkBindTag
- @db_class = @classname
- @classname = @classname.id
- elsif @classname
- @db_class = TkDatabaseClass.new(@classname)
- else
- @db_class = self.class
- @classname = @db_class::WidgetClassName
- end
- super(keys)
- end
-
- def create_self(keys)
- if keys and keys != None
- tk_call 'frame', @path, *hash_kv(keys)
- else
- tk_call 'frame', @path
- end
- end
- private :create_self
-
- def database_classname
- @classname
- end
-
- def self.database_class
- if self == WidgetClassNames[WidgetClassName] || self.name == ''
- self
- else
- TkDatabaseClass.new(self.name)
- end
- end
- def self.database_classname
- self.database_class.name
- end
-
- def self.bind(*args)
- if self == WidgetClassNames[WidgetClassName] || self.name == ''
- super(*args)
- else
- TkDatabaseClass.new(self.name).bind(*args)
- end
- end
- def self.bind_append(*args)
- if self == WidgetClassNames[WidgetClassName] || self.name == ''
- super(*args)
- else
- TkDatabaseClass.new(self.name).bind_append(*args)
- end
- end
- def self.bind_remove(*args)
- if self == WidgetClassNames[WidgetClassName] || self.name == ''
- super(*args)
- else
- TkDatabaseClass.new(self.name).bind_remove(*args)
- end
- end
- def self.bindinfo(*args)
- if self == WidgetClassNames[WidgetClassName] || self.name == ''
- super(*args)
- else
- TkDatabaseClass.new(self.name).bindinfo(*args)
- end
- end
-end
-
-class TkLabelFrame<TkFrame
- TkCommandNames = ['labelframe'.freeze].freeze
- WidgetClassName = 'Labelframe'.freeze
- WidgetClassNames[WidgetClassName] = self
- def create_self(keys)
- if keys and keys != None
- tk_call 'labelframe', @path, *hash_kv(keys)
- else
- tk_call 'labelframe', @path
- end
- end
- private :create_self
-end
-TkLabelframe = TkLabelFrame
-
-class TkPanedWindow<TkWindow
- TkCommandNames = ['panedwindow'.freeze].freeze
- WidgetClassName = 'Panedwindow'.freeze
- WidgetClassNames[WidgetClassName] = self
- def create_self(keys)
- if keys and keys != None
- tk_call 'panedwindow', @path, *hash_kv(keys)
- else
- tk_call 'panedwindow', @path
- end
- end
- private :create_self
-
- def add(*args)
- keys = args.pop
- fail ArgumentError, "no window in arguments" unless keys
- if keys && keys.kind_of?(Hash)
- fail ArgumentError, "no window in arguments" if args == []
- args += hash_kv(keys)
- else
- args.push(keys) if keys
- end
- tk_send('add', *args)
- self
- end
-
- def forget(win, *wins)
- tk_send('forget', win, *wins)
- self
- end
- alias del forget
- alias delete forget
- alias remove forget
-
- def identify(x, y)
- list(tk_send('identify', x, y))
- end
-
- def proxy_coord
- list(tk_send('proxy', 'coord'))
- end
- def proxy_forget
- tk_send('proxy', 'forget')
- self
- end
- def proxy_place(x, y)
- tk_send('proxy', 'place', x, y)
- self
- end
-
- def sash_coord(index)
- list(tk_send('sash', 'coord', index))
- end
- def sash_dragto(index)
- tk_send('sash', 'dragto', index, x, y)
- self
- end
- def sash_mark(index, x, y)
- tk_send('sash', 'mark', index, x, y)
- self
- end
- def sash_place(index, x, y)
- tk_send('sash', 'place', index, x, y)
- self
- end
-
- def panecget(win, key)
- tk_tcl2ruby(tk_send('panecget', win, "-#{key}"))
- end
-
- def paneconfigure(win, key, value=nil)
- if key.kind_of? Hash
- tk_send('paneconfigure', win, *hash_kv(key))
- else
- tk_send('paneconfigure', win, "-#{key}", value)
- end
- self
- end
- alias pane_config paneconfigure
-
- def paneconfiginfo(win, key=nil)
- if key
- conf = tk_split_list(tk_send('paneconfigure', win, "-#{key}"))
- conf[0] = conf[0][1..-1]
- conf
- else
- tk_split_simplelist(tk_send('paneconfigure', win)).collect{|conflist|
- conf = tk_split_simplelist(conflist)
- conf[0] = conf[0][1..-1]
- if conf[3]
- if conf[3].index('{')
- conf[3] = tk_split_list(conf[3])
- else
- conf[3] = tk_tcl2ruby(conf[3])
- end
- end
- if conf[4]
- if conf[4].index('{')
- conf[4] = tk_split_list(conf[4])
- else
- conf[4] = tk_tcl2ruby(conf[4])
- end
- end
- conf
- }
- end
- end
- alias pane_configinfo paneconfiginfo
-
- def panes
- list(tk_send('panes'))
- end
-end
-TkPanedwindow = TkPanedWindow
-
-class TkLabel<TkWindow
- TkCommandNames = ['label'.freeze].freeze
- WidgetClassName = 'Label'.freeze
- WidgetClassNames[WidgetClassName] = self
- def create_self(keys)
- if keys and keys != None
- tk_call 'label', @path, *hash_kv(keys)
- else
- tk_call 'label', @path
- end
- end
- private :create_self
-
- def textvariable(v)
- configure 'textvariable', tk_trace_variable(v)
- end
-end
-
-class TkButton<TkLabel
- TkCommandNames = ['button'.freeze].freeze
- WidgetClassName = 'Button'.freeze
- WidgetClassNames[WidgetClassName] = self
- def create_self(keys)
- if keys and keys != None
- tk_call 'button', @path, *hash_kv(keys)
- else
- tk_call 'button', @path
- end
- end
- private :create_self
-
- def invoke
- tk_send 'invoke'
- end
- def flash
- tk_send 'flash'
- self
- end
-end
-
-class TkRadioButton<TkButton
- TkCommandNames = ['radiobutton'.freeze].freeze
- WidgetClassName = 'Radiobutton'.freeze
- WidgetClassNames[WidgetClassName] = self
- def create_self(keys)
- if keys and keys != None
- tk_call 'radiobutton', @path, *hash_kv(keys)
- else
- tk_call 'radiobutton', @path
- end
- end
- private :create_self
-
- def deselect
- tk_send 'deselect'
- self
- end
- def select
- tk_send 'select'
- self
- end
- def variable(v)
- configure 'variable', tk_trace_variable(v)
- end
-end
-TkRadiobutton = TkRadioButton
-
-class TkCheckButton<TkRadioButton
- TkCommandNames = ['checkbutton'.freeze].freeze
- WidgetClassName = 'Checkbutton'.freeze
- WidgetClassNames[WidgetClassName] = self
- def create_self(keys)
- if keys and keys != None
- tk_call 'checkbutton', @path, *hash_kv(keys)
- else
- tk_call 'checkbutton', @path
- end
- end
- private :create_self
-
- def toggle
- tk_send 'toggle'
- self
- end
-end
-TkCheckbutton = TkCheckButton
-
-class TkMessage<TkLabel
- TkCommandNames = ['message'.freeze].freeze
- WidgetClassName = 'Message'.freeze
- WidgetClassNames[WidgetClassName] = self
- def create_self(keys)
- if keys and keys != None
- tk_call 'message', @path, *hash_kv(keys)
- else
- tk_call 'message', @path
- end
- end
- private :create_self
-end
-
-class TkScale<TkWindow
- TkCommandNames = ['scale'.freeze].freeze
- WidgetClassName = 'Scale'.freeze
- WidgetClassNames[WidgetClassName] = self
-
- def create_self(keys)
- if keys and keys != None
- if keys.key?('command')
- cmd = keys.delete('command')
- keys['command'] = proc{|val| cmd.call(val.to_f)}
- end
- tk_call 'scale', @path, *hash_kv(keys)
- else
- tk_call 'scale', @path
- end
- end
- private :create_self
-
- def _wrap_command_arg(cmd)
- proc{|val|
- if val.kind_of?(String)
- cmd.call(number(val))
- else
- cmd.call(val)
- end
- }
- end
- private :_wrap_command_arg
-
- def configure_cmd(slot, value)
- configure(slot=>value)
- end
-
- def configure(slot, value=None)
- if (slot == 'command' || slot == :command)
- configure('command'=>value)
- elsif slot.kind_of?(Hash) &&
- (slot.key?('command') || slot.key?(:command))
- slot = _symbolkey2str(slot)
- slot['command'] = _wrap_command_arg(slot.delete('command'))
- end
- super(slot, value)
- end
-
- def command(cmd=Proc.new)
- configure('command'=>cmd)
- end
-
- def get(x=None, y=None)
- number(tk_send('get', x, y))
- end
-
- def coords(val=None)
- tk_split_list(tk_send('coords', val))
- end
-
- def identify(x, y)
- tk_send('identify', x, y)
- end
-
- def set(val)
- tk_send("set", val)
- end
-
- def value
- get
- end
-
- def value= (val)
- set(val)
- end
-end
-
-class TkScrollbar<TkWindow
- TkCommandNames = ['scrollbar'.freeze].freeze
- WidgetClassName = 'Scrollbar'.freeze
- WidgetClassNames[WidgetClassName] = self
-
- def create_self(keys)
- if keys and keys != None
- tk_call 'scrollbar', @path, *hash_kv(keys)
- else
- tk_call 'scrollbar', @path
- end
- end
- private :create_self
-
- def delta(deltax=None, deltay=None)
- number(tk_send('delta', deltax, deltay))
- end
-
- def fraction(x=None, y=None)
- number(tk_send('fraction', x, y))
- end
-
- def identify(x, y)
- tk_send('identify', x, y)
- end
-
- def get
- ary1 = tk_send('get').split
- ary2 = []
- for i in ary1
- ary2.push number(i)
- end
- ary2
- end
-
- def set(first, last)
- tk_send "set", first, last
- self
- end
-
- def activate(element=None)
- tk_send('activate', element)
- end
-end
-
-class TkTextWin<TkWindow
- def create_self
- fail RuntimeError, "TkTextWin is an abstract class"
- end
- private :create_self
-
- def bbox(index)
- list(tk_send('bbox', index))
- end
- def delete(first, last=None)
- tk_send 'delete', first, last
- self
- end
- def get(*index)
- tk_send 'get', *index
- end
- def insert(index, *args)
- tk_send 'insert', index, *args
- self
- end
- def scan_mark(x, y)
- tk_send 'scan', 'mark', x, y
- self
- end
- def scan_dragto(x, y)
- tk_send 'scan', 'dragto', x, y
- self
- end
- def see(index)
- tk_send 'see', index
- self
- end
-end
-
-module TkTreatListItemFont
- include TkTreatItemFont
-
- ItemCMD = ['itemconfigure'.freeze, TkComm::None].freeze
- def __conf_cmd(idx)
- ItemCMD[idx]
- end
-
- def __item_pathname(tagOrId)
- self.path + ';' + tagOrId.to_s
- end
-
- private :__conf_cmd, :__item_pathname
-end
-
-class TkListbox<TkTextWin
- include TkTreatListItemFont
- include Scrollable
-
- TkCommandNames = ['listbox'.freeze].freeze
- WidgetClassName = 'Listbox'.freeze
- WidgetClassNames[WidgetClassName] = self
-
- def create_self(keys)
- if keys and keys != None
- tk_call 'listbox', @path, *hash_kv(keys)
- else
- tk_call 'listbox', @path
- end
- end
- private :create_self
-
- def activate(y)
- tk_send 'activate', y
- self
- end
- def curselection
- list(tk_send('curselection'))
- end
- def get(*index)
- v = tk_send('get', *index)
- if index.size == 1
- v
- else
- tk_split_simplelist(v)
- end
- end
- def nearest(y)
- tk_send('nearest', y).to_i
- end
- def size
- tk_send('size').to_i
- end
- def selection_anchor(index)
- tk_send 'selection', 'anchor', index
- self
- end
- def selection_clear(first, last=None)
- tk_send 'selection', 'clear', first, last
- self
- end
- def selection_includes(index)
- bool(tk_send('selection', 'includes', index))
- end
- def selection_set(first, last=None)
- tk_send 'selection', 'set', first, last
- self
- end
-
- def index(index)
- tk_send('index', index).to_i
- end
-
- def itemcget(index, key)
- case key.to_s
- when 'text', 'label', 'show'
- tk_send('itemcget', index, "-#{key}")
- when 'font', 'kanjifont'
- #fnt = tk_tcl2ruby(tk_send('itemcget', index, "-#{key}"))
- fnt = tk_tcl2ruby(tk_send('itemcget', index, '-font'))
- unless fnt.kind_of?(TkFont)
- fnt = tagfontobj(index, fnt)
- end
- if key.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
- # obsolete; just for compatibility
- fnt.kanji_font
- else
- fnt
- end
- else
- tk_tcl2ruby(tk_send('itemcget', index, "-#{key}"))
- end
- end
- def itemconfigure(index, key, val=None)
- if key.kind_of? Hash
- if (key['font'] || key[:font] ||
- key['kanjifont'] || key[:kanjifont] ||
- key['latinfont'] || key[:latinfont] ||
- key['asciifont'] || key[:asciifont] )
- tagfont_configure(index, _symbolkey2str(key))
- else
- tk_send 'itemconfigure', index, *hash_kv(key)
- end
-
- else
- if (key == 'font' || key == :font ||
- key == 'kanjifont' || key == :kanjifont ||
- key == 'latinfont' || key == :latinfont ||
- key == 'asciifont' || key == :asciifont )
- if val == None
- tagfontobj(index)
- else
- tagfont_configure(index, {key=>val})
- end
- else
- tk_call 'itemconfigure', index, "-#{key}", val
- end
- end
- self
- end
-
- def itemconfiginfo(index, key=nil)
- if key
- case key.to_s
- when 'text', 'label', 'show'
- conf = tk_split_simplelist(tk_send('itemconfigure',index,"-#{key}"))
- when 'font', 'kanjifont'
- conf = tk_split_simplelist(tk_send('itemconfigure',index,"-#{key}") )
- conf[4] = tagfont_configinfo(index, conf[4])
- else
- conf = tk_split_list(tk_send('itemconfigure',index,"-#{key}"))
- end
- conf[0] = conf[0][1..-1]
- conf
- else
- ret = tk_split_simplelist(tk_send('itemconfigure',
- index)).collect{|conflist|
- conf = tk_split_simplelist(conflist)
- conf[0] = conf[0][1..-1]
- case conf[0]
- when 'text', 'label', 'show'
- else
- if conf[3]
- if conf[3].index('{')
- conf[3] = tk_split_list(conf[3])
- else
- conf[3] = tk_tcl2ruby(conf[3])
- end
- end
- if conf[4]
- if conf[4].index('{')
- conf[4] = tk_split_list(conf[4])
- else
- conf[4] = tk_tcl2ruby(conf[4])
- end
- end
- end
- conf
- }
- fontconf = ret.assoc('font')
- if fontconf
- ret.delete_if{|item| item[0] == 'font' || item[0] == 'kanjifont'}
- fontconf[4] = tagfont_configinfo(index, fontconf[4])
- ret.push(fontconf)
- else
- ret
- end
- end
- end
-end
-
-module TkTreatMenuEntryFont
- include TkTreatItemFont
-
- ItemCMD = ['entryconfigure'.freeze, TkComm::None].freeze
- def __conf_cmd(idx)
- ItemCMD[idx]
- end
-
- def __item_pathname(tagOrId)
- self.path + ';' + tagOrId.to_s
- end
-
- private :__conf_cmd, :__item_pathname
-end
-
-class TkMenu<TkWindow
- include TkTreatMenuEntryFont
-
- TkCommandNames = ['menu'.freeze].freeze
- WidgetClassName = 'Menu'.freeze
- WidgetClassNames[WidgetClassName] = self
-
- def create_self(keys)
- if keys and keys != None
- tk_call 'menu', @path, *hash_kv(keys)
- else
- tk_call 'menu', @path
- end
- end
- private :create_self
-
- def activate(index)
- tk_send 'activate', index
- self
- end
- def add(type, keys=nil)
- tk_send 'add', type, *hash_kv(keys)
- self
- end
- def add_cascade(keys=nil)
- add('cascade', keys)
- end
- def add_checkbutton(keys=nil)
- add('checkbutton', keys)
- end
- def add_command(keys=nil)
- add('command', keys)
- end
- def add_radiobutton(keys=nil)
- add('radiobutton', keys)
- end
- def add_separator(keys=nil)
- add('separator', keys)
- end
- def index(index)
- ret = tk_send('index', index)
- (ret == 'none')? nil: number(ret)
- end
- def invoke(index)
- tk_send 'invoke', index
- end
- def insert(index, type, keys=nil)
- tk_send 'insert', index, type, *hash_kv(keys)
- self
- end
- def delete(index, last=None)
- tk_send 'delete', index, last
- self
- end
- def popup(x, y, index=None)
- tk_call('tk_popup', path, x, y, index)
- self
- end
- def post(x, y)
- tk_send 'post', x, y
- self
- end
- def postcascade(index)
- tk_send 'postcascade', index
- self
- end
- def postcommand(cmd=Proc.new)
- configure_cmd 'postcommand', cmd
- self
- end
- def set_focus
- tk_call('tk_menuSetFocus', path)
- end
- def tearoffcommand(cmd=Proc.new)
- configure_cmd 'tearoffcommand', cmd
- self
- end
- def menutype(index)
- tk_send 'type', index
- end
- def unpost
- tk_send 'unpost'
- end
- def yposition(index)
- number(tk_send('yposition', index))
- end
- def entrycget(index, key)
- case key.to_s
- when 'text', 'label', 'show'
- tk_send 'entrycget', index, "-#{key}"
- when 'font', 'kanjifont'
- #fnt = tk_tcl2ruby(tk_send('entrycget', index, "-#{key}"))
- fnt = tk_tcl2ruby(tk_send('entrycget', index, '-font'))
- unless fnt.kind_of?(TkFont)
- fnt = tagfontobj(index, fnt)
- end
- if key.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
- # obsolete; just for compatibility
- fnt.kanji_font
- else
- fnt
- end
- else
- tk_tcl2ruby(tk_send('entrycget', index, "-#{key}"))
- end
- end
- def entryconfigure(index, key, val=None)
- if key.kind_of? Hash
- if (key['font'] || key[:font] ||
- key['kanjifont'] || key[:kanjifont] ||
- key['latinfont'] || key[:latinfont] ||
- key['asciifont'] || key[:asciifont])
- tagfont_configure(index, _symbolkey2str(key))
- else
- tk_send 'entryconfigure', index, *hash_kv(key)
- end
-
- else
- if (key == 'font' || key == :font ||
- key == 'kanjifont' || key == :kanjifont ||
- key == 'latinfont' || key == :latinfont ||
- key == 'asciifont' || key == :asciifont )
- if val == None
- tagfontobj(index)
- else
- tagfont_configure(index, {key=>val})
- end
- else
- tk_call 'entryconfigure', index, "-#{key}", val
- end
- end
- self
- end
-
- def entryconfiginfo(index, key=nil)
- if key
- case key.to_s
- when 'text', 'label', 'show'
- conf = tk_split_simplelist(tk_send('entryconfigure',index,"-#{key}"))
- when 'font', 'kanjifont'
- conf = tk_split_simplelist(tk_send('entryconfigure',index,"-#{key}"))
- conf[4] = tagfont_configinfo(index, conf[4])
- else
- conf = tk_split_list(tk_send('entryconfigure',index,"-#{key}"))
- end
- conf[0] = conf[0][1..-1]
- conf
- else
- ret = tk_split_simplelist(tk_send('entryconfigure',
- index)).collect{|conflist|
- conf = tk_split_simplelist(conflist)
- conf[0] = conf[0][1..-1]
- case conf[0]
- when 'text', 'label', 'show'
- else
- if conf[3]
- if conf[3].index('{')
- conf[3] = tk_split_list(conf[3])
- else
- conf[3] = tk_tcl2ruby(conf[3])
- end
- end
- if conf[4]
- if conf[4].index('{')
- conf[4] = tk_split_list(conf[4])
- else
- conf[4] = tk_tcl2ruby(conf[4])
- end
- end
- end
- conf
- }
- if fontconf
- ret.delete_if{|item| item[0] == 'font' || item[0] == 'kanjifont'}
- fontconf[4] = tagfont_configinfo(index, fontconf[4])
- ret.push(fontconf)
- else
- ret
- end
- end
- end
-end
-
-class TkMenuClone<TkMenu
- def initialize(parent, type=None)
- widgetname = nil
- if parent.kind_of? Hash
- keys = _symbolkey2str(parent)
- parent = keys.delete('parent')
- widgetname = keys.delete('widgetname')
- type = keys.delete('type'); type = None unless type
- end
- unless parent.kind_of?(TkMenu)
- fail ArgumentError, "parent must be TkMenu"
- end
- @parent = parent
- install_win(@parent.path, widgetname)
- tk_call @parent.path, 'clone', @path, type
- end
-end
-
-module TkSystemMenu
- def initialize(parent, keys=nil)
- if parent.kind_of? Hash
- keys = _symbolkey2str(parent)
- parent = keys.delete('parent')
- end
- unless parent.kind_of? TkMenu
- fail ArgumentError, "parent must be a TkMenu object"
- end
- @path = Kernel.format("%s.%s", parent.path, self.class::SYSMENU_NAME)
- #TkComm::Tk_WINDOWS[@path] = self
- TkCore::INTERP.tk_windows[@path] = self
- if self.method(:create_self).arity == 0
- p 'create_self has no arg' if $DEBUG
- create_self
- configure(keys) if keys
- else
- p 'create_self has an arg' if $DEBUG
- create_self(keys)
- end
- end
-end
-
-class TkSysMenu_Help<TkMenu
- # for all platform
- include TkSystemMenu
- SYSMENU_NAME = 'help'
-end
-
-class TkSysMenu_System<TkMenu
- # for Windows
- include TkSystemMenu
- SYSMENU_NAME = 'system'
-end
-
-class TkSysMenu_Apple<TkMenu
- # for Machintosh
- include TkSystemMenu
- SYSMENU_NAME = 'apple'
-end
-
-class TkMenubutton<TkLabel
- TkCommandNames = ['menubutton'.freeze].freeze
- WidgetClassName = 'Menubutton'.freeze
- WidgetClassNames[WidgetClassName] = self
- def create_self(keys)
- if keys and keys != None
- tk_call 'menubutton', @path, *hash_kv(keys)
- else
- tk_call 'menubutton', @path
- end
- end
- private :create_self
-end
-
-class TkOptionMenubutton<TkMenubutton
- TkCommandNames = ['tk_optionMenu'.freeze].freeze
-
- class OptionMenu<TkMenu
- def initialize(path) #==> return value of tk_optionMenu
- @path = path
- #TkComm::Tk_WINDOWS[@path] = self
- TkCore::INTERP.tk_windows[@path] = self
- end
- end
-
- def initialize(parent=nil, var=TkVariable.new, firstval=nil, *vals)
- if parent.kind_of? Hash
- keys = _symbolkey2str(parent)
- parent = keys['parent']
- var = keys['variable'] if keys['variable']
- firstval, *vals = keys['values']
- end
- fail 'variable option must be TkVariable' unless var.kind_of? TkVariable
- @variable = var
- firstval = @variable.value unless firstval
- @variable.value = firstval
- install_win(if parent then parent.path end)
- @menu = OptionMenu.new(tk_call('tk_optionMenu', @path, @variable.id,
- firstval, *vals))
- end
-
- def value
- @variable.value
- end
-
- def activate(index)
- @menu.activate(index)
- self
- end
- def add(value)
- @menu.add('radiobutton', 'variable'=>@variable,
- 'label'=>value, 'value'=>value)
- self
- end
- def index(index)
- @menu.index(index)
- end
- def invoke(index)
- @menu.invoke(index)
- end
- def insert(index, value)
- @menu.add(index, 'radiobutton', 'variable'=>@variable,
- 'label'=>value, 'value'=>value)
- self
- end
- def delete(index, last=None)
- @menu.delete(index, last)
- self
- end
- def yposition(index)
- @menu.yposition(index)
- end
- def menu
- @menu
- end
- def menucget(key)
- @menu.cget(key)
- end
- def menuconfigure(key, val=None)
- @menu.configure(key, val)
- self
- end
- def menuconfiginfo(key=nil)
- @menu.configinfo(key)
- end
- def entrycget(index, key)
- @menu.entrycget(index, key)
- end
- def entryconfigure(index, key, val=None)
- @menu.entryconfigure(index, key, val)
- self
- end
- def entryconfiginfo(index, key=nil)
- @menu.entryconfiginfo(index, key)
- end
-end
-
-module TkComposite
- include Tk
- extend Tk
-
- def initialize(parent=nil, *args)
- @delegates = {}
-
- if parent.kind_of? Hash
- keys = _symbolkey2str(parent)
- parent = keys.delete('parent')
- @frame = TkFrame.new(parent)
- @delegates['DEFAULT'] = @frame
- @path = @epath = @frame.path
- initialize_composite(keys)
- else
- @frame = TkFrame.new(parent)
- @delegates['DEFAULT'] = @frame
- @path = @epath = @frame.path
- initialize_composite(*args)
- end
- end
-
- def epath
- @epath
- end
-
- def initialize_composite(*args) end
- private :initialize_composite
-
- def delegate(option, *wins)
- if @delegates[option].kind_of?(Array)
- for i in wins
- @delegates[option].push(i)
- end
- else
- @delegates[option] = wins
- end
- end
-
- def configure(slot, value=None)
- if slot.kind_of? Hash
- slot.each{|slot,value| configure slot, value}
- else
- if @delegates and @delegates[slot]
- for i in @delegates[slot]
- if not i
- i = @delegates['DEFALUT']
- redo
- else
- last = i.configure(slot, value)
- end
- end
- last
- else
- super
- end
- end
- end
-end
-
-module TkClipboard
- include Tk
- extend Tk
-
- TkCommandNames = ['clipboard'.freeze].freeze
-
- def self.clear(win=nil)
- if win
- tk_call 'clipboard', 'clear', '-displayof', win
- else
- tk_call 'clipboard', 'clear'
- end
- end
- def self.clear_on_display(win)
- tk_call 'clipboard', 'clear', '-displayof', win
- end
-
- def self.get(type=nil)
- if type
- tk_call 'clipboard', 'get', '-type', type
- else
- tk_call 'clipboard', 'get'
- end
- end
- def self.get_on_display(win, type=nil)
- if type
- tk_call 'clipboard', 'get', '-displayof', win, '-type', type
- else
- tk_call 'clipboard', 'get', '-displayof', win
- end
- end
-
- def self.set(data, keys=nil)
- clear
- append(data, keys)
- end
- def self.set_on_display(win, data, keys=nil)
- clear(win)
- append_on_display(win, data, keys)
- end
-
- def self.append(data, keys=nil)
- args = ['clipboard', 'append']
- args += hash_kv(keys)
- args += ['--', data]
- tk_call(*args)
- end
- def self.append_on_display(win, data, keys=nil)
- args = ['clipboard', 'append', '-displayof', win]
- args += hash_kv(keys)
- args += ['--', data]
- tk_call(*args)
- end
-
- def clear
- TkClipboard.clear_on_display(self)
- self
- end
- def get(type=nil)
- TkClipboard.get_on_display(self, type)
- end
- def set(data, keys=nil)
- TkClipboard.set_on_display(self, data, keys)
- self
- end
- def append(data, keys=nil)
- TkClipboard.append_on_display(self, data, keys)
- self
- end
-end
-
-# widget_destroy_hook
-require 'tkvirtevent'
-TkBindTag::ALL.bind(TkVirtualEvent.new('Destroy'), proc{|xpath|
- path = xpath[1..-1]
- if (widget = TkCore::INTERP.tk_windows[path])
- if widget.respond_to?(:__destroy_hook__)
- begin
- widget.__destroy_hook__
- rescue Exception
- end
- end
- end
- }, 'x%W')
-
-# freeze core modules
-#TclTkLib.freeze
-#TclTkIp.freeze
-#TkUtil.freeze
-#TkKernel.freeze
-#TkComm.freeze
-#TkComm::Event.freeze
-#TkCore.freeze
-#Tk.freeze
-
-# autoload
-autoload :TkCanvas, 'tkcanvas'
-autoload :TkImage, 'tkcanvas'
-autoload :TkBitmapImage, 'tkcanvas'
-autoload :TkPhotoImage, 'tkcanvas'
-autoload :TkEntry, 'tkentry'
-autoload :TkSpinbox, 'tkentry'
-autoload :TkText, 'tktext'
-autoload :TkDialog, 'tkdialog'
-autoload :TkDialog2, 'tkdialog'
-autoload :TkWarning, 'tkdialog'
-autoload :TkWarning2, 'tkdialog'
-autoload :TkMenubar, 'tkmenubar'
-autoload :TkAfter, 'tkafter'
-autoload :TkTimer, 'tkafter'
-autoload :TkPalette, 'tkpalette'
-autoload :TkFont, 'tkfont'
-autoload :TkBgError, 'tkbgerror'
-autoload :TkManageFocus, 'tkmngfocus'
-autoload :TkPalette, 'tkpalette'
-autoload :TkWinDDE, 'tkwinpkg'
-autoload :TkWinRegistry, 'tkwinpkg'
-autoload :TkMacResource, 'tkmacpkg'
-autoload :TkConsole, 'tkconsole'
diff --git a/ext/tk/lib/tkafter.rb b/ext/tk/lib/tkafter.rb
deleted file mode 100644
index 53e78b8808..0000000000
--- a/ext/tk/lib/tkafter.rb
+++ /dev/null
@@ -1,414 +0,0 @@
-#
-# tkafter.rb : methods for Tcl/Tk after command
-#
-# $Id$
-#
-require 'tk'
-
-class TkTimer
- include TkCore
- extend TkCore
-
- TkCommandNames = ['after'.freeze].freeze
-
- Tk_CBID = ['a'.freeze, '00000'.taint].freeze
- Tk_CBTBL = {}.taint
-
- TkCore::INTERP.add_tk_procs('rb_after', 'id', <<-'EOL')
- if {[set st [catch {ruby [format "TkTimer.callback %%Q!%s!" $id]} ret]] != 0} {
- return -code $st $ret
- } {
- return $ret
- }
- EOL
-
-
- ###############################
- # class methods
- ###############################
- def self.callback(obj_id)
- @after_id = nil
- ex_obj = Tk_CBTBL[obj_id]
- return "" if ex_obj == nil; # canceled
- ex_obj.cb_call
- end
-
- def self.info
- tk_call('after', 'info').split(' ').collect!{|id|
- ret = Tk_CBTBL.find{|key,val| val.after_id == id}
- (ret == nil)? id: ret[1]
- }
- end
-
- ###############################
- # instance methods
- ###############################
- def do_callback
- @in_callback = true
- begin
- @return_value = @current_proc.call(self)
- rescue Exception => e
- if @cancel_on_exception
- cancel
- @return_value = e
- return e
- else
- fail e
- end
- end
- if @set_next
- set_next_callback(@current_args)
- else
- @set_next = true
- end
- @in_callback = false
- @return_value
- end
-
- def set_callback(sleep, args=nil)
- @after_script = "rb_after #{@id}"
- @after_id = tk_call('after', sleep, @after_script)
- @current_args = args
- @current_script = [sleep, @after_script]
- self
- end
-
- def set_next_callback(args)
- if @running == false || @proc_max == 0 || @do_loop == 0
- Tk_CBTBL.delete(@id) ;# for GC
- @running = false
- @wait_var.value = 0
- return
- end
- if @current_pos >= @proc_max
- if @do_loop < 0 || (@do_loop -= 1) > 0
- @current_pos = 0
- else
- Tk_CBTBL.delete(@id) ;# for GC
- @running = false
- @wait_var.value = 0
- return
- end
- end
-
- @current_args = args
-
- if @sleep_time.kind_of? Proc
- sleep = @sleep_time.call(self)
- else
- sleep = @sleep_time
- end
- @current_sleep = sleep
-
- cmd, *cmd_args = @loop_proc[@current_pos]
- @current_pos += 1
- @current_proc = cmd
-
- set_callback(sleep, cmd_args)
- end
-
- def initialize(*args)
- @id = Tk_CBID.join
- Tk_CBID[1].succ!
-
- @wait_var = TkVariable.new(0)
-
- @cb_cmd = TkCore::INTERP.get_cb_entry(self.method(:do_callback))
-
- @set_next = true
-
- @init_sleep = 0
- @init_proc = nil
- @init_args = []
-
- @current_script = []
- @current_proc = nil
- @current_args = nil
- @return_value = nil
-
- @sleep_time = 0
- @current_sleep = 0
- @loop_exec = 0
- @do_loop = 0
- @loop_proc = []
- @proc_max = 0
- @current_pos = 0
-
- @after_id = nil
- @after_script = nil
-
- @cancel_on_exception = true
-
- set_procs(*args) if args != []
-
- @running = false
- @in_callback = false
- end
-
- attr :after_id
- attr :after_script
- attr :current_proc
- attr :current_args
- attr :current_sleep
- alias :current_interval :current_sleep
- attr :return_value
-
- attr_accessor :loop_exec
-
- def cb_call
- @cb_cmd.call
- end
-
- def get_procs
- [@init_sleep, @init_proc, @init_args, @sleep_time, @loop_exec, @loop_proc]
- end
-
- def current_status
- [@running, @current_sleep, @current_proc, @current_args,
- @do_loop, @cancel_on_exception]
- end
-
- def cancel_on_exception?
- @cancel_on_exception
- end
-
- def cancel_on_exception=(mode)
- @cancel_on_exception = mode
- self
- end
-
- def running?
- @running
- end
-
- def loop_rest
- @do_loop
- end
-
- def loop_rest=(rest)
- @do_loop = rest
- self
- end
-
- def set_procs(interval, loop_exec, *procs)
- if !interval == 'idle' \
- && !interval.kind_of?(Integer) && !interval.kind_of?(Proc)
- fail Kernel.format("%s need to be Integer or Proc", interval.inspect)
- end
- @sleep_time = interval
-
- @loop_proc = []
- procs.each{|e|
- if e.kind_of? Proc
- @loop_proc.push([e])
- else
- @loop_proc.push(e)
- end
- }
- @proc_max = @loop_proc.size
- @current_pos = 0
-
- @do_loop = 0
- if loop_exec
- if loop_exec.kind_of?(Integer) && loop_exec < 0
- @loop_exec = -1
- elsif loop_exec == nil || loop_exec == false || loop_exec == 0
- @loop_exec = 1
- else
- if not loop_exec.kind_of?(Integer)
- fail Kernel.format("%s need to be Integer", loop_exec.inspect)
- end
- @loop_exec = loop_exec
- end
- @do_loop = @loop_exec
- end
-
- self
- end
-
- def add_procs(*procs)
- procs.each{|e|
- if e.kind_of? Proc
- @loop_proc.push([e])
- else
- @loop_proc.push(e)
- end
- }
- @proc_max = @loop_proc.size
-
- self
- end
-
- def delete_procs(*procs)
- procs.each{|e|
- if e.kind_of? Proc
- @loop_proc.delete([e])
- else
- @loop_proc.delete(e)
- end
- }
- @proc_max = @loop_proc.size
-
- cancel if @proc_max == 0
-
- self
- end
-
- def delete_at(n)
- @loop_proc.delete_at(n)
- @proc_max = @loop_proc.size
- cancel if @proc_max == 0
- self
- end
-
- def set_start_proc(sleep, init_proc, *init_args)
- if !sleep == 'idle' && !sleep.kind_of?(Integer)
- fail Kernel.format("%s need to be Integer", sleep.inspect)
- end
- @init_sleep = sleep
- @init_proc = init_proc
- @init_args = init_args
- self
- end
-
- def start(*init_args)
- return nil if @running
-
- Tk_CBTBL[@id] = self
- @do_loop = @loop_exec
- @current_pos = 0
-
- argc = init_args.size
- if argc > 0
- sleep = init_args.shift
- if !sleep == 'idle' && !sleep.kind_of?(Integer)
- fail Kernel.format("%s need to be Integer", sleep.inspect)
- end
- @init_sleep = sleep
- end
- @init_proc = init_args.shift if argc > 1
- @init_args = init_args if argc > 0
-
- @current_sleep = @init_sleep
- @running = true
- if @init_proc
- if not @init_proc.kind_of? Proc
- fail Kernel.format("%s need to be Proc", @init_proc.inspect)
- end
- @current_proc = @init_proc
- set_callback(@init_sleep, @init_args)
- @set_next = false if @in_callback
- else
- set_next_callback(@init_args)
- end
-
- self
- end
-
- def reset(*reset_args)
- restart() if @running
-
- if @init_proc
- @return_value = @init_proc.call(self)
- else
- @return_value = nil
- end
-
- @current_pos = 0
- @current_args = @init_args
- @set_next = false if @in_callback
-
- self
- end
-
- def restart(*restart_args)
- cancel if @running
- if restart_args == []
- start(@init_sleep, @init_proc, *@init_args)
- else
- start(*restart_args)
- end
- end
-
- def cancel
- @running = false
- @wait_var.value = 0
- tk_call 'after', 'cancel', @after_id if @after_id
- @after_id = nil
- Tk_CBTBL.delete(@id) ;# for GC
- self
- end
- alias stop cancel
-
- def continue(wait=nil)
- fail RuntimeError, "is already running" if @running
- sleep, cmd = @current_script
- fail RuntimeError, "no procedure to continue" unless cmd
- if wait
- if not wait.kind_of? Integer
- fail RuntimeError, Kernel.format("%s need to be Integer", wait.inspect)
- end
- sleep = wait
- end
- Tk_CBTBL[@id] = self
- @running = true
- @after_id = tk_call('after', sleep, cmd)
- self
- end
-
- def skip
- fail RuntimeError, "is not running now" unless @running
- cancel
- Tk_CBTBL[@id] = self
- @running = true
- set_next_callback(@current_args)
- self
- end
-
- def info
- if @after_id
- inf = tk_split_list(tk_call('after', 'info', @after_id))
- [Tk_CBTBL[inf[0][1]], inf[1]]
- else
- nil
- end
- end
-
- def wait(on_thread = true, check_root = false)
- if $SAFE >= 4
- fail SecurityError, "can't wait timer at $SAFE >= 4"
- end
-
- unless @running
- if @return_value.kind_of?(Exception)
- fail @return_value
- else
- return @return_value
- end
- end
-
- @wait_var.wait(on_thread, check_root)
- if @return_value.kind_of?(Exception)
- fail @return_value
- else
- @return_value
- end
- end
- def eventloop_wait(check_root = false)
- wait(false, check_root)
- end
- def thread_wait(check_root = false)
- wait(true, check_root)
- end
- def tkwait(on_thread = true)
- wait(on_thread, true)
- end
- def eventloop_tkwait
- wait(false, true)
- end
- def thread_tkwait
- wait(true, true)
- end
-end
-
-TkAfter = TkTimer
diff --git a/ext/tk/lib/tkbgerror.rb b/ext/tk/lib/tkbgerror.rb
deleted file mode 100644
index 760a3901b3..0000000000
--- a/ext/tk/lib/tkbgerror.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-#
-# tkbgerror -- bgerror ( tkerror ) module
-# 1998/07/16 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
-#
-require 'tk'
-
-module TkBgError
- extend Tk
-
- TkCommandNames = ['bgerror'.freeze].freeze
-
- def bgerror(message)
- tk_call 'bgerror', message
- end
- alias tkerror bgerror
- alias show bgerror
- module_function :bgerror, :tkerror, :show
-
- def set_handler(hdlr = Proc.new) #==> handler :: proc{|msg| ...body... }
- tk_call('proc', 'bgerror', 'msg', install_cmd(hdlr) + ' $msg')
- end
- def set_default
- begin
- tk_call('rename', 'bgerror', '')
- rescue RuntimeError
- end
- end
- module_function :set_handler, :set_default
-end
diff --git a/ext/tk/lib/tkcanvas.rb b/ext/tk/lib/tkcanvas.rb
deleted file mode 100644
index 32b5ac7af8..0000000000
--- a/ext/tk/lib/tkcanvas.rb
+++ /dev/null
@@ -1,1014 +0,0 @@
-#
-# tkcanvas.rb - Tk canvas classes
-# $Date$
-# by Yukihiro Matsumoto <matz@caelum.co.jp>
-# $Date$
-# by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
-
-require "tk"
-require 'tkfont'
-
-module TkTreatCItemFont
- include TkTreatItemFont
-
- ItemCMD = ['itemconfigure'.freeze, TkComm::None].freeze
- def __conf_cmd(idx)
- ItemCMD[idx]
- end
-
- def __item_pathname(tagOrId)
- if tagOrId.kind_of?(TkcItem) || tagOrId.kind_of?(TkcTag)
- self.path + ';' + tagOrId.id.to_s
- else
- self.path + ';' + tagOrId.to_s
- end
- end
-
- private :__conf_cmd, :__item_pathname
-end
-
-class TkCanvas<TkWindow
- include TkTreatCItemFont
- include Scrollable
-
- TkCommandNames = ['canvas'.freeze].freeze
- WidgetClassName = 'Canvas'.freeze
- WidgetClassNames[WidgetClassName] = self
-
- def __destroy_hook__
- TkcItem::CItemID_TBL.delete(@path)
- end
-
- def create_self(keys)
- if keys and keys != None
- tk_call 'canvas', @path, *hash_kv(keys)
- else
- tk_call 'canvas', @path
- end
- end
- private :create_self
-
- def tagid(tag)
- if tag.kind_of?(TkcItem) || tag.kind_of?(TkcTag)
- tag.id
- else
- tag
- end
- end
- private :tagid
-
- def addtag(tag, mode, *args)
- tk_send 'addtag', tagid(tag), mode, *args
- self
- end
- def addtag_above(tagOrId, target)
- addtag(tagOrId, 'above', tagid(target))
- end
- def addtag_all(tagOrId)
- addtag(tagOrId, 'all')
- end
- def addtag_below(tagOrId, target)
- addtag(tagOrId, 'below', tagid(target))
- end
- def addtag_closest(tagOrId, x, y, halo=None, start=None)
- addtag(tagOrId, 'closest', x, y, halo, start)
- end
- def addtag_enclosed(tagOrId, x1, y1, x2, y2)
- addtag(tagOrId, 'enclosed', x1, y1, x2, y2)
- end
- def addtag_overlapping(tagOrId, x1, y1, x2, y2)
- addtag(tagOrId, 'overlapping', x1, y1, x2, y2)
- end
- def addtag_withtag(tagOrId, tag)
- addtag(tagOrId, 'withtag', tagid(tag))
- end
-
- def bbox(tagOrId, *tags)
- list(tk_send('bbox', tagid(tagOrId), *tags.collect{|t| tagid(t)}))
- end
-
- def itembind(tag, context, cmd=Proc.new, args=nil)
- _bind([path, "bind", tagid(tag)], context, cmd, args)
- self
- end
-
- def itembind_append(tag, context, cmd=Proc.new, args=nil)
- _bind_append([path, "bind", tagid(tag)], context, cmd, args)
- self
- end
-
- def itembind_remove(tag, context)
- _bind_remove([path, "bind", tagid(tag)], context)
- self
- end
-
- def itembindinfo(tag, context=nil)
- _bindinfo([path, "bind", tagid(tag)], context)
- end
-
- def canvasx(x, *args)
- tk_tcl2ruby(tk_send('canvasx', x, *args))
- end
- def canvasy(y, *args)
- tk_tcl2ruby(tk_send('canvasy', y, *args))
- end
-
- def coords(tag, *args)
- if args == []
- tk_split_list(tk_send('coords', tagid(tag)))
- else
- tk_send('coords', tagid(tag), *(args.flatten))
- end
- end
-
- def dchars(tag, first, last=None)
- tk_send 'dchars', tagid(tag), first, last
- self
- end
-
- def delete(*args)
- if TkcItem::CItemID_TBL[self.path]
- find('withtag', *args).each{|item|
- TkcItem::CItemID_TBL[self.path].delete(item.id)
- }
- end
- tk_send 'delete', *args.collect{|t| tagid(t)}
- self
- end
- alias remove delete
-
- def dtag(tag, tag_to_del=None)
- tk_send 'dtag', tagid(tag), tag_to_del
- self
- end
-
- def find(mode, *args)
- list(tk_send('find', mode, *args)).collect!{|id|
- TkcItem.id2obj(self, id)
- }
- end
- def find_above(target)
- find('above', tagid(target))
- end
- def find_all
- find('all')
- end
- def find_below(target)
- find('below', tagid(target))
- end
- def find_closest(x, y, halo=None, start=None)
- find('closest', x, y, halo, start)
- end
- def find_enclosed(x1, y1, x2, y2)
- find('enclosed', x1, y1, x2, y2)
- end
- def find_overlapping(x1, y1, x2, y2)
- find('overlapping', x1, y1, x2, y2)
- end
- def find_withtag(tag)
- find('withtag', tag)
- end
-
- def itemfocus(tagOrId=nil)
- if tagOrId
- tk_send 'focus', tagid(tagOrId)
- self
- else
- ret = tk_send('focus')
- if ret == ""
- nil
- else
- TkcItem.id2obj(self, ret)
- end
- end
- end
-
- def gettags(tagOrId)
- list(tk_send('gettags', tagid(tagOrId))).collect{|tag|
- TkcTag.id2obj(self, tag)
- }
- end
-
- def icursor(tagOrId, index)
- tk_send 'icursor', tagid(tagOrId), index
- self
- end
-
- def index(tagOrId, index)
- number(tk_send('index', tagid(tagOrId), index))
- end
-
- def insert(tagOrId, index, string)
- tk_send 'insert', tagid(tagOrId), index, string
- self
- end
-
- def itemcget(tagOrId, option)
- case option.to_s
- when 'dash', 'activedash', 'disableddash'
- conf = tk_send('itemcget', tagid(tagOrId), "-#{option}")
- if conf =~ /^[0-9]/
- list(conf)
- else
- conf
- end
- when 'text', 'label', 'show', 'data', 'file', 'maskdata', 'maskfile'
- tk_send 'itemcget', tagid(tagOrId), "-#{option}"
- when 'font', 'kanjifont'
- #fnt = tk_tcl2ruby(tk_send('itemcget', tagid(tagOrId), "-#{option}"))
- fnt = tk_tcl2ruby(tk_send('itemcget', tagid(tagOrId), '-font'))
- unless fnt.kind_of?(TkFont)
- fnt = tagfontobj(tagid(tagOrId), fnt)
- end
- if option.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
- # obsolete; just for compatibility
- fnt.kanji_font
- else
- fnt
- end
- else
- tk_tcl2ruby tk_send('itemcget', tagid(tagOrId), "-#{option}")
- end
- end
-
- def itemconfigure(tagOrId, key, value=None)
- if key.kind_of? Hash
- key = _symbolkey2str(key)
- if ( key['font'] || key['kanjifont'] \
- || key['latinfont'] || key['asciifont'] )
- tagfont_configure(tagid(tagOrId), key.dup)
- else
- tk_send 'itemconfigure', tagid(tagOrId), *hash_kv(key)
- end
-
- else
- if ( key == 'font' || key == :font ||
- key == 'kanjifont' || key == :kanjifont ||
- key == 'latinfont' || key == :latinfont ||
- key == 'asciifont' || key == :asciifont )
- if value == None
- tagfontobj(tagid(tagOrId))
- else
- tagfont_configure(tagid(tagOrId), {key=>value})
- end
- else
- tk_send 'itemconfigure', tagid(tagOrId), "-#{key}", value
- end
- end
- self
- end
-# def itemconfigure(tagOrId, key, value=None)
-# if key.kind_of? Hash
-# tk_send 'itemconfigure', tagid(tagOrId), *hash_kv(key)
-# else
-# tk_send 'itemconfigure', tagid(tagOrId), "-#{key}", value
-# end
-# end
-# def itemconfigure(tagOrId, keys)
-# tk_send 'itemconfigure', tagid(tagOrId), *hash_kv(keys)
-# end
-
- def itemconfiginfo(tagOrId, key=nil)
- if key
- case key.to_s
- when 'dash', 'activedash', 'disableddash'
- conf = tk_split_simplelist(tk_send('itemconfigure',
- tagid(tagOrId), "-#{key}"))
- if conf[3] && conf[3] =~ /^[0-9]/
- conf[3] = list(conf[3])
- end
- if conf[4] && conf[4] =~ /^[0-9]/
- conf[4] = list(conf[4])
- end
- when 'text', 'label', 'show', 'data', 'file', 'maskdata', 'maskfile'
- conf = tk_split_simplelist(tk_send('itemconfigure',
- tagid(tagOrId), "-#{key}"))
- when 'font', 'kanjifont'
- conf = tk_split_simplelist(tk_send('itemconfigure',
- tagid(tagOrId),"-#{key}") )
- conf[4] = tagfont_configinfo(tagid(tagOrId), conf[4])
- else
- conf = tk_split_list(tk_send('itemconfigure',
- tagid(tagOrId), "-#{key}"))
- end
- conf[0] = conf[0][1..-1]
- conf
- else
- ret = tk_split_simplelist(tk_send('itemconfigure',
- tagid(tagOrId))).collect{|conflist|
- conf = tk_split_simplelist(conflist)
- conf[0] = conf[0][1..-1]
- case conf[0]
- when 'text', 'label', 'show', 'data', 'file', 'maskdata', 'maskfile'
- when 'dash', 'activedash', 'disableddash'
- if conf[3] && conf[3] =~ /^[0-9]/
- conf[3] = list(conf[3])
- end
- if conf[4] && conf[4] =~ /^[0-9]/
- conf[4] = list(conf[4])
- end
- else
- if conf[3]
- if conf[3].index('{')
- conf[3] = tk_split_list(conf[3])
- else
- conf[3] = tk_tcl2ruby(conf[3])
- end
- end
- if conf[4]
- if conf[4].index('{')
- conf[4] = tk_split_list(conf[4])
- else
- conf[4] = tk_tcl2ruby(conf[4])
- end
- end
- end
- conf
- }
- fontconf = ret.assoc('font')
- if fontconf
- ret.delete_if{|item| item[0] == 'font' || item[0] == 'kanjifont'}
- fontconf[4] = tagfont_configinfo(tagid(tagOrId), fontconf[4])
- ret.push(fontconf)
- else
- ret
- end
- end
- end
-
- def lower(tag, below=None)
- tk_send 'lower', tagid(tag), tagid(below)
- self
- end
-
- def move(tag, x, y)
- tk_send 'move', tagid(tag), x, y
- self
- end
-
- def postscript(keys)
- tk_send "postscript", *hash_kv(keys)
- end
-
- def raise(tag, above=None)
- tk_send 'raise', tagid(tag), tagid(above)
- self
- end
-
- def scale(tag, x, y, xs, ys)
- tk_send 'scale', tagid(tag), x, y, xs, ys
- self
- end
-
- def scan_mark(x, y)
- tk_send 'scan', 'mark', x, y
- self
- end
- def scan_dragto(x, y)
- tk_send 'scan', 'dragto', x, y
- self
- end
-
- def select(mode, *args)
- r = tk_send('select', mode, *args)
- (mode == 'item')? TkcItem.id2obj(self, r): self
- end
- def select_adjust(tagOrId, index)
- select('adjust', tagid(tagOrId), index)
- end
- def select_clear
- select('clear')
- end
- def select_from(tagOrId, index)
- select('from', tagid(tagOrId), index)
- end
- def select_item
- select('item')
- end
- def select_to(tagOrId, index)
- select('to', tagid(tagOrId), index)
- end
-
- def itemtype(tag)
- TkcItem.type2class(tk_send('type', tagid(tag)))
- end
-end
-
-module TkcTagAccess
- include TkComm
- include TkTreatTagFont
-
- def addtag(tag)
- @c.addtag(tag, 'with', @id)
- self
- end
-
- def bbox
- @c.bbox(@id)
- end
-
- def bind(seq, cmd=Proc.new, args=nil)
- @c.itembind @id, seq, cmd, args
- self
- end
-
- def bind_append(seq, cmd=Proc.new, args=nil)
- @c.itembind_append @id, seq, cmd, args
- self
- end
-
- def bind_remove(seq)
- @c.itembind_remove @id, seq
- self
- end
-
- def bindinfo(seq=nil)
- @c.itembindinfo @id, seq
- end
-
- def cget(option)
- @c.itemcget @id, option
- end
-
- def configure(key, value=None)
- @c.itemconfigure @id, key, value
- self
- end
-# def configure(keys)
-# @c.itemconfigure @id, keys
-# end
-
- def configinfo(key=nil)
- @c.itemconfiginfo @id, key
- end
-
- def coords(*args)
- @c.coords @id, *args
- end
-
- def dchars(first, last=None)
- @c.dchars @id, first, last
- self
- end
-
- def dtag(tag_to_del=None)
- @c.dtag @id, tag_to_del
- self
- end
-
- def find
- @c.find 'withtag', @id
- end
- alias list find
-
- def focus
- @c.itemfocus @id
- end
-
- def gettags
- @c.gettags @id
- end
-
- def icursor(index)
- @c.icursor @id, index
- self
- end
-
- def index(index)
- @c.index @id, index
- end
-
- def insert(beforethis, string)
- @c.insert @id, beforethis, string
- self
- end
-
- def lower(belowthis=None)
- @c.lower @id, belowthis
- self
- end
-
- def move(xamount, yamount)
- @c.move @id, xamount, yamount
- self
- end
-
- def raise(abovethis=None)
- @c.raise @id, abovethis
- self
- end
-
- def scale(xorigin, yorigin, xscale, yscale)
- @c.scale @id, xorigin, yorigin, xscale, yscale
- self
- end
-
- def select_adjust(index)
- @c.select('adjust', @id, index)
- self
- end
- def select_from(index)
- @c.select('from', @id, index)
- self
- end
- def select_to(index)
- @c.select('to', @id, index)
- self
- end
-
- def itemtype
- @c.itemtype @id
- end
-
- # Following operators support logical expressions of canvas tags
- # (for Tk8.3+).
- # If tag1.path is 't1' and tag2.path is 't2', then
- # ltag = tag1 & tag2; ltag.path => "(t1)&&(t2)"
- # ltag = tag1 | tag2; ltag.path => "(t1)||(t2)"
- # ltag = tag1 ^ tag2; ltag.path => "(t1)^(t2)"
- # ltag = - tag1; ltag.path => "!(t1)"
- def & (tag)
- if tag.kind_of? TkObject
- TkcTagString.new(@c, '(' + @id + ')&&(' + tag.path + ')')
- else
- TkcTagString.new(@c, '(' + @id + ')&&(' + tag.to_s + ')')
- end
- end
-
- def | (tag)
- if tag.kind_of? TkObject
- TkcTagString.new(@c, '(' + @id + ')||(' + tag.path + ')')
- else
- TkcTagString.new(@c, '(' + @id + ')||(' + tag.to_s + ')')
- end
- end
-
- def ^ (tag)
- if tag.kind_of? TkObject
- TkcTagString.new(@c, '(' + @id + ')^(' + tag.path + ')')
- else
- TkcTagString.new(@c, '(' + @id + ')^(' + tag.to_s + ')')
- end
- end
-
- def -@
- TkcTagString.new(@c, '!(' + @id + ')')
- end
-end
-
-class TkcTag<TkObject
- include TkcTagAccess
-
- CTagID_TBL = TkCore::INTERP.create_table
- Tk_CanvasTag_ID = ['ctag'.freeze, '00000'.taint].freeze
-
- TkCore::INTERP.init_ip_env{ CTagID_TBL.clear }
-
- def TkcTag.id2obj(canvas, id)
- cpath = canvas.path
- return id unless CTagID_TBL[cpath]
- CTagID_TBL[cpath][id]? CTagID_TBL[cpath][id]: id
- end
-
- def initialize(parent, mode=nil, *args)
- if not parent.kind_of?(TkCanvas)
- fail Kernel.format("%s need to be TkCanvas", parent.inspect)
- end
- @c = parent
- @cpath = parent.path
- @path = @id = Tk_CanvasTag_ID.join
- CTagID_TBL[@cpath] = {} unless CTagID_TBL[@cpath]
- CTagID_TBL[@cpath][@id] = self
- Tk_CanvasTag_ID[1].succ!
- if mode
- tk_call @c.path, "addtag", @id, mode, *args
- end
- end
- def id
- @id
- end
-
- def delete
- @c.delete @id
- CTagID_TBL[@cpath].delete(@id) if CTagID_TBL[@cpath]
- self
- end
- alias remove delete
- alias destroy delete
-
- def set_to_above(target)
- @c.addtag_above(@id, target)
- self
- end
- alias above set_to_above
-
- def set_to_all
- @c.addtag_all(@id)
- self
- end
- alias all set_to_all
-
- def set_to_below(target)
- @c.addtag_below(@id, target)
- self
- end
- alias below set_to_below
-
- def set_to_closest(x, y, halo=None, start=None)
- @c.addtag_closest(@id, x, y, halo, start)
- self
- end
- alias closest set_to_closest
-
- def set_to_enclosed(x1, y1, x2, y2)
- @c.addtag_enclosed(@id, x1, y1, x2, y2)
- self
- end
- alias enclosed set_to_enclosed
-
- def set_to_overlapping(x1, y1, x2, y2)
- @c.addtag_overlapping(@id, x1, y1, x2, y2)
- self
- end
- alias overlapping set_to_overlapping
-
- def set_to_withtag(target)
- @c.addtag_withtag(@id, target)
- self
- end
- alias withtag set_to_withtag
-end
-
-class TkcTagString<TkcTag
- def self.new(parent, name, *args)
- if CTagID_TBL[parent.path] && CTagID_TBL[parent.path][name]
- return CTagID_TBL[parent.path][name]
- else
- super(parent, name, *args)
- end
- end
-
- def initialize(parent, name, mode=nil, *args)
- if not parent.kind_of?(TkCanvas)
- fail Kernel.format("%s need to be TkCanvas", parent.inspect)
- end
- @c = parent
- @cpath = parent.path
- @path = @id = name
- CTagID_TBL[@cpath] = {} unless CTagID_TBL[@cpath]
- CTagID_TBL[@cpath][@id] = self
- if mode
- tk_call @c.path, "addtag", @id, mode, *args
- end
- end
-end
-TkcNamedTag = TkcTagString
-
-class TkcTagAll<TkcTag
- def initialize(parent)
- if not parent.kind_of?(TkCanvas)
- fail Kernel.format("%s need to be TkCanvas", parent.inspect)
- end
- @c = parent
- @cpath = parent.path
- @path = @id = 'all'
- CTagID_TBL[@cpath] = {} unless CTagID_TBL[@cpath]
- CTagID_TBL[@cpath][@id] = self
- end
-end
-
-class TkcTagCurrent<TkcTag
- def initialize(parent)
- if not parent.kind_of?(TkCanvas)
- fail Kernel.format("%s need to be TkCanvas", parent.inspect)
- end
- @c = parent
- @cpath = parent.path
- @path = @id = 'current'
- CTagID_TBL[@cpath] = {} unless CTagID_TBL[@cpath]
- CTagID_TBL[@cpath][@id] = self
- end
-end
-
-class TkcGroup<TkcTag
- Tk_cGroup_ID = ['tkcg'.freeze, '00000'.taint].freeze
- def create_self(parent, *args)
- if not parent.kind_of?(TkCanvas)
- fail Kernel.format("%s need to be TkCanvas", parent.inspect)
- end
- @c = parent
- @cpath = parent.path
- @path = @id = Tk_cGroup_ID.join
- CTagID_TBL[@cpath] = {} unless CTagID_TBL[@cpath]
- CTagID_TBL[@cpath][@id] = self
- Tk_cGroup_ID[1].succ!
- add(*args) if args != []
- end
- private :create_self
-
- def include(*tags)
- for i in tags
- i.addtag @id
- end
- self
- end
-
- def exclude(*tags)
- for i in tags
- i.delete @id
- end
- self
- end
-end
-
-class TkcItem<TkObject
- include TkcTagAccess
-
- CItemTypeToClass = {}
- CItemID_TBL = TkCore::INTERP.create_table
-
- TkCore::INTERP.init_ip_env{ CItemID_TBL.clear }
-
- def TkcItem.type2class(type)
- CItemTypeToClass[type]
- end
-
- def TkcItem.id2obj(canvas, id)
- cpath = canvas.path
- return id unless CItemID_TBL[cpath]
- CItemID_TBL[cpath][id]? CItemID_TBL[cpath][id]: id
- end
-
- def initialize(parent, *args)
- if not parent.kind_of?(TkCanvas)
- fail Kernel.format("%s need to be TkCanvas", parent.inspect)
- end
- @parent = @c = parent
- @path = parent.path
- fontkeys = {}
- if args.size == 1 && args[0].kind_of?(Hash)
- args[0] = _symbolkey2str(args[0])
- coords = args[0].delete('coords')
- if not coords.kind_of?(Array)
- fail "coords parameter must be given by an Array"
- end
- args[0,0] = coords.flatten
- end
- if args[-1].kind_of? Hash
- keys = _symbolkey2str(args.pop)
- ['font', 'kanjifont', 'latinfont', 'asciifont'].each{|key|
- fontkeys[key] = keys.delete(key) if keys.key?(key)
- }
- args += hash_kv(keys)
- end
- @id = create_self(*args).to_i ;# 'canvas item id' is integer number
- CItemID_TBL[@path] = {} unless CItemID_TBL[@path]
- CItemID_TBL[@path][@id] = self
- configure(fontkeys) unless fontkeys.empty?
-
-######## old version
-# if args[-1].kind_of? Hash
-# keys = args.pop
-# end
-# @id = create_self(*args).to_i ;# 'canvas item id' is integer number
-# CItemID_TBL[@path] = {} unless CItemID_TBL[@path]
-# CItemID_TBL[@path][@id] = self
-# if keys
-# # tk_call @path, 'itemconfigure', @id, *hash_kv(keys)
-# configure(keys) if keys
-# end
-########
- end
- def create_self(*args); end
- private :create_self
-
- def id
- @id
- end
-
- def delete
- @c.delete @id
- CItemID_TBL[@path].delete(@id) if CItemID_TBL[@path]
- self
- end
- alias remove delete
- alias destroy delete
-end
-
-class TkcArc<TkcItem
- CItemTypeToClass['arc'] = self
- def create_self(*args)
- tk_call(@path, 'create', 'arc', *args)
- end
- private :create_self
-end
-
-class TkcBitmap<TkcItem
- CItemTypeToClass['bitmap'] = self
- def create_self(*args)
- tk_call(@path, 'create', 'bitmap', *args)
- end
- private :create_self
-end
-
-class TkcImage<TkcItem
- CItemTypeToClass['image'] = self
- def create_self(*args)
- tk_call(@path, 'create', 'image', *args)
- end
- private :create_self
-end
-
-class TkcLine<TkcItem
- CItemTypeToClass['line'] = self
- def create_self(*args)
- tk_call(@path, 'create', 'line', *args)
- end
- private :create_self
-end
-
-class TkcOval<TkcItem
- CItemTypeToClass['oval'] = self
- def create_self(*args)
- tk_call(@path, 'create', 'oval', *args)
- end
- private :create_self
-end
-
-class TkcPolygon<TkcItem
- CItemTypeToClass['polygon'] = self
- def create_self(*args)
- tk_call(@path, 'create', 'polygon', *args)
- end
- private :create_self
-end
-
-class TkcRectangle<TkcItem
- CItemTypeToClass['rectangle'] = self
- def create_self(*args)
- tk_call(@path, 'create', 'rectangle', *args)
- end
- private :create_self
-end
-
-class TkcText<TkcItem
- CItemTypeToClass['text'] = self
- def create_self(*args)
- tk_call(@path, 'create', 'text', *args)
- end
- private :create_self
-end
-
-class TkcWindow<TkcItem
- CItemTypeToClass['window'] = self
- def create_self(*args)
- tk_call(@path, 'create', 'window', *args)
- end
- private :create_self
-end
-
-class TkImage<TkObject
- include Tk
-
- TkCommandNames = ['image'.freeze].freeze
-
- Tk_IMGTBL = TkCore::INTERP.create_table
- Tk_Image_ID = ['i'.freeze, '00000'.taint].freeze
-
- TkCore::INTERP.init_ip_env{ Tk_IMGTBL.clear }
-
- def initialize(keys=nil)
- @path = Tk_Image_ID.join
- Tk_Image_ID[1].succ!
- tk_call 'image', 'create', @type, @path, *hash_kv(keys)
- Tk_IMGTBL[@path] = self
- end
-
- def delete
- Tk_IMGTBL.delete(@id) if @id
- tk_call('image', 'delete', @path)
- self
- end
- def height
- number(tk_call('image', 'height', @path))
- end
- def inuse
- bool(tk_call('image', 'inuse', @path))
- end
- def itemtype
- tk_call('image', 'type', @path)
- end
- def width
- number(tk_call('image', 'width', @path))
- end
-
- def TkImage.names
- Tk.tk_call('image', 'names').split.collect!{|id|
- (Tk_IMGTBL[id])? Tk_IMGTBL[id] : id
- }
- end
-
- def TkImage.types
- Tk.tk_call('image', 'types').split
- end
-end
-
-class TkBitmapImage<TkImage
- def initialize(*args)
- @type = 'bitmap'
- super
- end
-end
-
-class TkPhotoImage<TkImage
- def initialize(*args)
- @type = 'photo'
- super
- end
-
- def blank
- tk_send 'blank'
- self
- end
-
- def cget(option)
- case option.to_s
- when 'data', 'file'
- tk_send 'cget', option
- else
- tk_tcl2ruby tk_send('cget', option)
- end
- end
-
- def copy(source, *opts)
- args = opts.collect{|term|
- if term.kind_of?(String) && term.include?(?\s)
- term.split
- else
- term
- end
- }.flatten
-
- tk_send 'copy', source, *args
-
- self
- end
-
- def data(keys=nil)
- tk_send('data', *hash_kv(keys))
- end
-
- def get(x, y)
- tk_send('get', x, y).split.collect{|n| n.to_i}
- end
-
- def put(data, *to)
- if to == []
- tk_send 'put', data
- else
- tk_send 'put', data, '-to', *to
- end
- self
- end
-
- def read(file, *opts)
- args = opts.collect{|term|
- if term.kind_of?(String) && term.include?(?\s)
- term.split
- else
- term
- end
- }.flatten
-
- tk_send 'read', file, *args
-
- self
- end
-
- def redither
- tk_send 'redither'
- self
- end
-
- def get_transparency(x, y)
- bool(tk_send('transparency', 'get', x, y))
- end
- def set_transparency(x, y, st)
- tk_send('transparency', 'set', x, y, st)
- self
- end
-
- def write(file, *opts)
- args = opts.collect{|term|
- if term.kind_of?(String) && term.include?(?\s)
- term.split
- else
- term
- end
- }.flatten
-
- tk_send 'write', file, *args
-
- self
- end
-end
diff --git a/ext/tk/lib/tkclass.rb b/ext/tk/lib/tkclass.rb
deleted file mode 100644
index 9ea275e560..0000000000
--- a/ext/tk/lib/tkclass.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-#
-# tkclass.rb - Tk classes
-# Date: 2000/11/27 09:23:36
-# by Yukihiro Matsumoto <matz@caelum.co.jp>
-#
-# $Id$
-
-require "tk"
-
-TopLevel = TkToplevel
-Frame = TkFrame
-Label = TkLabel
-Button = TkButton
-Radiobutton = TkRadioButton
-Checkbutton = TkCheckButton
-Message = TkMessage
-Entry = TkEntry
-Spinbox = TkSpinbox
-Text = TkText
-Scale = TkScale
-Scrollbar = TkScrollbar
-Listbox = TkListbox
-Menu = TkMenu
-Menubutton = TkMenubutton
-Canvas = TkCanvas
-Arc = TkcArc
-Bitmap = TkcBitmap
-Line = TkcLine
-Oval = TkcOval
-Polygon = TkcPolygon
-Rectangle = TkcRectangle
-TextItem = TkcText
-WindowItem = TkcWindow
-BitmapImage = TkBitmapImage
-PhotoImage = TkPhotoImage
-Selection = TkSelection
-Winfo = TkWinfo
-Pack = TkPack
-Grid = TkGrid
-Place = TkPlace
-Variable = TkVariable
-Font = TkFont
-VirtualEvent = TkVirtualEvent
-
-def Mainloop
- Tk.mainloop
-end
diff --git a/ext/tk/lib/tkconsole.rb b/ext/tk/lib/tkconsole.rb
deleted file mode 100644
index d97df159fc..0000000000
--- a/ext/tk/lib/tkconsole.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-#
-# tkconsole.rb : control the console on system without a real console
-#
-require 'tk'
-
-module TkConsole
- include Tk
- extend Tk
-
- TkCommandNames = ['console'.freeze].freeze
-
- def self.title(str=None)
- tk_call 'console', str
- end
- def self.hide
- tk_call 'console', 'hide'
- end
- def self.show
- tk_call 'console', 'show'
- end
- def self.eval(tcl_script)
- #
- # supports a Tcl script only
- # I have no idea to support a Ruby script seamlessly.
- #
- tk_call 'console', 'eval', tcl_script
- end
-end
diff --git a/ext/tk/lib/tkdialog.rb b/ext/tk/lib/tkdialog.rb
deleted file mode 100644
index a581f3becc..0000000000
--- a/ext/tk/lib/tkdialog.rb
+++ /dev/null
@@ -1,276 +0,0 @@
-require "tk"
-
-class TkDialog2 < TkWindow
- extend Tk
-
- TkCommandNames = ['tk_dialog'.freeze].freeze
-
- def self.show(*args)
- dlog = self.new(*args)
- dlog.show
- dlog
- end
-
- def _set_button_config(configs)
- set_config = proc{|c,i|
- if $VERBOSE && (c.has_key?('command') || c.has_key?(:command))
- STDERR.print("Warning: cannot give a command option " +
- "to the dialog button#{i}. It was removed.\n")
- end
- c.delete('command'); c.delete(:command)
- @config << Kernel.format("%s.button%s configure %s; ",
- @path, i, hash_kv(c).join(' '))
- }
- case configs
- when Proc
- @buttons.each_index{|i|
- if (c = configs.call(i)).kind_of? Hash
- set_config.call(c,i)
- end
- }
-
- when Array
- @buttons.each_index{|i|
- if (c = configs[i]).kind_of? Hash
- set_config.call(c,i)
- end
- }
-
- when Hash
- @buttons.each_with_index{|s,i|
- if (c = configs[s]).kind_of? Hash
- set_config.call(c,i)
- end
- }
- end
- @config = 'after idle {' + @config + '};' if @config != ""
- end
- private :_set_button_config
-
- # initialize tk_dialog
- def create_self(keys)
- @var = TkVariable.new
-
- @title = title
-
- @message = message
- @message_config = message_config
- @msgframe_config = msgframe_config
-
- @bitmap = bitmap
- @bitmap_config = message_config
-
- @default_button = default_button
-
- @buttons = buttons
- @button_configs = proc{|num| button_configs(num)}
- @btnframe_config = btnframe_config
-
- #@config = "puts [winfo children .w0000];"
- @config = ""
-
- @command = nil
-
- if keys.kind_of? Hash
- @title = keys['title'] if keys.key? 'title'
- @message = keys['message'] if keys.key? 'message'
- @bitmap = keys['bitmap'] if keys.key? 'bitmap'
- @bitmap = '{}' if @bitmap == nil || @bitmap == ""
- @default_button = keys['default'] if keys.key? 'default'
- @buttons = keys['buttons'] if keys.key? 'buttons'
-
- @command = keys['prev_command']
-
- @message_config = keys['message_config'] if keys.key? 'message_config'
- @msgframe_config = keys['msgframe_config'] if keys.key? 'msgframe_config'
- @bitmap_config = keys['bitmap_config'] if keys.key? 'bitmap_config'
- @button_configs = keys['button_configs'] if keys.key? 'button_configs'
- @btnframe_config = keys['btnframe_config'] if keys.key? 'btnframe_config'
- end
-
- if @title.include? ?\s
- @title = '{' + @title + '}'
- end
-
- if @buttons.kind_of? Array
- _set_button_config(@buttons.collect{|cfg|
- (cfg.kind_of? Array)? cfg[1]: nil})
- @buttons = @buttons.collect{|cfg| (cfg.kind_of? Array)? cfg[0]: cfg}
- end
- if @buttons.kind_of? Hash
- _set_button_config(@buttons)
- @buttons = @buttons.keys
- end
- @buttons = tk_split_simplelist(@buttons) if @buttons.kind_of? String
- @buttons = @buttons.collect{|s|
- if s.kind_of? Array
- s = s.join(' ')
- end
- if s.include? ?\s
- '{' + s + '}'
- else
- s
- end
- }
-
- if @message_config.kind_of? Hash
- @config << Kernel.format("%s.msg configure %s;",
- @path, hash_kv(@message_config).join(' '))
- end
-
- if @msgframe_config.kind_of? Hash
- @config << Kernel.format("%s.top configure %s;",
- @path, hash_kv(@msgframe_config).join(' '))
- end
-
- if @btnframe_config.kind_of? Hash
- @config << Kernel.format("%s.bot configure %s;",
- @path, hash_kv(@btnframe_config).join(' '))
- end
-
- if @bitmap_config.kind_of? Hash
- @config << Kernel.format("%s.bitmap configure %s;",
- @path, hash_kv(@bitmap_config).join(' '))
- end
-
- _set_button_config(@button_configs) if @button_configs
-
- if @command.kind_of? Proc
- @command.call(self)
- end
- end
- private :create_self
-
- def show
- if @default_button.kind_of? String
- default_button = @buttons.index(@default_button)
- else
- default_button = @default_button
- end
- default_button = '{}' if default_button == nil
- Tk.ip_eval('eval {global '+@var.id+';'+@config+
- 'set '+@var.id+' [tk_dialog '+
- @path+" "+@title+" {#{@message}} "+@bitmap+" "+
- String(default_button)+" "+@buttons.join(' ')+']}')
- end
-
- def value
- return @var.value.to_i
- end
- ######################################################
- # #
- # these methods must be overridden for each dialog #
- # #
- ######################################################
- private
-
- def title
- # returns a title string of the dialog window
- return "DIALOG"
- end
- def message
- # returns a message text to display on the dialog
- return "MESSAGE"
- end
- def message_config
- # returns a Hash {option=>value, ...} for the message text
- return nil
- end
- def msgframe_config
- # returns a Hash {option=>value, ...} for the message text frame
- return nil
- end
- def bitmap
- # returns a bitmap name or a bitmap file path
- # (@ + path ; e.g. '@/usr/share/bitmap/sample.xbm')
- return "info"
- end
- def bitmap_config
- # returns nil or a Hash {option=>value, ...} for the bitmap
- return nil
- end
- def default_button
- # returns a default button's number or name
- # if nil or null string, set no-default
- return 0
- end
- def buttons
- #return "BUTTON1 BUTTON2"
- return ["BUTTON1", "BUTTON2"]
- end
- def button_configs(num)
- # returns nil / Proc / Array or Hash (see _set_button_config)
- return nil
- end
- def btnframe_config
- # returns nil or a Hash {option=>value, ...} for the button frame
- return nil
- end
-end
-
-
-#
-# TkDialog : with showing at initialize
-#
-class TkDialog < TkDialog2
- def self.show(*args)
- self.new(*args)
- end
-
- def initialize(*args)
- super(*args)
- show
- end
-end
-
-
-#
-# dialog for warning
-#
-class TkWarning2 < TkDialog2
- def initialize(parent = nil, mes = nil)
- if !mes
- if parent.kind_of? TkWindow
- mes = ""
- else
- mes = parent.to_s
- parent = nil
- end
- end
- super(parent, :message=>mes)
- end
-
- def show(mes = nil)
- mes_bup = @message
- @message = mes if mes
- ret = super()
- @message = mes_bup
- ret
- end
-
- #######
- private
-
- def title
- return "WARNING";
- end
- def bitmap
- return "warning";
- end
- def default_button
- return 0;
- end
- def buttons
- return "OK";
- end
-end
-
-class TkWarning < TkWarning2
- def self.show(*args)
- self.new(*args)
- end
- def initialize(*args)
- super(*args)
- show
- end
-end
diff --git a/ext/tk/lib/tkentry.rb b/ext/tk/lib/tkentry.rb
deleted file mode 100644
index fe9a7b6277..0000000000
--- a/ext/tk/lib/tkentry.rb
+++ /dev/null
@@ -1,292 +0,0 @@
-#
-# tkentry.rb - Tk entry classes
-# $Date$
-# by Yukihiro Matsumoto <matz@caelum.co.jp>
-
-require 'tk.rb'
-
-class TkEntry<TkLabel
- include Scrollable
-
- TkCommandNames = ['entry'.freeze].freeze
- WidgetClassName = 'Entry'.freeze
- WidgetClassNames[WidgetClassName] = self
-
- class ValidateCmd
- include TkComm
-
- module Action
- Insert = 1
- Delete = 0
- Others = -1
- Focus = -1
- Forced = -1
- Textvariable = -1
- TextVariable = -1
- end
-
- class ValidateArgs
- VARG_KEY = 'disvPSVW'
- VARG_TYPE = 'nxeseesw'
-
- def self.scan_args(arg_str, arg_val)
- enc = Tk.encoding
- arg_cnv = []
- arg_str.strip.split(/\s+/).each_with_index{|kwd,idx|
- if kwd =~ /^%(.)$/
- if num = VARG_KEY.index($1)
- case VARG_TYPE[num]
- when ?n
- arg_cnv << TkComm::number(arg_val[idx])
- when ?s
- arg_cnv << TkComm::string(arg_val[idx])
- when ?e
- if enc
- arg_cnv << Tk.fromUTF8(TkComm::string(arg_val[idx]), enc)
- else
- arg_cnv << TkComm::string(arg_val[idx])
- end
- when ?w
- arg_cnv << TkComm::window(arg_val[idx])
- when ?x
- idx = TkComm::number(arg_val[idx])
- if idx < 0
- arg_cnv << nil
- else
- arg_cnv << idx
- end
- else
- arg_cnv << arg_val[idx]
- end
- else
- arg_cnv << arg_val[idx]
- end
- else
- arg_cnv << arg_val[idx]
- end
- }
- arg_cnv
- end
-
- def initialize(d,i,s,v,pp,ss,vv,ww)
- @action = d
- @index = i
- @current = s
- @type = v
- @value = pp
- @string = ss
- @triggered = vv
- @widget = ww
- end
- attr :action
- attr :index
- attr :current
- attr :type
- attr :value
- attr :string
- attr :triggered
- attr :widget
- end
-
- def initialize(cmd = Proc.new, args=nil)
- if args
- @id =
- install_cmd(proc{|*arg|
- TkUtil.eval_cmd(proc{|*v| (cmd.call(*v))? '1': '0'},
- *ValidateArgs.scan_args(args, arg))
- }) + " " + args
- else
- args = ' %d %i %s %v %P %S %V %W'
- @id =
- install_cmd(proc{|*arg|
- TkUtil.eval_cmd(proc{|*v| (cmd.call(*v))? '1': '0'},
- ValidateArgs.new(*ValidateArgs \
- .scan_args(args,arg)))
- }) + args
- end
- end
-
- def to_eval
- @id
- end
- end
-
- def create_self(keys)
- tk_call 'entry', @path
- if keys and keys != None
- configure(keys)
- end
- end
- private :create_self
-
- def configure(slot, value=None)
- if slot.kind_of? Hash
- slot = _symbolkey2str(slot)
- if slot['vcmd'].kind_of? Array
- cmd, *args = slot['vcmd']
- slot['vcmd'] = ValidateCmd.new(cmd, args.join(' '))
- elsif slot['vcmd'].kind_of? Proc
- slot['vcmd'] = ValidateCmd.new(slot['vcmd'])
- end
- if slot['validatecommand'].kind_of? Array
- cmd, *args = slot['validatecommand']
- slot['validatecommand'] = ValidateCmd.new(cmd, args.join(' '))
- elsif slot['validatecommand'].kind_of? Proc
- slot['validatecommand'] = ValidateCmd.new(slot['validatecommand'])
- end
- if slot['invcmd'].kind_of? Array
- cmd, *args = slot['invcmd']
- slot['invcmd'] = ValidateCmd.new(cmd, args.join(' '))
- elsif slot['invcmd'].kind_of? Proc
- slot['invcmd'] = ValidateCmd.new(slot['invcmd'])
- end
- if slot['invalidcommand'].kind_of? Array
- cmd, *args = slot['invalidcommand']
- slot['invalidcommand'] = ValidateCmd.new(cmd, args.join(' '))
- elsif slot['invalidcommand'].kind_of? Proc
- slot['invalidcommand'] = ValidateCmd.new(slot['invalidcommand'])
- end
- super(slot)
- else
- if (slot == 'vcmd' || slot == :vcmd ||
- slot == 'validatecommand' || slot == :validatecommand ||
- slot == 'invcmd' || slot == :invcmd ||
- slot == 'invalidcommand' || slot == :invalidcommand)
- if value.kind_of? Array
- cmd, *args = value
- value = ValidateCmd.new(cmd, args.join(' '))
- elsif value.kind_of? Proc
- value = ValidateCmd.new(value)
- end
- end
- super(slot, value)
- end
- self
- end
-
- def bbox(index)
- list(tk_send('bbox', index))
- end
- def cursor
- number(tk_send('index', 'insert'))
- end
- def cursor=(index)
- tk_send 'icursor', index
- self
- end
- def index(index)
- number(tk_send('index', index))
- end
- def insert(pos,text)
- tk_send 'insert', pos, text
- self
- end
- def delete(first, last=None)
- tk_send 'delete', first, last
- self
- end
- def mark(pos)
- tk_send 'scan', 'mark', pos
- self
- end
- def dragto(pos)
- tk_send 'scan', 'dragto', pos
- self
- end
- def selection_adjust(index)
- tk_send 'selection', 'adjust', index
- self
- end
- def selection_clear
- tk_send 'selection', 'clear'
- self
- end
- def selection_from(index)
- tk_send 'selection', 'from', index
- self
- end
- def selection_present()
- bool(tk_send('selection', 'present'))
- end
- def selection_range(s, e)
- tk_send 'selection', 'range', s, e
- self
- end
- def selection_to(index)
- tk_send 'selection', 'to', index
- self
- end
-
- def invoke_validate
- bool(tk_send('validate'))
- end
- def validate(mode = nil)
- if mode
- configure 'validate', mode
- else
- invoke_validate
- end
- end
-
- def validatecommand(cmd = Proc.new, args = nil)
- if cmd.kind_of?(ValidateCmd)
- configure('validatecommand', cmd)
- elsif args
- configure('validatecommand', [cmd, args])
- else
- configure('validatecommand', cmd)
- end
- end
- alias vcmd validatecommand
-
- def invalidcommand(cmd = Proc.new, args = nil)
- if cmd.kind_of?(ValidateCmd)
- configure('invalidcommand', cmd)
- elsif args
- configure('invalidcommand', [cmd, args])
- else
- configure('invalidcommand', cmd)
- end
- end
- alias invcmd invalidcommand
-
- def value
- tk_send 'get'
- end
- def value= (val)
- tk_send 'delete', 0, 'end'
- tk_send 'insert', 0, val
- end
-end
-
-class TkSpinbox<TkEntry
- TkCommandNames = ['spinbox'.freeze].freeze
- WidgetClassName = 'Spinbox'.freeze
- WidgetClassNames[WidgetClassName] = self
-
- def create_self(keys)
- tk_call 'spinbox', @path
- if keys and keys != None
- configure(keys)
- end
- end
- private :create_self
-
- def identify(x, y)
- tk_send 'identify', x, y
- end
-
- def spinup
- tk_send 'invoke', 'spinup'
- self
- end
-
- def spindown
- tk_send 'invoke', 'spindown'
- self
- end
-
- def set(str)
- tk_send 'set', str
- end
-end
diff --git a/ext/tk/lib/tkfont.rb b/ext/tk/lib/tkfont.rb
deleted file mode 100644
index ff7bbc74e4..0000000000
--- a/ext/tk/lib/tkfont.rb
+++ /dev/null
@@ -1,1390 +0,0 @@
-#
-# tkfont.rb - the class to treat fonts on Ruby/Tk
-#
-# by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
-#
-require 'tk'
-
-class TkFont
- include Tk
- extend TkCore
-
- TkCommandNames = ['font'.freeze].freeze
-
- Tk_FontID = ["@font".freeze, "00000".taint].freeze
- Tk_FontNameTBL = TkCore::INTERP.create_table
- Tk_FontUseTBL = TkCore::INTERP.create_table
-
- TkCore::INTERP.init_ip_env{
- Tk_FontNameTBL.clear
- Tk_FontUseTBL.clear
- }
-
- # set default font
- case Tk::TK_VERSION
- when /^4\.*/
- DEFAULT_LATIN_FONT_NAME = 'a14'.freeze
- DEFAULT_KANJI_FONT_NAME = 'k14'.freeze
-
- when /^8\.*/
- if JAPANIZED_TK
- begin
- fontnames = tk_call('font', 'names')
- case fontnames
- when /defaultgui/
- # Tcl/Tk-JP for Windows
- ltn = 'defaultgui'
- knj = 'defaultgui'
- when /Mincho:Helvetica-Bold-12/
- # Tcl/Tk-JP for UNIX/X
- ltn, knj = tk_split_simplelist(tk_call('font', 'configure',
- 'Mincho:Helvetica-Bold-12',
- '-compound'))
- else
- # unknown Tcl/Tk-JP
- platform = tk_call('set', 'tcl_platform(platform)')
- case platform
- when 'unix'
- ltn = {'family'=>'Helvetica'.freeze,
- 'size'=>-12, 'weight'=>'bold'.freeze}
- #knj = 'k14'
- #knj = '-misc-fixed-medium-r-normal--14-*-*-*-c-*-jisx0208.1983-0'
- knj = '-*-fixed-bold-r-normal--12-*-*-*-c-*-jisx0208.1983-0'
- when 'windows'
- ltn = {'family'=>'MS Sans Serif'.freeze, 'size'=>8}
- knj = 'mincho'
- when 'macintosh'
- ltn = 'system'
- knj = 'mincho'
- else # unknown
- ltn = 'Helvetica'
- knj = 'mincho'
- end
- end
- rescue
- ltn = 'Helvetica'
- knj = 'mincho'
- end
-
- else # not JAPANIZED_TK
- begin
- platform = tk_call('set', 'tcl_platform(platform)')
- case platform
- when 'unix'
- ltn = {'family'=>'Helvetica'.freeze,
- 'size'=>-12, 'weight'=>'bold'.freeze}
- #knj = 'k14'
- #knj = '-misc-fixed-medium-r-normal--14-*-*-*-c-*-jisx0208.1983-0'
- knj = '-*-fixed-bold-r-normal--12-*-*-*-c-*-jisx0208.1983-0'
- when 'windows'
- ltn = {'family'=>'MS Sans Serif'.freeze, 'size'=>8}
- knj = 'mincho'
- when 'macintosh'
- ltn = 'system'
- knj = 'mincho'
- else # unknown
- ltn = 'Helvetica'
- knj = 'mincho'
- end
- rescue
- ltn = 'Helvetica'
- knj = 'mincho'
- end
-
- knj = ltn
- end
-
- DEFAULT_LATIN_FONT_NAME = ltn.freeze
- DEFAULT_KANJI_FONT_NAME = knj.freeze
-
- else # unknown version
- DEFAULT_LATIN_FONT_NAME = 'Helvetica'.freeze
- DEFAULT_KANJI_FONT_NAME = 'mincho'.freeze
-
- end
-
- if $DEBUG
- print "default latin font = "; p DEFAULT_LATIN_FONT_NAME
- print "default kanji font = "; p DEFAULT_KANJI_FONT_NAME
- end
-
-
- ###################################
- class DescendantFont
- def initialize(compound, type)
- unless compound.kind_of?(TkFont)
- fail ArgumentError, "a TkFont object is expected for the 1st argument"
- end
- @compound = compound
- case type
- when 'kanji', 'latin', 'ascii'
- @type = type
- else
- fail ArgumentError, "unknown type '#{type}'"
- end
- end
-
- def dup
- fail RuntimeError, "cannot dupulicate a descendant font"
- end
- def clone
- fail RuntimeError, "cannot clone a descendant font"
- end
-
- def to_eval
- @compound.__send__(@type + '_font_id')
- end
- def font
- @compound.__send__(@type + '_font_id')
- end
-
- def [](slot)
- @compound.__send__(@type + '_configinfo', slot)
- end
- def []=(slot, value=None)
- @compound.__send__(@type + '_configure', slot, value)
- end
-
- def method_missing(id, *args)
- @compound.__send__(@type + '_' + id.id2name, *args)
- end
- end
-
-
- ###################################
- # class methods
- ###################################
- def TkFont.families(window=nil)
- case (Tk::TK_VERSION)
- when /^4\.*/
- ['fixed']
-
- when /^8\.*/
- if window
- tk_split_simplelist(tk_call('font', 'families', '-displayof', window))
- else
- tk_split_simplelist(tk_call('font', 'families'))
- end
- end
- end
-
- def TkFont.names
- case (Tk::TK_VERSION)
- when /^4\.*/
- r = ['fixed']
- r += ['a14', 'k14'] if JAPANIZED_TK
- Tk_FontNameTBL.each_value{|obj| r.push(obj)}
- r | []
-
- when /^8\.*/
- tk_split_simplelist(tk_call('font', 'names'))
-
- end
- end
-
- def TkFont.create_copy(font)
- fail 'source-font must be a TkFont object' unless font.kind_of? TkFont
- keys = {}
- font.configinfo.each{|key,value| keys[key] = value }
- TkFont.new(font.latin_font_id, font.kanji_font_id, keys)
- end
-
- def TkFont.get_obj(name)
- if name =~ /^(@font[0-9]+)(|c|l|k)$/
- Tk_FontNameTBL[$1]
- else
- nil
- end
- end
-
- def TkFont.init_widget_font(path, *args)
- case (Tk::TK_VERSION)
- when /^4\.*/
- conf = tk_split_simplelist(tk_call(*args)).
- find_all{|prop| prop[0..5]=='-font ' || prop[0..10]=='-kanjifont '}.
- collect{|prop| tk_split_simplelist(prop)}
- if font_inf = conf.assoc('-font')
- ltn = font_inf[4]
- ltn = nil if ltn == []
- else
- #ltn = nil
- raise RuntimeError, "unknown option '-font'"
- end
- if font_inf = conf.assoc('-kanjifont')
- knj = font_inf[4]
- knj = nil if knj == []
- else
- knj = nil
- end
- TkFont.new(ltn, knj).call_font_configure(path, *(args + [{}]))
-
- when /^8\.*/
- font_prop = tk_split_simplelist(tk_call(*args)).find{|prop|
- prop[0..5] == '-font '
- }
- unless font_prop
- raise RuntimeError, "unknown option '-font'"
- end
- fnt = tk_split_simplelist(font_prop)[4]
- if fnt == ""
- TkFont.new(nil, nil).call_font_configure(path, *(args + [{}]))
- else
- begin
- compound = tk_split_simplelist(
- Hash[*tk_split_simplelist(tk_call('font', 'configure',
- fnt))].collect{|key,value|
- [key[1..-1], value]
- }.assoc('compound')[1])
- rescue
- compound = []
- end
- if compound == []
- #TkFont.new(fnt, DEFAULT_KANJI_FONT_NAME) \
- #.call_font_configure(path, *(args + [{}]))
- TkFont.new(fnt).call_font_configure(path, *(args + [{}]))
- else
- TkFont.new(compound[0], compound[1]) \
- .call_font_configure(path, *(args + [{}]))
- end
- end
- end
- end
-
- def TkFont.used_on(path=nil)
- if path
- Tk_FontUseTBL[path]
- else
- Tk_FontUseTBL.values | []
- end
- end
-
- def TkFont.failsafe(font)
- begin
- if /^8\.*/ === Tk::TK_VERSION && JAPANIZED_TK
- tk_call('font', 'failsafe', font)
- end
- rescue
- end
- end
-
- ###################################
- # instance methods
- ###################################
- private
- ###################################
- def initialize(ltn=nil, knj=nil, keys=nil)
- @id = Tk_FontID.join
- Tk_FontID[1].succ!
- Tk_FontNameTBL[@id] = self
-
- @latin_desscendant = nil
- @kanji_desscendant = nil
-
- if knj.kind_of?(Hash) && !keys
- keys = knj
- knj = nil
- end
-
- # compound font check
- if Tk::TK_VERSION == '8.0' && JAPANIZED_TK
- begin
- compound = tk_split_simplelist(tk_call('font', 'configure',
- ltn, '-compound'))
- if knj == nil
- if compound != []
- ltn, knj = compound
- end
- else
- if compound != []
- ltn = compound[0]
- end
- compound = tk_split_simplelist(tk_call('font', 'configure',
- knj, '-compound'))
- if compound != []
- knj = compound[1]
- end
- end
- rescue
- end
- end
-
- if ltn
- knj = ltn if JAPANIZED_TK && !knj
- else
- ltn = DEFAULT_LATIN_FONT_NAME
- knj = DEFAULT_KANJI_FONT_NAME if JAPANIZED_TK && !knj
- end
-
- create_compoundfont(ltn, knj, keys)
- end
-
- def _get_font_info_from_hash(font)
- font = _symbolkey2str(font)
- foundry = (info = font['foundry'] .to_s)? info: '*'
- family = (info = font['family'] .to_s)? info: '*'
- weight = (info = font['weight'] .to_s)? info: '*'
- slant = (info = font['slant'] .to_s)? info: '*'
- swidth = (info = font['swidth'] .to_s)? info: '*'
- adstyle = (info = font['adstyle'] .to_s)? info: '*'
- pixels = (info = font['pixels'] .to_s)? info: '*'
- points = (info = font['points'] .to_s)? info: '*'
- resx = (info = font['resx'] .to_s)? info: '*'
- resy = (info = font['resy'] .to_s)? info: '*'
- space = (info = font['space'] .to_s)? info: '*'
- avgWidth = (info = font['avgWidth'].to_s)? info: '*'
- charset = (info = font['charset'] .to_s)? info: '*'
- encoding = (info = font['encoding'].to_s)? info: '*'
-
- [foundry, family, weight, slant, swidth, adstyle,
- pixels, points, resx, resy, space, avgWidth, charset, encoding]
- end
-
- def create_latinfont_tk4x(font)
- if font.kind_of? Hash
- @latinfont = '-' + _get_font_info_from_hash(font).join('-') + '-'
-
- elsif font.kind_of? Array
- finfo = {}
- finfo['family'] = font[0].to_s
- if font[1]
- fsize = font[1].to_s
- if fsize != '0' && fsize =~ /^(|\+|-)([0-9]+)$/
- if $1 == '-'
- finfo['pixels'] = $2
- else
- finfo['points'] = $2
- end
- else
- finfo['points'] = '13'
- end
- end
- font[2..-1].each{|style|
- case (style)
- when 'normal'
- finfo['weight'] = style
- when 'bold'
- finfo['weight'] = style
- when 'roman'
- finfo['slant'] = 'r'
- when 'italic'
- finfo['slant'] = 'i'
- end
- }
-
- @latinfont = '-' + _get_font_info_from_hash(finfo).join('-') + '-'
-
- elsif font.kind_of? TkFont
- @latinfont = font.latin_font
-
- else
- if font
- @latinfont = font
- else
- @latinfont = DEFAULT_LATIN_FONT_NAME
- end
-
- end
- end
-
- def create_kanjifont_tk4x(font)
- unless JAPANIZED_TK
- @kanjifont = ""
- return
- end
-
- if font.kind_of? Hash
- @kanjifont = '-' + _get_font_info_from_hash(font).join('-') + '-'
-
- elsif font.kind_of? Array
- finfo = {}
- finfo['family'] = font[0].to_s
- if font[1]
- fsize = font[1].to_s
- if fsize != '0' && fsize =~ /^(|\+|-)([0-9]+)$/
- if $1 == '-'
- finfo['pixels'] = $2
- else
- finfo['points'] = $2
- end
- else
- finfo['points'] = '13'
- end
- end
- font[2..-1].each{|style|
- case (style)
- when 'normal'
- finfo['weight'] = style
- when 'bold'
- finfo['weight'] = style
- when 'roman'
- finfo['slant'] = 'r'
- when 'italic'
- finfo['slant'] = 'i'
- end
- }
-
- @kanjifont = '-' + _get_font_info_from_hash(finfo).join('-') + '-'
- elsif font.kind_of? TkFont
- @kanjifont = font.kanji_font_id
- else
- if font
- @kanjifont = font
- else
- @kanjifont = DEFAULT_KANJI_FONT_NAME
- end
- end
- end
-
- def create_compoundfont_tk4x(ltn, knj, keys)
- create_latinfont(ltn)
- create_kanjifont(knj)
-
- if JAPANIZED_TK
- @compoundfont = [[@latinfont], [@kanjifont]]
- @fontslot = {'font'=>@latinfont, 'kanjifont'=>@kanjifont}
- else
- @compoundfont = @latinfont
- @fontslot = {'font'=>@latinfont}
- end
- end
-
- def create_latinfont_tk8x(font)
- @latinfont = @id + 'l'
-
- if JAPANIZED_TK
- if font.kind_of? Hash
- if font[:charset] || font['charset']
- tk_call('font', 'create', @latinfont, *hash_kv(font))
- else
- tk_call('font', 'create', @latinfont,
- '-charset', 'iso8859', *hash_kv(font))
- end
- elsif font.kind_of? Array
- tk_call('font', 'create', @latinfont, '-copy', array2tk_list(font))
- tk_call('font', 'configure', @latinfont, '-charset', 'iso8859')
- elsif font.kind_of? TkFont
- tk_call('font', 'create', @latinfont, '-copy', font.latin_font)
- elsif font
- tk_call('font', 'create', @latinfont, '-copy', font,
- '-charset', 'iso8859')
- else
- tk_call('font', 'create', @latinfont, '-charset', 'iso8859')
- end
- else
- if font.kind_of? Hash
- tk_call('font', 'create', @latinfont, *hash_kv(font))
- else
- keys = {}
- if font.kind_of? Array
- actual_core(array2tk_list(font)).each{|key,val| keys[key] = val}
- elsif font.kind_of? TkFont
- actual_core(font.latin_font).each{|key,val| keys[key] = val}
- elsif font
- actual_core(font).each{|key,val| keys[key] = val}
- end
- tk_call('font', 'create', @latinfont, *hash_kv(keys))
- end
-
- if font && @compoundfont
- keys = {}
- actual_core(@latinfont).each{|key,val| keys[key] = val}
- tk_call('font', 'configure', @compoundfont, *hash_kv(keys))
- end
- end
- end
-
- def create_kanjifont_tk8x(font)
- @kanjifont = @id + 'k'
-
- if JAPANIZED_TK
- if font.kind_of? Hash
- if font[:charset] || font['charset']
- tk_call('font', 'create', @kanjifont, *hash_kv(font))
- else
- tk_call('font', 'create', @kanjifont,
- '-charset', 'jisx0208.1983', *hash_kv(font))
- end
- elsif font.kind_of? Array
- tk_call('font', 'create', @kanjifont, '-copy', array2tk_list(font))
- tk_call('font', 'configure', @kanjifont, '-charset', 'jisx0208.1983')
- elsif font.kind_of? TkFont
- tk_call('font', 'create', @kanjifont, '-copy', font.kanji_font_id)
- elsif font
- tk_call('font', 'create', @kanjifont, '-copy', font,
- '-charset', 'jisx0208.1983')
- else
- tk_call('font', 'create', @kanjifont, '-charset', 'jisx0208.1983')
- end
- # end of JAPANIZED_TK
-
- else
- if font.kind_of? Hash
- tk_call('font', 'create', @kanjifont, *hash_kv(font))
- else
- keys = {}
- if font.kind_of? Array
- actual_core(array2tk_list(font)).each{|key,val| keys[key] = val}
- elsif font.kind_of? TkFont
- actual_core(font.kanji_font_id).each{|key,val| keys[key] = val}
- elsif font
- actual_core(font).each{|key,val| keys[key] = val}
- end
- tk_call('font', 'create', @kanjifont, *hash_kv(keys))
- end
-
- if font && @compoundfont
- keys = {}
- actual_core(@kanjifont).each{|key,val| keys[key] = val}
- tk_call('font', 'configure', @compoundfont, *hash_kv(keys))
- end
- end
- end
-
- def create_compoundfont_tk8x(ltn, knj, keys)
- create_latinfont(ltn)
- create_kanjifont(knj)
-
- @compoundfont = @id + 'c'
- if JAPANIZED_TK
- unless keys
- keys = {}
- else
- keys = keys.dup
- end
- if (tk_call('font', 'configure', @latinfont, '-underline') == '1' &&
- tk_call('font', 'configure', @kanjifont, '-underline') == '1' &&
- !keys.key?('underline'))
- keys['underline'] = true
- end
- if (tk_call('font', 'configure', @latinfont, '-overstrike') == '1' &&
- tk_call('font', 'configure', @kanjifont, '-overstrike') == '1' &&
- !keys.key?('overstrike'))
- keys['overstrike'] = true
- end
-
- @fontslot = {'font'=>@compoundfont}
- begin
- tk_call('font', 'create', @compoundfont,
- '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
- rescue RuntimeError => e
- if ltn == knj
- if e.message =~ /kanji font .* specified/
- tk_call('font', 'delete', @latinfont)
- create_latinfont(DEFAULT_LATIN_FONT_NAME)
- opts = []
- Hash[*(tk_split_simplelist(tk_call('font', 'configure',
- @kanjifont)))].each{|k,v|
- case k
- when '-size', '-weight', '-slant', '-underline', '-overstrike'
- opts << k << v
- end
- }
- tk_call('font', 'configure', @latinfont, *opts)
- tk_call('font', 'create', @compoundfont,
- '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
-
- elsif e.message =~ /ascii font .* specified/
- tk_call('font', 'delete', @kanjifont)
- create_kanjifont(DEFAULT_KANJI_FONT_NAME)
- opts = []
- Hash[*(tk_split_simplelist(tk_call('font', 'configure',
- @latinfont)))].each{|k,v|
- case k
- when '-size', '-weight', '-slant', '-underline', '-overstrike'
- opts << k << v
- end
- }
- tk_call('font', 'configure', @kanjifont, *opts)
- tk_call('font', 'create', @compoundfont,
- '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
-
- else
- raise e
- end
- else
- raise e
- end
- end
- else
- tk_call('font', 'create', @compoundfont)
-
- latinkeys = {}
- begin
- actual_core(@latinfont).each{|key,val| latinkeys[key] = val}
- rescue
- latinkeys {}
- end
- if latinkeys != {}
- tk_call('font', 'configure', @compoundfont, *hash_kv(latinkeys))
- end
-
- if knj
- kanjikeys = {}
- begin
- actual_core(@kanjifont).each{|key,val| kanjikeys[key] = val}
- rescue
- kanjikeys {}
- end
- if kanjikeys != {}
- tk_call('font', 'configure', @compoundfont, *hash_kv(kanjikeys))
- end
- end
-
- @fontslot = {'font'=>@compoundfont}
- tk_call('font', 'configure', @compoundfont, *hash_kv(keys))
- end
- end
-
- def actual_core_tk4x(font, window=nil, option=nil)
- # dummy
- if option
- ""
- else
- [['family',[]], ['size',[]], ['weight',[]], ['slant',[]],
- ['underline',[]], ['overstrike',[]], ['charset',[]],
- ['pointadjust',[]]]
- end
- end
-
- def actual_core_tk8x(font, window=nil, option=nil)
- if option == 'compound'
- ""
- elsif option
- if window
- tk_call('font', 'actual', font, "-displayof", window, "-#{option}")
- else
- tk_call('font', 'actual', font, "-#{option}")
- end
- else
- l = tk_split_simplelist(if window
- tk_call('font', 'actual', font,
- "-displayof", window)
- else
- tk_call('font', 'actual', font)
- end)
- r = []
- while key=l.shift
- if key == '-compound'
- l.shift
- else
- r.push [key[1..-1], l.shift]
- end
- end
- r
- end
- end
-
- def configure_core_tk4x(font, slot, value=None)
- #""
- self
- end
-
- def configinfo_core_tk4x(font, option=nil)
- # dummy
- if option
- ""
- else
- [['family',[]], ['size',[]], ['weight',[]], ['slant',[]],
- ['underline',[]], ['overstrike',[]], ['charset',[]],
- ['pointadjust',[]]]
- end
- end
-
- def configure_core_tk8x(font, slot, value=None)
- if JAPANIZED_TK
- begin
- padjust = tk_call('font', 'configure', font, '-pointadjust')
- rescue
- padjust = nil
- end
- else
- padjust = nil
- end
- if slot.kind_of? Hash
- if JAPANIZED_TK && (slot.key?('family') || slot.key?(:family))
- slot = _symbolkey2str(slot)
- configure_core_tk8x(font, 'family', slot.delete('family'))
- end
-
- if ((slot.key?('size') || slot.key?(:size)) &&
- padjust && !slot.key?('pointadjust') && !slot.key?(:pointadjust))
- tk_call('font', 'configure', font,
- '-pointadjust', padjust, *hash_kv(slot))
- else
- tk_call('font', 'configure', font, *hash_kv(slot))
- end
- elsif (slot == 'size' || slot == :size) && padjust != nil
- tk_call('font', 'configure', font,
- "-#{slot}", value, '-pointadjust', padjust)
- elsif JAPANIZED_TK && (slot == 'family' || slot == :family)
- # coumpund font?
- begin
- compound = tk_split_simplelist(tk_call('font', 'configure',
- font, '-compound'))
- rescue
- tk_call('font', 'configure', font, '-family', value)
- return self
- end
- if compound == []
- tk_call('font', 'configure', font, '-family', value)
- return self
- end
- ltn, knj = compound
-
- lfnt = tk_call('font', 'create', '-copy', ltn)
- begin
- tk_call('font', 'configure', lfnt, '-family', value)
- latin_replace_core_tk8x(lfnt)
- rescue RuntimeError => e
- fail e if $DEBUG
- ensure
- tk_call('font', 'delete', lfnt) if lfnt != ''
- end
-
- kfnt = tk_call('font', 'create', '-copy', knj)
- begin
- tk_call('font', 'configure', kfnt, '-family', value)
- kanji_replace_core_tk8x(lfnt)
- rescue RuntimeError => e
- fail e if $DEBUG
- ensure
- tk_call('font', 'delete', kfnt) if kfnt != ''
- end
-
- else
- tk_call('font', 'configure', font, "-#{slot}", value)
- end
- self
- end
-
- def configinfo_core_tk8x(font, option=nil)
- if option == 'compound'
- ""
- elsif option
- tk_call('font', 'configure', font, "-#{option}")
- else
- l = tk_split_simplelist(tk_call('font', 'configure', font))
- r = []
- while key=l.shift
- if key == '-compound'
- l.shift
- else
- r.push [key[1..-1], l.shift]
- end
- end
- r
- end
- end
-
- def delete_core_tk4x
- Tk_FontNameTBL.delete(@id)
- Tk_FontUseTBL.delete_if{|key,value| value == self}
- end
-
- def delete_core_tk8x
- begin
- tk_call('font', 'delete', @latinfont)
- rescue
- end
- begin
- tk_call('font', 'delete', @kanjifont)
- rescue
- end
- begin
- tk_call('font', 'delete', @compoundfont)
- rescue
- end
- Tk_FontNameTBL.delete(@id)
- Tk_FontUseTBL.delete_if{|key,value| value == self}
- end
-
- def latin_replace_core_tk4x(ltn)
- create_latinfont_tk4x(ltn)
- @compoundfont[0] = [@latinfont] if JAPANIZED_TK
- @fontslot['font'] = @latinfont
- Tk_FontUseTBL.dup.each{|w, fobj|
- if self == fobj
- begin
- if w.include?(';')
- win, tag = w.split(';')
- winobj = tk_tcl2ruby(win)
-# winobj.tagfont_configure(tag, {'font'=>@latinfont})
- if winobj.kind_of? TkText
- tk_call(win, 'tag', 'configure', tag, '-font', @latinfont)
- elsif winobj.kind_of? TkCanvas
- tk_call(win, 'itemconfigure', tag, '-font', @latinfont)
- elsif winobj.kind_of? TkMenu
- tk_call(win, 'entryconfigure', tag, '-font', @latinfont)
- else
- raise RuntimeError, "unknown widget type"
- end
- else
-# tk_tcl2ruby(w).font_configure('font'=>@latinfont)
- tk_call(w, 'configure', '-font', @latinfont)
- end
- rescue
- Tk_FontUseTBL.delete(w)
- end
- end
- }
- self
- end
-
- def kanji_replace_core_tk4x(knj)
- return self unless JAPANIZED_TK
-
- create_kanjifont_tk4x(knj)
- @compoundfont[1] = [@kanjifont]
- @fontslot['kanjifont'] = @kanjifont
- Tk_FontUseTBL.dup.each{|w, fobj|
- if self == fobj
- begin
- if w.include?(';')
- win, tag = w.split(';')
- winobj = tk_tcl2ruby(win)
-# winobj.tagfont_configure(tag, {'kanjifont'=>@kanjifont})
- if winobj.kind_of? TkText
- tk_call(win, 'tag', 'configure', tag, '-kanjifont', @kanjifont)
- elsif winobj.kind_of? TkCanvas
- tk_call(win, 'itemconfigure', tag, '-kanjifont', @kanjifont)
- elsif winobj.kind_of? TkMenu
- tk_call(win, 'entryconfigure', tag, '-kanjifont', @latinfont)
- else
- raise RuntimeError, "unknown widget type"
- end
- else
-# tk_tcl2ruby(w).font_configure('kanjifont'=>@kanjifont)
- tk_call(w, 'configure', '-kanjifont', @kanjifont)
- end
- rescue
- Tk_FontUseTBL.delete(w)
- end
- end
- }
- self
- end
-
- def latin_replace_core_tk8x(ltn)
- if JAPANIZED_TK
- begin
- tk_call('font', 'delete', '@font_tmp')
- rescue
- end
- begin
- fnt_bup = tk_call('font', 'create', '@font_tmp', '-copy', @latinfont)
- rescue
- #fnt_bup = ''
- fnt_bup = DEFAULT_LATIN_FONT_NAME
- end
- end
-
- begin
- tk_call('font', 'delete', @latinfont)
- rescue
- end
- create_latinfont(ltn)
-
- if JAPANIZED_TK
- keys = self.configinfo
- tk_call('font', 'delete', @compoundfont)
- begin
- tk_call('font', 'create', @compoundfont,
- '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
-=begin
- latinkeys = {}
- begin
- actual_core(@latinfont).each{|key,val| latinkeys[key] = val}
- rescue
- latinkeys {}
- end
- if latinkeys != {}
- tk_call('font', 'configure', @compoundfont, *hash_kv(latinkeys))
- end
-=end
- rescue RuntimeError => e
- tk_call('font', 'delete', @latinfont)
- if fnt_bup && fnt_bup != ''
- tk_call('font', 'create', @latinfont, '-copy', fnt_bup)
- tk_call('font', 'create', @compoundfont,
- '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
- tk_call('font', 'delete', fnt_bup)
- else
- fail e
- end
- end
-
- else
- latinkeys = {}
- begin
- actual_core(@latinfont).each{|key,val| latinkeys[key] = val}
- rescue
- latinkeys {}
- end
- if latinkeys != {}
- tk_call('font', 'configure', @compoundfont, *hash_kv(latinkeys))
- end
- end
- self
- end
-
- def kanji_replace_core_tk8x(knj)
- if JAPANIZED_TK
- begin
- tk_call('font', 'delete', '@font_tmp')
- rescue
- end
- begin
- fnt_bup = tk_call('font', 'create', '@font_tmp', '-copy', @kanjifont)
- rescue
- #fnt_bup = ''
- fnt_bup = DEFAULT_KANJI_FONT_NAME
- end
- end
-
- begin
- tk_call('font', 'delete', @kanjifont)
- rescue
- end
- create_kanjifont(knj)
-
- if JAPANIZED_TK
- keys = self.configinfo
- tk_call('font', 'delete', @compoundfont)
- begin
- tk_call('font', 'create', @compoundfont,
- '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
- rescue RuntimeError => e
- tk_call('font', 'delete', @kanjifont)
- if fnt_bup && fnt_bup != ''
- tk_call('font', 'create', @kanjifont, '-copy', fnt_bup)
- tk_call('font', 'create', @compoundfont,
- '-compound', [@latinfont, @kanjifont], *hash_kv(keys))
- tk_call('font', 'delete', fnt_bup)
- else
- fail e
- end
- end
- end
- self
- end
-
- def measure_core_tk4x(window, text)
- 0
- end
-
- def measure_core_tk8x(window, text)
- if window
- number(tk_call('font', 'measure', @compoundfont,
- '-displayof', window, text))
- else
- number(tk_call('font', 'measure', @compoundfont, text))
- end
- end
-
- def metrics_core_tk4x(font, window, option=nil)
- # dummy
- if option
- ""
- else
- [['ascent',[]], ['descent',[]], ['linespace',[]], ['fixed',[]]]
- end
- end
-
- def metrics_core_tk8x(font, window, option=nil)
- if option
- if window
- number(tk_call('font', 'metrics', font,
- "-displayof", window, "-#{option}"))
- else
- number(tk_call('font', 'metrics', font, "-#{option}"))
- end
- else
- l = tk_split_list(if window
- tk_call('font','metrics',font,"-displayof",window)
- else
- tk_call('font','metrics',font)
- end)
- r = []
- while key=l.shift
- r.push [key[1..-1], l.shift.to_i]
- end
- r
- end
- end
-
- ###################################
- # private alias
- ###################################
- case (Tk::TK_VERSION)
- when /^4\.*/
- alias create_latinfont create_latinfont_tk4x
- alias create_kanjifont create_kanjifont_tk4x
- alias create_compoundfont create_compoundfont_tk4x
- alias actual_core actual_core_tk4x
- alias configure_core configure_core_tk4x
- alias configinfo_core configinfo_core_tk4x
- alias delete_core delete_core_tk4x
- alias latin_replace_core latin_replace_core_tk4x
- alias kanji_replace_core kanji_replace_core_tk4x
- alias measure_core measure_core_tk4x
- alias metrics_core metrics_core_tk4x
-
- when /^8\.[0-4]/
- alias create_latinfont create_latinfont_tk8x
- alias create_kanjifont create_kanjifont_tk8x
- alias create_compoundfont create_compoundfont_tk8x
- alias actual_core actual_core_tk8x
- alias configure_core configure_core_tk8x
- alias configinfo_core configinfo_core_tk8x
- alias delete_core delete_core_tk8x
- alias latin_replace_core latin_replace_core_tk8x
- alias kanji_replace_core kanji_replace_core_tk8x
- alias measure_core measure_core_tk8x
- alias metrics_core metrics_core_tk8x
-
- when /^8\.*/
- alias create_latinfont create_latinfont_tk8x
- alias create_kanjifont create_kanjifont_tk8x
- alias create_compoundfont create_compoundfont_tk8x
- alias actual_core actual_core_tk8x
- alias configure_core configure_core_tk8x
- alias configinfo_core configinfo_core_tk8x
- alias delete_core delete_core_tk8x
- alias latin_replace_core latin_replace_core_tk8x
- alias kanji_replace_core kanji_replace_core_tk8x
- alias measure_core measure_core_tk8x
- alias metrics_core metrics_core_tk8x
-
- end
-
- ###################################
- public
- ###################################
- def method_missing(id, *args)
- name = id.id2name
- case args.length
- when 1
- configure name, args[0]
- when 0
- begin
- configinfo name
- rescue
- fail NameError, "undefined local variable or method `#{name}' for #{self.to_s}", error_at
- end
- else
- fail NameError, "undefined method `#{name}' for #{self.to_s}", error_at
- end
- end
-
- def call_font_configure(path, *args)
- args += hash_kv(args.pop.update(@fontslot))
- tk_call(*args)
- Tk_FontUseTBL[path] = self
- self
- end
-
- def used
- ret = []
- Tk_FontUseTBL.each{|key,value|
- if key.include?(';')
- win, tag = key.split(';')
- winobj = tk_tcl2ruby(win)
- if winobj.kind_of? TkText
- ret.push([winobj, winobj.tagid2obj(tag)])
- elsif winobj.kind_of? TkCanvas
- if (tagobj = TkcTag.id2obj(winobj, tag)).kind_of? TkcTag
- ret.push([winobj, tagobj])
- elsif (tagobj = TkcItem.id2obj(tag)).kind_of? TkcItem
- ret.push([winobj, tagobj])
- else
- ret.push([winobj, tag])
- end
- elsif winobj.kind_of? TkMenu
- ret.push([winobj, tag])
- else
- ret.push([win, tag])
- end
- else
- ret.push(tk_tcl2ruby(key)) if value == self
- end
- }
- ret
- end
-
- def id
- @id
- end
-
- def to_eval
- font
- end
-
- def font
- @compoundfont
- end
- alias font_id font
-
- def latin_font_id
- @latinfont
- end
-
- def latin_font
- # @latinfont
- if @latin_descendant
- @latin_descendant
- else
- @latin_descendant = DescendantFont.new(self, 'latin')
- end
- end
- alias latinfont latin_font
-
- def kanji_font_id
- @kanjifont
- end
-
- def kanji_font
- # @kanjifont
- if @kanji_descendant
- @kanji_descendant
- else
- @kanji_descendant = DescendantFont.new(self, 'kanji')
- end
- end
- alias kanjifont kanji_font
-
- def actual(option=nil)
- actual_core(@compoundfont, nil, option)
- end
-
- def actual_displayof(window, option=nil)
- window = '.' unless window
- actual_core(@compoundfont, window, option)
- end
-
- def latin_actual(option=nil)
- actual_core(@latinfont, nil, option)
- end
-
- def latin_actual_displayof(window, option=nil)
- window = '.' unless window
- actual_core(@latinfont, window, option)
- end
-
- def kanji_actual(option=nil)
- #if JAPANIZED_TK
- if @kanjifont != ""
- actual_core(@kanjifont, nil, option)
- else
- actual_core_tk4x(nil, nil, option)
- end
- end
-
- def kanji_actual_displayof(window, option=nil)
- #if JAPANIZED_TK
- if @kanjifont != ""
- window = '.' unless window
- actual_core(@kanjifont, window, option)
- else
- actual_core_tk4x(nil, window, option)
- end
- end
-
- def [](slot)
- configinfo slot
- end
-
- def []=(slot, val)
- configure slot, val
- end
-
- def configure(slot, value=None)
- configure_core(@compoundfont, slot, value)
- self
- end
-
- def configinfo(slot=nil)
- configinfo_core(@compoundfont, slot)
- end
-
- def delete
- delete_core
- end
-
- def latin_configure(slot, value=None)
- if JAPANIZED_TK
- configure_core(@latinfont, slot, value)
- else
- configure(slot, value)
- end
- self
- end
-
- def latin_configinfo(slot=nil)
- if JAPANIZED_TK
- configinfo_core(@latinfont, slot)
- else
- configinfo(slot)
- end
- end
-
- def kanji_configure(slot, value=None)
- #if JAPANIZED_TK
- if @kanjifont != ""
- configure_core(@kanjifont, slot, value)
- configure('size'=>configinfo('size')) # to reflect new configuration
- else
- #""
- configure(slot, value)
- end
- self
- end
-
- def kanji_configinfo(slot=nil)
- #if JAPANIZED_TK
- if @kanjifont != ""
- configinfo_core(@kanjifont, slot)
- else
- #[]
- configinfo(slot)
- end
- end
-
- def replace(ltn, knj)
- latin_replace(ltn)
- kanji_replace(knj)
- self
- end
-
- def latin_replace(ltn)
- latin_replace_core(ltn)
- reset_pointadjust
- self
- end
-
- def kanji_replace(knj)
- kanji_replace_core(knj)
- reset_pointadjust
- self
- end
-
- def measure(text)
- measure_core(nil, text)
- end
-
- def measure_displayof(window, text)
- window = '.' unless window
- measure_core(window, text)
- end
-
- def metrics(option=nil)
- metrics_core(@compoundfont, nil, option)
- end
-
- def metrics_displayof(window, option=nil)
- window = '.' unless window
- metrics_core(@compoundfont, window, option)
- end
-
- def latin_metrics(option=nil)
- metrics_core(@latinfont, nil, option)
- end
-
- def latin_metrics_displayof(window, option=nil)
- window = '.' unless window
- metrics_core(@latinfont, window, option)
- end
-
- def kanji_metrics(option=nil)
- if JAPANIZED_TK
- metrics_core(@kanjifont, nil, option)
- else
- metrics_core_tk4x(nil, nil, option)
- end
- end
-
- def kanji_metrics_displayof(window, option=nil)
- if JAPANIZED_TK
- window = '.' unless window
- metrics_core(@kanjifont, window, option)
- else
- metrics_core_tk4x(nil, window, option)
- end
- end
-
- def reset_pointadjust
- begin
- if /^8\.*/ === Tk::TK_VERSION && JAPANIZED_TK
- configure('pointadjust' => latin_actual.assoc('size')[1].to_f /
- kanji_actual.assoc('size')[1].to_f )
- end
- rescue
- end
- self
- end
-
- ###################################
- # public alias
- ###################################
- alias ascii_font latin_font
- alias asciifont latinfont
- alias create_asciifont create_latinfont
- alias ascii_actual latin_actual
- alias ascii_actual_displayof latin_actual_displayof
- alias ascii_configure latin_configure
- alias ascii_configinfo latin_configinfo
- alias ascii_replace latin_replace
- alias ascii_metrics latin_metrics
-
- ###################################
- def dup
- src = self
- obj = super()
- obj.instance_eval{ initialize(src) }
- obj
- end
- def clone
- src = self
- obj = super()
- obj.instance_eval{ initialize(src) }
- obj
- end
-end
-
-module TkTreatTagFont
- def font_configinfo
- @parent.tagfont_configinfo(@id)
- end
-# alias font font_configinfo
-
- def font_configure(slot)
- @parent.tagfont_configure(@id, slot)
- self
- end
-
- def latinfont_configure(ltn, keys=nil)
- @parent.latintagfont_configure(@id, ltn, keys)
- self
- end
- alias asciifont_configure latinfont_configure
-
- def kanjifont_configure(knj, keys=nil)
- @parent.kanjitagfont_configure(@id, ltn, keys)
- self
- end
-
- def font_copy(window, wintag=nil)
- @parent.tagfont_copy(@id, window, wintag)
- self
- end
-
- def latinfont_copy(window, wintag=nil)
- @parent.latintagfont_copy(@id, window, wintag)
- self
- end
- alias asciifont_copy latinfont_copy
-
- def kanjifont_copy(window, wintag=nil)
- @parent.kanjitagfont_copy(@id, window, wintag)
- self
- end
-end
diff --git a/ext/tk/lib/tkmacpkg.rb b/ext/tk/lib/tkmacpkg.rb
deleted file mode 100644
index 3bac5e6c3e..0000000000
--- a/ext/tk/lib/tkmacpkg.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-#
-# tkmacpkg.rb : methods for Tcl/Tk packages for Macintosh
-# 2000/11/22 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
-#
-# ATTENTION !!
-# This is NOT TESTED. Because I have no test-environment.
-#
-#
-require 'tk'
-
-module TkMacResource
- extend Tk
- extend TkMacResource
-
- TkCommandNames = ['resource'.freeze].freeze
-
- tk_call('package', 'require', 'resource')
-
- def close(rsrcRef)
- tk_call('resource', 'close', rsrcRef)
- end
-
- def delete(rsrcType, opts=nil)
- tk_call('resource', 'delete', *(hash_kv(opts) + rsrcType))
- end
-
- def files(rsrcRef=nil)
- if rsrcRef
- tk_call('resource', 'files', rsrcRef)
- else
- tk_split_simplelist(tk_call('resource', 'files'))
- end
- end
-
- def list(rsrcType, rsrcRef=nil)
- tk_split_simplelist(tk_call('resource', 'list', rsrcType, rsrcRef))
- end
-
- def open(fname, access=nil)
- tk_call('resource', 'open', fname, access)
- end
-
- def read(rsrcType, rsrcID, rsrcRef=nil)
- tk_call('resource', 'read', rsrcType, rsrcID, rsrcRef)
- end
-
- def types(rsrcRef=nil)
- tk_split_simplelist(tk_call('resource', 'types', rsrcRef))
- end
-
- def write(rsrcType, data, opts=nil)
- tk_call('resource', 'write', *(hash_kv(opts) + rsrcType + data))
- end
-
- module_function :close, :delete, :files, :list, :open, :read, :types, :write
-end
diff --git a/ext/tk/lib/tkmenubar.rb b/ext/tk/lib/tkmenubar.rb
deleted file mode 100644
index 0d29571eb7..0000000000
--- a/ext/tk/lib/tkmenubar.rb
+++ /dev/null
@@ -1,143 +0,0 @@
-#
-# tkmenubar.rb
-#
-# Copyright (C) 1998 maeda shugo. All rights reserved.
-# This file can be distributed under the terms of the Ruby.
-
-# Usage:
-#
-# menu_spec = [
-# [['File', 0],
-# ['Open', proc{puts('Open clicked')}, 0],
-# '---',
-# ['Quit', proc{exit}, 0]],
-# [['Edit', 0],
-# ['Cut', proc{puts('Cut clicked')}, 2],
-# ['Copy', proc{puts('Copy clicked')}, 0],
-# ['Paste', proc{puts('Paste clicked')}, 0]]
-# ]
-# menubar = TkMenubar.new(nil, menu_spec,
-# 'tearoff'=>false,
-# 'foreground'=>'grey40',
-# 'activeforeground'=>'red',
-# 'font'=>'-adobe-helvetica-bold-r-*--12-*-iso8859-1')
-# menubar.pack('side'=>'top', 'fill'=>'x')
-#
-#
-# OR
-#
-#
-# menubar = TkMenubar.new
-# menubar.add_menu([['File', 0],
-# ['Open', proc{puts('Open clicked')}, 0],
-# '---',
-# ['Quit', proc{exit}, 0]])
-# menubar.add_menu([['Edit', 0],
-# ['Cut', proc{puts('Cut clicked')}, 2],
-# ['Copy', proc{puts('Copy clicked')}, 0],
-# ['Paste', proc{puts('Paste clicked')}, 0]])
-# menubar.configure('tearoff', false)
-# menubar.configure('foreground', 'grey40')
-# menubar.configure('activeforeground', 'red')
-# menubar.configure('font', '-adobe-helvetica-bold-r-*--12-*-iso8859-1')
-# menubar.pack('side'=>'top', 'fill'=>'x')
-
-# The format of the menu_spec is:
-# [
-# [
-# [button text, underline, accelerator],
-# [menu label, command, underline, accelerator],
-# '---', # separator
-# ...
-# ],
-# ...
-# ]
-
-# underline and accelerator are optional parameters.
-# Hashes are OK instead of Arrays.
-
-# To use add_menu, configuration must be done by calling configure after
-# adding all menus by add_menu, not by the constructor arguments.
-
-require "tk"
-
-class TkMenubar<TkFrame
-
- include TkComposite
-
- def initialize(parent = nil, spec = nil, options = nil)
- if parent.kind_of? Hash
- options = _symbolkey2str(parent)
- spec = options.delete('spec')
- super(options)
- else
- super(parent, options)
- end
-
- @menus = []
-
- if spec
- for menu_info in spec
- add_menu(menu_info)
- end
- end
-
- if options
- for key, value in options
- configure(key, value)
- end
- end
- end
-
- def add_menu(menu_info)
- btn_info = menu_info.shift
- mbtn = TkMenubutton.new(@frame)
-
- if btn_info.kind_of?(Hash)
- for key, value in btn_info
- mbtn.configure(key, value)
- end
- elsif btn_info.kind_of?(Array)
- mbtn.configure('text', btn_info[0]) if btn_info[0]
- mbtn.configure('underline', btn_info[1]) if btn_info[1]
- mbtn.configure('accelerator', btn_info[2]) if btn_info[2]
- else
- mbtn.configure('text', btn_info)
- end
-
- menu = TkMenu.new(mbtn)
-
- for item_info in menu_info
- if item_info.kind_of?(Hash)
- menu.add('command', item_info)
- elsif item_info.kind_of?(Array)
- options = {}
- options['label'] = item_info[0] if item_info[0]
- options['command'] = item_info[1] if item_info[1]
- options['underline'] = item_info[2] if item_info[2]
- options['accelerator'] = item_info[3] if item_info[3]
- menu.add('command', options)
- elsif /^-+$/ =~ item_info
- menu.add('sep')
- else
- menu.add('command', 'label' => item_info)
- end
- end
-
- mbtn.menu(menu)
- @menus.push([mbtn, menu])
- delegate('tearoff', menu)
- delegate('foreground', mbtn, menu)
- delegate('background', mbtn, menu)
- delegate('disabledforeground', mbtn, menu)
- delegate('activeforeground', mbtn, menu)
- delegate('activebackground', mbtn, menu)
- delegate('font', mbtn, menu)
- delegate('kanjifont', mbtn, menu)
- mbtn.pack('side' => 'left')
- end
-
- def [](index)
- return @menus[index]
- end
-end
diff --git a/ext/tk/lib/tkmngfocus.rb b/ext/tk/lib/tkmngfocus.rb
deleted file mode 100644
index 461525009f..0000000000
--- a/ext/tk/lib/tkmngfocus.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-#
-# tkmngfocus.rb : methods for Tcl/Tk standard library 'focus.tcl'
-# by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
-#
-require 'tk'
-
-module TkManageFocus
- extend Tk
-
- TkCommandNames = [
- 'tk_focusFollowMouse'.freeze,
- 'tk_focusNext'.freeze,
- 'tk_focusPrev'.freeze
- ].freeze
-
- def TkManageFocus.followsMouse
- tk_call 'tk_focusFollowsMouse'
- end
-
- def TkManageFocus.next(window)
- tk_tcl2ruby(tk_call('tk_focusNext', window))
- end
- def focusNext
- TkManageFocus.next(self)
- end
-
- def TkManageFocus.prev(window)
- tk_tcl2ruby(tk_call('tk_focusPrev', window))
- end
- def focusPrev
- TkManageFocus.prev(self)
- end
-end
diff --git a/ext/tk/lib/tkpalette.rb b/ext/tk/lib/tkpalette.rb
deleted file mode 100644
index dc2fd47e5c..0000000000
--- a/ext/tk/lib/tkpalette.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-#
-# tkpalette.rb : methods for Tcl/Tk standard library 'palette.tcl'
-# 1998/06/21 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
-#
-require 'tk'
-
-module TkPalette
- include Tk
- extend Tk
-
- TkCommandNames = [
- 'tk_setPalette'.freeze,
- 'tk_bisque'.freeze,
- 'tkDarken'.freeze
- ].freeze
-
- def TkPalette.set(*args)
- args = args.to_a.flatten if args.kind_of? Hash
- tk_call 'tk_setPalette', *args
- end
- def TkPalette.setPalette(*args)
- TkPalette.set(*args)
- end
-
- def TkPalette.bisque
- tk_call 'tk_bisque'
- end
-
- def TkPalette.darken(color, percent)
- tk_call 'tkDarken', color, percent
- end
-
- def TkPalette.recolorTree(window, colors)
- if not colors.kind_of?(Hash)
- fail "2nd arg need to be Hash"
- end
-
- colors.each{|key, value|
- begin
- if window.cget(key) == tk_call('set', "tkPalette(#{key})")
- window[key] = colors[key]
- end
- rescue
- # ignore
- end
- }
-
- TkWinfo.children(window).each{|w| TkPalette.recolorTree(w, colors)}
- end
-
- def recolorTree(colors)
- TkPalette.recolorTree(self, colors)
- end
-end
diff --git a/ext/tk/lib/tkscrollbox.rb b/ext/tk/lib/tkscrollbox.rb
deleted file mode 100644
index 3f1191c740..0000000000
--- a/ext/tk/lib/tkscrollbox.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-#
-# tkscrollbox.rb - Tk Listbox with Scrollbar
-# as an example of Composite Widget
-# $Date$
-# by Yukihiro Matsumoto <matz@netlab.co.jp>
-
-require 'tk.rb'
-
-class TkScrollbox<TkListbox
- include TkComposite
- def initialize_composite(keys=nil)
- list = TkListbox.new(@frame)
- scroll = TkScrollbar.new(@frame)
- @path = list.path
-
- list.configure 'yscroll', scroll.path+" set"
- list.pack 'side'=>'left','fill'=>'both','expand'=>'yes'
- scroll.configure 'command', list.path+" yview"
- scroll.pack 'side'=>'right','fill'=>'y'
-
- delegate('DEFAULT', list)
- delegate('foreground', list)
- delegate('background', list, scroll)
- delegate('borderwidth', @frame)
- delegate('relief', @frame)
-
- configure keys if keys
- end
- private :initialize_composite
-end
diff --git a/ext/tk/lib/tktext.rb b/ext/tk/lib/tktext.rb
deleted file mode 100644
index 44dc6cc3b8..0000000000
--- a/ext/tk/lib/tktext.rb
+++ /dev/null
@@ -1,1302 +0,0 @@
-#
-# tktext.rb - Tk text classes
-# $Date$
-# by Yukihiro Matsumoto <matz@caelum.co.jp>
-
-require 'tk.rb'
-require 'tkfont'
-
-module TkTreatTextTagFont
- include TkTreatItemFont
-
- ItemCMD = ['tag'.freeze, 'configure'.freeze].freeze
- def __conf_cmd(idx)
- ItemCMD[idx]
- end
-
- def __item_pathname(tagOrId)
- if tagOrId.kind_of?(TkTextTag)
- self.path + ';' + tagOrId.id
- else
- self.path + ';' + tagOrId
- end
- end
-
- private :__conf_cmd, :__item_pathname
-end
-
-class TkText<TkTextWin
- ItemConfCMD = ['tag'.freeze, 'configure'.freeze].freeze
- include TkTreatTextTagFont
- include Scrollable
-
- TkCommandNames = ['text'.freeze].freeze
- WidgetClassName = 'Text'.freeze
- WidgetClassNames[WidgetClassName] = self
-
- def self.new(*args, &block)
- obj = super(*args){}
- obj.init_instance_variable
- obj.instance_eval(&block) if defined? yield
- obj
- end
-
- def init_instance_variable
- @cmdtbl = []
- @tags = {}
- end
-
- def __destroy_hook__
- TTagID_TBL.delete(@path)
- TMarkID_TBL.delete(@path)
- end
-
- def create_self(keys)
- if keys and keys != None
- tk_call 'text', @path, *hash_kv(keys)
- else
- tk_call 'text', @path
- end
- init_instance_variable
- end
- private :create_self
-
- def index(index)
- tk_send 'index', index
- end
-
- def value
- tk_send 'get', "1.0", "end - 1 char"
- end
-
- def value= (val)
- tk_send 'delete', "1.0", 'end'
- tk_send 'insert', "1.0", val
- end
-
- def _addcmd(cmd)
- @cmdtbl.push cmd
- end
-
- def _addtag(name, obj)
- @tags[name] = obj
- end
-
- def tagid2obj(tagid)
- if @tags[tagid]
- @tags[tagid]
- else
- tagid
- end
- end
-
- def tag_names(index=None)
- tk_split_simplelist(tk_send('tag', 'names', index)).collect{|elt|
- tagid2obj(elt)
- }
- end
-
- def mark_names
- tk_split_simplelist(tk_send('mark', 'names')).collect{|elt|
- tagid2obj(elt)
- }
- end
-
- def mark_gravity(mark, direction=nil)
- if direction
- tk_send 'mark', 'gravity', mark, direction
- self
- else
- tk_send 'mark', 'gravity', mark
- end
- end
-
- def mark_set(mark, index)
- tk_send 'mark', 'set', mark, index
- self
- end
- alias set_mark mark_set
-
- def mark_unset(*marks)
- tk_send 'mark', 'unset', *marks
- self
- end
- alias unset_mark mark_unset
-
- def mark_next(index)
- tagid2obj(tk_send('mark', 'next', index))
- end
- alias next_mark mark_next
-
- def mark_previous(index)
- tagid2obj(tk_send('mark', 'previous', index))
- end
- alias previous_mark mark_previous
-
- def image_cget(index, slot)
- case slot.to_s
- when 'text', 'label', 'show', 'data', 'file'
- tk_send('image', 'cget', index, "-#{slot}")
- else
- tk_tcl2ruby(tk_send('image', 'cget', index, "-#{slot}"))
- end
- end
-
- def image_configure(index, slot, value=None)
- if slot.kind_of? Hash
- tk_send('image', 'configure', index, *hash_kv(slot))
- else
- tk_send('image', 'configure', index, "-#{slot}", value)
- end
- self
- end
-
- def image_configinfo(index, slot = nil)
- if slot
- case slot.to_s
- when 'text', 'label', 'show', 'data', 'file'
- conf = tk_split_simplelist(tk_send('image', 'configure',
- index, "-#{slot}"))
- else
- conf = tk_split_list(tk_send('image', 'configure',
- index, "-#{slot}"))
- end
- conf[0] = conf[0][1..-1]
- conf
- else
- tk_split_simplelist(tk_send('image', 'configure',
- index)).collect{|conflist|
- conf = tk_split_simplelist(conflist)
- conf[0] = conf[0][1..-1]
- case conf[0]
- when 'text', 'label', 'show', 'data', 'file'
- else
- if conf[3]
- if conf[3].index('{')
- conf[3] = tk_split_list(conf[3])
- else
- conf[3] = tk_tcl2ruby(conf[3])
- end
- end
- if conf[4]
- if conf[4].index('{')
- conf[4] = tk_split_list(conf[4])
- else
- conf[4] = tk_tcl2ruby(conf[4])
- end
- end
- end
- conf
- }
- end
- end
-
- def image_names
- tk_split_simplelist(tk_send('image', 'names')).collect{|elt|
- tagid2obj(elt)
- }
- end
-
- def set_insert(index)
- tk_send 'mark', 'set', 'insert', index
- self
- end
-
- def set_current(index)
- tk_send 'mark', 'set', 'current', index
- self
- end
-
- def insert(index, chars, *tags)
- if tags[0].kind_of? Array
- # multiple chars-taglist argument
- args = [chars]
- while tags.size > 0
- tags.shift.collect{|x|_get_eval_string(x)}.join(' ') # taglist
- args << tags.shift if tags.size > 0 # chars
- end
- super index, *args
- else
- # single chars-taglist argument
- super index, chars, tags.collect{|x|_get_eval_string(x)}.join(' ')
- end
- end
-
- def destroy
- @tags = {} unless @tags
- @tags.each_value do |t|
- t.destroy
- end
- super
- end
-
- def backspace
- self.delete 'insert'
- end
-
- def compare(idx1, op, idx2)
- bool(tk_send('compare', idx1, op, idx2))
- end
-
- def debug
- bool(tk_send('debug'))
- end
- def debug=(boolean)
- tk_send 'debug', boolean
- self
- end
- def bbox(index)
- list(tk_send('bbox', index))
- end
-
- def dlineinfo(index)
- list(tk_send('dlineinfo', index))
- end
-
- def modified?
- bool(tk_send('edit', 'modified'))
- end
- def modified(mode)
- tk_send('edit', 'modified', mode)
- self
- end
- def edit_redo
- tk_send('edit', 'redo')
- self
- end
- def edit_reset
- tk_send('edit', 'reset')
- self
- end
- def edit_separator
- tk_send('edit', 'separator')
- self
- end
- def edit_undo
- tk_send('edit', 'undo')
- self
- end
-
- def yview_pickplace(*what)
- tk_send 'yview', '-pickplace', *what
- self
- end
-
- def xview_pickplace(*what)
- tk_send 'xview', '-pickplace', *what
- self
- end
-
- def text_copy
- # Tk8.4 feature
- tk_call('tk_textCopy', @path)
- end
-
- def text_cut
- # Tk8.4 feature
- tk_call('tk_textCut', @path)
- end
-
- def text_paste
- # Tk8.4 feature
- tk_call('tk_textPaste', @path)
- end
-
- def tag_add(tag, index1, index2=None)
- tk_send 'tag', 'add', tag, index1, index2
- self
- end
- alias addtag tag_add
- alias add_tag tag_add
-
- def tag_delete(*tags)
- tk_send 'tag', 'delete', *tags
- if TkTextTag::TTagID_TBL[@path]
- tags.each{|tag|
- if tag.kind_of? TkTextTag
- TTagID_TBL[@path].delete(tag.id)
- else
- TTagID_TBL[@path].delete(tag)
- end
- }
- end
- self
- end
- alias deltag tag_delete
- alias delete_tag tag_delete
-
- def tag_bind(tag, seq, cmd=Proc.new, args=nil)
- _bind([@path, 'tag', 'bind', tag], seq, cmd, args)
- self
- end
-
- def tag_bind_append(tag, seq, cmd=Proc.new, args=nil)
- _bind_append([@path, 'tag', 'bind', tag], seq, cmd, args)
- self
- end
-
- def tag_bind_remove(tag, seq)
- _bind_remove([@path, 'tag', 'bind', tag], seq)
- self
- end
-
- def tag_bindinfo(tag, context=nil)
- _bindinfo([@path, 'tag', 'bind', tag], context)
- end
-
- def tag_cget(tag, key)
- case key.to_s
- when 'text', 'label', 'show', 'data', 'file'
- tk_call(@path, 'tag', 'cget', tag, "-#{key}")
- when 'font', 'kanjifont'
- #fnt = tk_tcl2ruby(tk_send('tag', 'cget', tag, "-#{key}"))
- fnt = tk_tcl2ruby(tk_send('tag', 'cget', tag, '-font'))
- unless fnt.kind_of?(TkFont)
- fnt = tagfontobj(tag, fnt)
- end
- if key.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
- # obsolete; just for compatibility
- fnt.kanji_font
- else
- fnt
- end
- else
- tk_tcl2ruby(tk_call(@path, 'tag', 'cget', tag, "-#{key}"))
- end
- end
-
- def tag_configure(tag, key, val=None)
- if key.kind_of? Hash
- key = _symbolkey2str(key)
- if ( key['font'] || key['kanjifont'] \
- || key['latinfont'] || key['asciifont'] )
- tagfont_configure(tag, key)
- else
- tk_send 'tag', 'configure', tag, *hash_kv(key)
- end
-
- else
- if key == 'font' || key == :font ||
- key == 'kanjifont' || key == :kanjifont ||
- key == 'latinfont' || key == :latinfont ||
- key == 'asciifont' || key == :asciifont
- if val == None
- tagfontobj(tag)
- else
- tagfont_configure(tag, {key=>val})
- end
- else
- tk_send 'tag', 'configure', tag, "-#{key}", val
- end
- end
- self
- end
-
- def tag_configinfo(tag, key=nil)
- if key
- case key.to_s
- when 'text', 'label', 'show', 'data', 'file'
- conf = tk_split_simplelist(tk_send('tag','configure',tag,"-#{key}"))
- when 'font', 'kanjifont'
- conf = tk_split_simplelist(tk_send('tag','configure',tag,"-#{key}") )
- conf[4] = tagfont_configinfo(tag, conf[4])
- else
- conf = tk_split_list(tk_send('tag','configure',tag,"-#{key}"))
- end
- conf[0] = conf[0][1..-1]
- conf
- else
- ret = tk_split_simplelist(tk_send('tag', 'configure',
- tag)).collect{|conflist|
- conf = tk_split_simplelist(conflist)
- conf[0] = conf[0][1..-1]
- case conf[0]
- when 'text', 'label', 'show', 'data', 'file'
- else
- if conf[3]
- if conf[3].index('{')
- conf[3] = tk_split_list(conf[3])
- else
- conf[3] = tk_tcl2ruby(conf[3])
- end
- end
- if conf[4]
- if conf[4].index('{')
- conf[4] = tk_split_list(conf[4])
- else
- conf[4] = tk_tcl2ruby(conf[4])
- end
- end
- end
- conf
- }
- fontconf = ret.assoc('font')
- if fontconf
- ret.delete_if{|item| item[0] == 'font' || item[0] == 'kanjifont'}
- fontconf[4] = tagfont_configinfo(tag, fontconf[4])
- ret.push(fontconf)
- else
- ret
- end
- end
- end
-
- def tag_raise(tag, above=None)
- tk_send 'tag', 'raise', tag, above
- self
- end
-
- def tag_lower(tag, below=None)
- tk_send 'tag', 'lower', tag, below
- self
- end
-
- def tag_remove(tag, *index)
- tk_send 'tag', 'remove', tag, *index
- self
- end
-
- def tag_ranges(tag)
- l = tk_split_simplelist(tk_send('tag', 'ranges', tag))
- r = []
- while key=l.shift
- r.push [key, l.shift]
- end
- r
- end
-
- def tag_nextrange(tag, first, last=None)
- tk_split_list(tk_send('tag', 'nextrange', tag, first, last))
- end
-
- def tag_prevrange(tag, first, last=None)
- tk_split_list(tk_send('tag', 'prevrange', tag, first, last))
- end
-
- def window_cget(index, slot)
- case slot.to_s
- when 'text', 'label', 'show', 'data', 'file'
- tk_send('window', 'cget', index, "-#{slot}")
- when 'font', 'kanjifont'
- #fnt = tk_tcl2ruby(tk_send('window', 'cget', index, "-#{slot}"))
- fnt = tk_tcl2ruby(tk_send('window', 'cget', index, '-font'))
- unless fnt.kind_of?(TkFont)
- fnt = tagfontobj(index, fnt)
- end
- if slot.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
- # obsolete; just for compatibility
- fnt.kanji_font
- else
- fnt
- end
- else
- tk_tcl2ruby(tk_send('window', 'cget', index, "-#{slot}"))
- end
- end
-
- def window_configure(index, slot, value=None)
- if index.kind_of? TkTextWindow
- index.configure(slot, value)
- else
- if slot.kind_of? Hash
- tk_send('window', 'configure', index, *hash_kv(slot))
- else
- tk_send('window', 'configure', index, "-#{slot}", value)
- end
- end
- self
- end
-
- def window_configinfo(win, slot = nil)
- if slot
- case slot.to_s
- when 'text', 'label', 'show', 'data', 'file'
- conf = tk_split_simplelist(tk_send('window', 'configure',
- win, "-#{slot}"))
- else
- conf = tk_split_list(tk_send('window', 'configure',
- win, "-#{slot}"))
- end
- conf[0] = conf[0][1..-1]
- conf
- else
- tk_split_simplelist(tk_send('window', 'configure',
- win)).collect{|conflist|
- conf = tk_split_simplelist(conflist)
- conf[0] = conf[0][1..-1]
- case conf[0]
- when 'text', 'label', 'show', 'data', 'file'
- else
- if conf[3]
- if conf[3].index('{')
- conf[3] = tk_split_list(conf[3])
- else
- conf[3] = tk_tcl2ruby(conf[3])
- end
- end
- if conf[4]
- if conf[4].index('{')
- conf[4] = tk_split_list(conf[4])
- else
- conf[4] = tk_tcl2ruby(conf[4])
- end
- end
- end
- conf
- }
- end
- end
-
- def window_names
- tk_split_simplelist(tk_send('window', 'names')).collect{|elt|
- tagid2obj(elt)
- }
- end
-
- def _ktext_length(txt)
- if $KCODE !~ /n/i
- return txt.gsub(/[^\Wa-zA-Z_\d]/, ' ').length
- end
-
- # $KCODE == 'NONE'
- if JAPANIZED_TK
- tk_call('kstring', 'length', txt).to_i
- else
- begin
- tk_call('encoding', 'convertto', 'ascii', txt).length
- rescue StandardError, NameError
- # sorry, I have no plan
- txt.length
- end
- end
- end
- private :_ktext_length
-
- def search_with_length(pat,start,stop=None)
- pat = pat.chr if pat.kind_of? Integer
- if stop != None
- return ["", 0] if compare(start,'>=',stop)
- txt = get(start,stop)
- if (pos = txt.index(pat))
- match = $&
- #pos = txt[0..(pos-1)].split('').length if pos > 0
- pos = _ktext_length(txt[0..(pos-1)]) if pos > 0
- if pat.kind_of? String
- #return [index(start + " + #{pos} chars"), pat.split('').length]
- return [index(start + " + #{pos} chars"),
- _ktext_length(pat), pat.dup]
- else
- #return [index(start + " + #{pos} chars"), $&.split('').length]
- return [index(start + " + #{pos} chars"),
- _ktext_length(match), match]
- end
- else
- return ["", 0]
- end
- else
- txt = get(start,'end - 1 char')
- if (pos = txt.index(pat))
- match = $&
- #pos = txt[0..(pos-1)].split('').length if pos > 0
- pos = _ktext_length(txt[0..(pos-1)]) if pos > 0
- if pat.kind_of? String
- #return [index(start + " + #{pos} chars"), pat.split('').length]
- return [index(start + " + #{pos} chars"),
- _ktext_length(pat), pat.dup]
- else
- #return [index(start + " + #{pos} chars"), $&.split('').length]
- return [index(start + " + #{pos} chars"),
- _ktext_length(match), match]
- end
- else
- txt = get('1.0','end - 1 char')
- if (pos = txt.index(pat))
- match = $&
- #pos = txt[0..(pos-1)].split('').length if pos > 0
- pos = _ktext_length(txt[0..(pos-1)]) if pos > 0
- if pat.kind_of? String
- #return [index("1.0 + #{pos} chars"), pat.split('').length]
- return [index("1.0 + #{pos} chars"),
- _ktext_length(pat), pat.dup]
- else
- #return [index("1.0 + #{pos} chars"), $&.split('').length]
- return [index("1.0 + #{pos} chars"), _ktext_length(match), match]
- end
- else
- return ["", 0]
- end
- end
- end
- end
-
- def search(pat,start,stop=None)
- search_with_length(pat,start,stop)[0]
- end
-
- def rsearch_with_length(pat,start,stop=None)
- pat = pat.chr if pat.kind_of? Integer
- if stop != None
- return ["", 0] if compare(start,'<=',stop)
- txt = get(stop,start)
- if (pos = txt.rindex(pat))
- match = $&
- #pos = txt[0..(pos-1)].split('').length if pos > 0
- pos = _ktext_length(txt[0..(pos-1)]) if pos > 0
- if pat.kind_of? String
- #return [index(stop + " + #{pos} chars"), pat.split('').length]
- return [index(stop + " + #{pos} chars"), _ktext_length(pat), pat.dup]
- else
- #return [index(stop + " + #{pos} chars"), $&.split('').length]
- return [index(stop + " + #{pos} chars"), _ktext_length(match), match]
- end
- else
- return ["", 0]
- end
- else
- txt = get('1.0',start)
- if (pos = txt.rindex(pat))
- match = $&
- #pos = txt[0..(pos-1)].split('').length if pos > 0
- pos = _ktext_length(txt[0..(pos-1)]) if pos > 0
- if pat.kind_of? String
- #return [index("1.0 + #{pos} chars"), pat.split('').length]
- return [index("1.0 + #{pos} chars"), _ktext_length(pat), pat.dup]
- else
- #return [index("1.0 + #{pos} chars"), $&.split('').length]
- return [index("1.0 + #{pos} chars"), _ktext_length(match), match]
- end
- else
- txt = get('1.0','end - 1 char')
- if (pos = txt.rindex(pat))
- match = $&
- #pos = txt[0..(pos-1)].split('').length if pos > 0
- pos = _ktext_length(txt[0..(pos-1)]) if pos > 0
- if pat.kind_of? String
- #return [index("1.0 + #{pos} chars"), pat.split('').length]
- return [index("1.0 + #{pos} chars"), _ktext_length(pat), pat.dup]
- else
- #return [index("1.0 + #{pos} chars"), $&.split('').length]
- return [index("1.0 + #{pos} chars"), _ktext_length(match), match]
- end
- else
- return ["", 0]
- end
- end
- end
- end
-
- def rsearch(pat,start,stop=None)
- rsearch_with_length(pat,start,stop)[0]
- end
-
- def dump(type_info, *index, &block)
- args = type_info.collect{|inf| '-' + inf}
- args << '-command' << block if block
- str = tk_send('dump', *(args + index))
- result = []
- sel = nil
- i = 0
- while i < str.size
- # retrieve key
- idx = str.index(/ /, i)
- result.push str[i..(idx-1)]
- i = idx + 1
-
- # retrieve value
- case result[-1]
- when 'text'
- if str[i] == ?{
- # text formed as {...}
- val, i = _retrieve_braced_text(str, i)
- result.push val
- else
- # text which may contain backslahes
- val, i = _retrieve_backslashed_text(str, i)
- result.push val
- end
- else
- idx = str.index(/ /, i)
- val = str[i..(idx-1)]
- case result[-1]
- when 'mark'
- case val
- when 'insert'
- result.push TkTextMarkInsert.new(self)
- when 'current'
- result.push TkTextMarkCurrent.new(self)
- when 'anchor'
- result.push TkTextMarkAnchor.new(self)
- else
- result.push tk_tcl2ruby(val)
- end
- when 'tagon'
- if val == 'sel'
- if sel
- result.push sel
- else
- result.push TkTextTagSel.new(self)
- end
- else
- result.push tk_tcl2ruby(val)
- end
- when 'tagoff'
- result.push tk_tcl2ruby(val)
- when 'window'
- result.push tk_tcl2ruby(val)
- end
- i = idx + 1
- end
-
- # retrieve index
- idx = str.index(/ /, i)
- if idx
- result.push str[i..(idx-1)]
- i = idx + 1
- else
- result.push str[i..-1]
- break
- end
- end
-
- kvis = []
- until result.empty?
- kvis.push [result.shift, result.shift, result.shift]
- end
- kvis # result is [[key1, value1, index1], [key2, value2, index2], ...]
- end
-
- def _retrieve_braced_text(str, i)
- cnt = 0
- idx = i
- while idx < str.size
- case str[idx]
- when ?{
- cnt += 1
- when ?}
- cnt -= 1
- if cnt == 0
- break
- end
- end
- idx += 1
- end
- return str[i+1..idx-1], idx + 2
- end
- private :_retrieve_braced_text
-
- def _retrieve_backslashed_text(str, i)
- j = i
- idx = nil
- loop {
- idx = str.index(/ /, j)
- if str[idx-1] == ?\\
- j += 1
- else
- break
- end
- }
- val = str[i..(idx-1)]
- val.gsub!(/\\( |\{|\})/, '\1')
- return val, idx + 1
- end
- private :_retrieve_backslashed_text
-
- def dump_all(*index, &block)
- dump(['all'], *index, &block)
- end
- def dump_mark(*index, &block)
- dump(['mark'], *index, &block)
- end
- def dump_tag(*index, &block)
- dump(['tag'], *index, &block)
- end
- def dump_text(*index, &block)
- dump(['text'], *index, &block)
- end
- def dump_window(*index, &block)
- dump(['window'], *index, &block)
- end
- def dump_image(*index, &block)
- dump(['image'], *index, &block)
- end
-end
-
-class TkTextTag<TkObject
- include TkTreatTagFont
-
- TTagID_TBL = TkCore::INTERP.create_table
- Tk_TextTag_ID = ['tag'.freeze, '00000'.taint].freeze
-
- TkCore::INTERP.init_ip_env{ TTagID_TBL.clear }
-
- def TkTextTag.id2obj(text, id)
- tpath = text.path
- return id unless TTagID_TBL[tpath]
- TTagID_TBL[tpath][id]? TTagID_TBL[tpath][id]: id
- end
-
- def initialize(parent, *args)
- if not parent.kind_of?(TkText)
- fail Kernel.format("%s need to be TkText", parent.inspect)
- end
- @parent = @t = parent
- @tpath = parent.path
- @path = @id = Tk_TextTag_ID.join
- TTagID_TBL[@id] = self
- TTagID_TBL[@tpath] = {} unless TTagID_TBL[@tpath]
- TTagID_TBL[@tpath][@id] = self
- Tk_TextTag_ID[1].succ!
- #tk_call @t.path, "tag", "configure", @id, *hash_kv(keys)
- if args != [] then
- keys = args.pop
- if keys.kind_of? Hash then
- add(*args) if args != []
- configure(keys)
- else
- args.push keys
- add(*args)
- end
- end
- @t._addtag id, self
- end
-
- def id
- @id
- end
-
- def first
- @id + '.first'
- end
-
- def last
- @id + '.last'
- end
-
- def add(*index)
- tk_call @t.path, 'tag', 'add', @id, *index
- self
- end
-
- def remove(*index)
- tk_call @t.path, 'tag', 'remove', @id, *index
- self
- end
-
- def ranges
- l = tk_split_simplelist(tk_call(@t.path, 'tag', 'ranges', @id))
- r = []
- while key=l.shift
- r.push [key, l.shift]
- end
- r
- end
-
- def nextrange(first, last=None)
- tk_split_list(tk_call(@t.path, 'tag', 'nextrange', @id, first, last))
- end
-
- def prevrange(first, last=None)
- tk_split_list(tk_call(@t.path, 'tag', 'prevrange', @id, first, last))
- end
-
- def [](key)
- cget key
- end
-
- def []=(key,val)
- configure key, val
- end
-
- def cget(key)
- case key.to_s
- when 'text', 'label', 'show', 'data', 'file'
- tk_call @t.path, 'tag', 'cget', @id, "-#{key}"
- when 'font', 'kanjifont'
- #fnt = tk_tcl2ruby(tk_call(@t.path, 'tag', 'cget', @id, "-#{key}"))
- fnt = tk_tcl2ruby(tk_call(@t.path, 'tag', 'cget', @id, '-font'))
- unless fnt.kind_of?(TkFont)
- fnt = tagfontobj(@id, fnt)
- end
- if key.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
- # obsolete; just for compatibility
- fnt.kanji_font
- else
- fnt
- end
- else
- tk_tcl2ruby(tk_call(@t.path, 'tag', 'cget', @id, "-#{key}"))
- end
- end
-
- def configure(key, val=None)
- @t.tag_configure @id, key, val
- end
-# def configure(key, val=None)
-# if key.kind_of? Hash
-# tk_call @t.path, 'tag', 'configure', @id, *hash_kv(key)
-# else
-# tk_call @t.path, 'tag', 'configure', @id, "-#{key}", val
-# end
-# end
-# def configure(key, value)
-# if value == FALSE
-# value = "0"
-# elsif value.kind_of? Proc
-# value = install_cmd(value)
-# end
-# tk_call @t.path, 'tag', 'configure', @id, "-#{key}", value
-# end
-
- def configinfo(key=nil)
- @t.tag_configinfo @id, key
- end
-
- def bind(seq, cmd=Proc.new, args=nil)
- _bind([@t.path, 'tag', 'bind', @id], seq, cmd, args)
- self
- end
-
- def bind_append(seq, cmd=Proc.new, args=nil)
- _bind_append([@t.path, 'tag', 'bind', @id], seq, cmd, args)
- self
- end
-
- def bind_remove(seq)
- _bind_remove([@t.path, 'tag', 'bind', @id], seq)
- self
- end
-
- def bindinfo(context=nil)
- _bindinfo([@t.path, 'tag', 'bind', @id], context)
- end
-
- def raise(above=None)
- tk_call @t.path, 'tag', 'raise', @id, above
- self
- end
-
- def lower(below=None)
- tk_call @t.path, 'tag', 'lower', @id, below
- self
- end
-
- def destroy
- tk_call @t.path, 'tag', 'delete', @id
- TTagID_TBL[@tpath].delete(@id) if TTagID_TBL[@tpath]
- self
- end
-end
-
-class TkTextNamedTag<TkTextTag
- def self.new(parent, name, *args)
- if TTagID_TBL[parent.path] && TTagID_TBL[parent.path][name]
- tagobj = TTagID_TBL[parent.path][name]
- if args != [] then
- keys = args.pop
- if keys.kind_of? Hash then
- tagobj.add(*args) if args != []
- tagobj.configure(keys)
- else
- args.push keys
- tagobj.add(*args)
- end
- end
- return tagobj
- else
- super(parent, name, *args)
- end
- end
-
- def initialize(parent, name, *args)
- if not parent.kind_of?(TkText)
- fail Kernel.format("%s need to be TkText", parent.inspect)
- end
- @parent = @t = parent
- @tpath = parent.path
- @path = @id = name
- TTagID_TBL[@tpath] = {} unless TTagID_TBL[@tpath]
- TTagID_TBL[@tpath][@id] = self unless TTagID_TBL[@tpath][@id]
- #if mode
- # tk_call @t.path, "addtag", @id, *args
- #end
- if args != [] then
- keys = args.pop
- if keys.kind_of? Hash then
- add(*args) if args != []
- configure(keys)
- else
- args.push keys
- add(*args)
- end
- end
- @t._addtag id, self
- end
-end
-
-class TkTextTagSel<TkTextNamedTag
- def self.new(parent, *args)
- super(parent, 'sel', *args)
- end
-end
-
-class TkTextMark<TkObject
- TMarkID_TBL = TkCore::INTERP.create_table
- Tk_TextMark_ID = ['mark'.freeze, '00000'.taint].freeze
-
- TkCore::INTERP.init_ip_env{ TMarkID_TBL.clear }
-
- def TkTextMark.id2obj(text, id)
- tpath = text.path
- return id unless TMarkID_TBL[tpath]
- TMarkID_TBL[tpath][id]? TMarkID_TBL[tpath][id]: id
- end
-
- def initialize(parent, index)
- if not parent.kind_of?(TkText)
- fail Kernel.format("%s need to be TkText", parent.inspect)
- end
- @parent = @t = parent
- @tpath = parent.path
- @path = @id = Tk_TextMark_ID.join
- TMarkID_TBL[@id] = self
- TMarkID_TBL[@tpath] = {} unless TMarkID_TBL[@tpath]
- TMarkID_TBL[@tpath][@id] = self
- Tk_TextMark_ID[1].succ!
- tk_call @t.path, 'mark', 'set', @id, index
- @t._addtag id, self
- end
-
- def id
- @id
- end
-
- def +(mod)
- @id + ' + ' + mod
- end
- def -(mod)
- @id + ' - ' + mod
- end
-
- def set(where)
- tk_call @t.path, 'mark', 'set', @id, where
- self
- end
-
- def unset
- tk_call @t.path, 'mark', 'unset', @id
- self
- end
- alias destroy unset
-
- def gravity
- tk_call @t.path, 'mark', 'gravity', @id
- end
-
- def gravity=(direction)
- tk_call @t.path, 'mark', 'gravity', @id, direction
- self
- end
-
- def next(index = nil)
- if index
- @t.tagid2obj(tk_call(@t.path, 'mark', 'next', index))
- else
- @t.tagid2obj(tk_call(@t.path, 'mark', 'next', @id))
- end
- end
-
- def previous(index = nil)
- if index
- @t.tagid2obj(tk_call(@t.path, 'mark', 'previous', index))
- else
- @t.tagid2obj(tk_call(@t.path, 'mark', 'previous', @id))
- end
- end
-end
-
-class TkTextNamedMark<TkTextMark
- def self.new(parent, name, *args)
- if TMarkID_TBL[parent.path] && TMarkID_TBL[parent.path][name]
- return TMarkID_TBL[parent.path][name]
- else
- super(parent, name, *args)
- end
- end
-
- def initialize(parent, name, index=nil)
- if not parent.kind_of?(TkText)
- fail Kernel.format("%s need to be TkText", parent.inspect)
- end
- @parent = @t = parent
- @tpath = parent.path
- @path = @id = name
- TMarkID_TBL[@id] = self
- TMarkID_TBL[@tpath] = {} unless TMarkID_TBL[@tpath]
- TMarkID_TBL[@tpath][@id] = self unless TMarkID_TBL[@tpath][@id]
- tk_call @t.path, 'mark', 'set', @id, index if index
- @t._addtag id, self
- end
-end
-
-class TkTextMarkInsert<TkTextNamedMark
- def self.new(parent,*args)
- super(parent, 'insert', *args)
- end
-end
-
-class TkTextMarkCurrent<TkTextMark
- def self.new(parent,*args)
- super(parent, 'current', *args)
- end
-end
-
-class TkTextMarkAnchor<TkTextMark
- def self.new(parent,*args)
- super(parent, 'anchor', *args)
- end
-end
-
-class TkTextWindow<TkObject
- def initialize(parent, index, keys)
- if not parent.kind_of?(TkText)
- fail Kernel.format("%s need to be TkText", parent.inspect)
- end
- @t = parent
- if index == 'end'
- @path = TkTextMark.new(@t, tk_call(@t.path, 'index', 'end - 1 chars'))
- elsif index.kind_of? TkTextMark
- if tk_call(@t.path,'index',index.path) == tk_call(@t.path,'index','end')
- @path = TkTextMark.new(@t, tk_call(@t.path, 'index', 'end - 1 chars'))
- else
- @path = TkTextMark.new(@t, tk_call(@t.path, 'index', index.path))
- end
- else
- @path = TkTextMark.new(@t, tk_call(@t.path, 'index', index))
- end
- @path.gravity = 'left'
- @index = @path.path
- keys = _symbolkey2str(keys)
- @id = keys['window']
- if keys['create']
- @p_create = keys['create']
- if @p_create.kind_of? Proc
- keys['create'] = install_cmd(proc{@id = @p_create.call; @id.path})
- end
- end
- tk_call @t.path, 'window', 'create', @index, *hash_kv(keys)
- end
-
- def [](slot)
- cget(slot)
- end
- def []=(slot, value)
- configure(slot, value)
- end
-
- def cget(slot)
- @t.window_cget(@index, slot)
- end
-
- def configure(slot, value=None)
- if slot.kind_of? Hash
- slot = _symbolkey2str(slot)
- @id = slot['window'] if slot['window']
- if slot['create']
- self.create=value
- slot['create']=nil
- end
- if slot.size > 0
- tk_call(@t.path, 'window', 'configure', @index, *hash_kv(slot))
- end
- else
- @id = value if slot == 'window' || slot == :window
- if slot == 'create' || slot == :create
- self.create=value
- else
- tk_call(@t.path, 'window', 'configure', @index, "-#{slot}", value)
- end
- end
- self
- end
-
- def configinfo(slot = nil)
- @t.window_configinfo(@index, slot)
- end
-
- def window
- @id
- end
-
- def window=(value)
- tk_call @t.path, 'window', 'configure', @index, '-window', value
- @id = value
- end
-
- def create
- @p_create
- end
-
- def create=(value)
- @p_create = value
- if @p_create.kind_of? Proc
- value = install_cmd(proc{@id = @p_create.call})
- end
- tk_call @t.path, 'window', 'configure', @index, '-create', value
- end
-end
-
-class TkTextImage<TkObject
- def initialize(parent, index, keys)
- if not parent.kind_of?(TkText)
- fail Kernel.format("%s need to be TkText", parent.inspect)
- end
- @t = parent
- if index == 'end'
- @path = TkTextMark.new(@t, tk_call(@t.path, 'index', 'end - 1 chars'))
- elsif index.kind_of? TkTextMark
- if tk_call(@t.path,'index',index.path) == tk_call(@t.path,'index','end')
- @path = TkTextMark.new(@t, tk_call(@t.path, 'index', 'end - 1 chars'))
- else
- @path = TkTextMark.new(@t, tk_call(@t.path, 'index', index.path))
- end
- else
- @path = TkTextMark.new(@t, tk_call(@t.path, 'index', index))
- end
- @path.gravity = 'left'
- @index = @path.path
- @id = tk_call(@t.path, 'image', 'create', @index, *hash_kv(keys))
- end
-
- def [](slot)
- cget(slot)
- end
- def []=(slot, value)
- configure(slot, value)
- end
-
- def cget(slot)
- @t.image_cget(@index, slot)
- end
-
- def configure(slot, value=None)
- @t.image_configure(@index, slot, value)
- self
- end
-# def configure(slot, value)
-# tk_call @t.path, 'image', 'configure', @index, "-#{slot}", value
-# end
-
- def configinfo(slot = nil)
- @t.image_configinfo(@index, slot)
- end
-
- def image
- img = tk_call(@t.path, 'image', 'configure', @index, '-image')
- TkImage::Tk_IMGTBL[img]? TkImage::Tk_IMGTBL[img] : img
- end
-
- def image=(value)
- tk_call @t.path, 'image', 'configure', @index, '-image', value
- self
- end
-end
diff --git a/ext/tk/lib/tkvirtevent.rb b/ext/tk/lib/tkvirtevent.rb
deleted file mode 100644
index ccd3448434..0000000000
--- a/ext/tk/lib/tkvirtevent.rb
+++ /dev/null
@@ -1,85 +0,0 @@
-#
-# tkvirtevent.rb : treats virtual events
-# 1998/07/16 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
-#
-require 'tk'
-
-class TkVirtualEvent<TkObject
- extend Tk
-
- TkCommandNames = ['event'.freeze].freeze
-
- TkVirtualEventID = ["<VirtEvent".freeze, "00000".taint, ">".freeze].freeze
- TkVirtualEventTBL = TkCore::INTERP.create_table
-
- TkCore::INTERP.init_ip_env{ TkVirtualEventTBL.clear }
-
- class PreDefVirtEvent<self
- def initialize(event)
- @path = @id = event
- TkVirtualEvent::TkVirtualEventTBL[@id] = self
- end
- end
-
- def TkVirtualEvent.getobj(event)
- obj = TkVirtualEventTBL[event]
- if obj
- obj
- else
- if tk_call('event', 'info').index("<#{event}>")
- PreDefVirtEvent.new(event)
- else
- fail ArgumentError, "undefined virtual event '<#{event}>'"
- end
- end
- end
-
- def TkVirtualEvent.info
- tk_call('event', 'info').split(/\s+/).collect!{|seq|
- TkVirtualEvent.getobj(seq[1..-2])
- }
- end
-
- def initialize(*sequences)
- @path = @id = TkVirtualEventID.join
- TkVirtualEventID[1].succ!
- add(*sequences)
- end
-
- def add(*sequences)
- if sequences != []
- tk_call('event', 'add', "<#{@id}>",
- *(sequences.collect{|seq| "<#{tk_event_sequence(seq)}>"}) )
- TkVirtualEventTBL[@id] = self
- end
- self
- end
-
- def delete(*sequences)
- if sequences == []
- tk_call('event', 'delete', "<#{@id}>")
- TkVirtualEventTBL.delete(@id)
- else
- tk_call('event', 'delete', "<#{@id}>",
- *(sequences.collect{|seq| "<#{tk_event_sequence(seq)}>"}) )
- TkVirtualEventTBL.delete(@id) if info == []
- end
- self
- end
-
- def info
- tk_call('event', 'info', "<#{@id}>").split(/\s+/).collect!{|seq|
- 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
- }
- end
-end
diff --git a/ext/tk/lib/tkwinpkg.rb b/ext/tk/lib/tkwinpkg.rb
deleted file mode 100644
index 7762b3a596..0000000000
--- a/ext/tk/lib/tkwinpkg.rb
+++ /dev/null
@@ -1,84 +0,0 @@
-#
-# tkwinpkg.rb : methods for Tcl/Tk packages for Microsoft Windows
-# 2000/11/22 by Hidetoshi Nagai <nagai@ai.kyutech.ac.jp>
-#
-# ATTENTION !!
-# This is NOT TESTED. Because I have no test-environment.
-#
-#
-require 'tk'
-
-module TkWinDDE
- extend Tk
- extend TkWinDDE
-
- TkCommandNames = ['dde'.freeze].freeze
-
- tk_call('package', 'require', 'dde')
-
- def servername(topic=nil)
- tk_call('dde', 'servername', topic)
- end
-
- def execute(service, topic, data)
- tk_call('dde', 'execute', service, topic, data)
- end
-
- def async_execute(service, topic, data)
- tk_call('dde', '-async', 'execute', service, topic, data)
- end
-
- def poke(service, topic, item, data)
- tk_call('dde', 'poke', service, topic, item, data)
- end
-
- def request(service, topic, item)
- tk_call('dde', 'request', service, topic, item)
- end
-
- def services(service, topic)
- tk_call('dde', 'services', service, topic)
- end
-
- def eval(topic, cmd, *args)
- tk_call('dde', 'eval', topic, cmd, *args)
- end
-
- module_function :servername, :execute, :async_execute,
- :poke, :request, :services, :eval
-end
-
-module TkWinRegistry
- extend Tk
- extend TkWinRegistry
-
- TkCommandNames = ['registry'.freeze].freeze
-
- tk_call('package', 'require', 'registry')
-
- def delete(keynam, valnam=nil)
- tk_call('registry', 'delete', keynam, valnam)
- end
-
- def get(keynam, valnam)
- tk_call('registry', 'get', keynam, valnam)
- end
-
- def keys(keynam)
- tk_split_simplelist(tk_call('registry', 'keys', keynam))
- end
-
- def set(keynam, valnam=nil, data=nil, dattype=nil)
- tk_call('registry', 'set', keynam, valnam, data, dattype)
- end
-
- def type(keynam, valnam)
- tk_call('registry', 'type', keynam, valnam)
- end
-
- def values(keynam)
- tk_split_simplelist(tk_call('registry', 'values', keynam))
- end
-
- module_function :delete, :get, :keys, :set, :type, :values
-end
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-03 16:26:38 +0000