mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
287a34ae0d
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22784 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2145 lines
57 KiB
Ruby
2145 lines
57 KiB
Ruby
#
|
|
# tkextlib/blt/component.rb
|
|
# by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
|
|
#
|
|
|
|
require 'tk'
|
|
require 'tkextlib/blt.rb'
|
|
|
|
module Tk::BLT
|
|
module PlotComponent
|
|
include TkItemConfigMethod
|
|
|
|
module OptKeys
|
|
def __item_font_optkeys(id)
|
|
['font', 'tickfont', 'titlefont']
|
|
end
|
|
private :__item_font_optkeys
|
|
|
|
def __item_numstrval_optkeys(id)
|
|
['xoffset', 'yoffset']
|
|
end
|
|
private :__item_numstrval_optkeys
|
|
|
|
def __item_boolval_optkeys(id)
|
|
['hide', 'under', 'descending', 'logscale', 'loose', 'showticks',
|
|
'titlealternate', 'scalesymbols', 'minor', 'raised',
|
|
'center', 'decoration', 'landscape', 'maxpect']
|
|
end
|
|
private :__item_boolval_optkeys
|
|
|
|
def __item_strval_optkeys(id)
|
|
['text', 'label', 'limits', 'title',
|
|
'show', 'file', 'maskdata', 'maskfile',
|
|
'color', 'titlecolor', 'fill', 'outline', 'offdash']
|
|
end
|
|
private :__item_strval_optkeys
|
|
|
|
def __item_listval_optkeys(id)
|
|
['bindtags']
|
|
end
|
|
private :__item_listval_optkeys
|
|
|
|
def __item_numlistval_optkeys(id)
|
|
['dashes', 'majorticks', 'minorticks']
|
|
end
|
|
private :__item_numlistval_optkeys
|
|
|
|
def __item_tkvariable_optkeys(id)
|
|
['variable', 'textvariable', 'colormap', 'fontmap']
|
|
end
|
|
private :__item_tkvariable_optkeys
|
|
end
|
|
|
|
include OptKeys
|
|
|
|
def __item_cget_cmd(id)
|
|
if id.kind_of?(Array)
|
|
# id := [ type, name ]
|
|
[self.path, id[0], 'cget', id[1]]
|
|
else
|
|
[self.path, id, 'cget']
|
|
end
|
|
end
|
|
private :__item_cget_cmd
|
|
|
|
def __item_config_cmd(id)
|
|
if id.kind_of?(Array)
|
|
# id := [ type, name, ... ]
|
|
type, *names = id
|
|
[self.path, type, 'configure'].concat(names)
|
|
else
|
|
[self.path, id, 'configure']
|
|
end
|
|
end
|
|
private :__item_config_cmd
|
|
|
|
def __item_pathname(id)
|
|
if id.kind_of?(Array)
|
|
id = tagid(id[1])
|
|
end
|
|
[self.path, id].join(';')
|
|
end
|
|
private :__item_pathname
|
|
|
|
def axis_cget(id, option)
|
|
ret = itemcget(['axis', tagid(id)], option)
|
|
end
|
|
def axis_cget_strict(id, option)
|
|
ret = itemcget_strict(['axis', tagid(id)], option)
|
|
end
|
|
def axis_configure(*args)
|
|
slot = args.pop
|
|
if slot.kind_of?(Hash)
|
|
value = None
|
|
slot = _symbolkey2str(slot)
|
|
if cmd = slot.delete('command')
|
|
slot['command'] = proc{|w, tick|
|
|
cmd.call(TkComm.window(w), TkComm.num_or_str(tick))
|
|
}
|
|
end
|
|
else
|
|
value = slot
|
|
slot = args.pop
|
|
if slot == :command || slot == 'command'
|
|
cmd = value
|
|
value = proc{|w, tick|
|
|
cmd.call(TkComm.window(w), TkComm.num_or_str(tick))
|
|
}
|
|
end
|
|
end
|
|
id_list = args.flatten.collect!{|id| tagid(id)}.unshift('axis')
|
|
itemconfigure(id_list, slot, value)
|
|
end
|
|
def axis_configinfo(id, slot=nil)
|
|
itemconfiginfo(['axis', tagid(id)], slot)
|
|
end
|
|
def current_axis_configinfo(id, slot=nil)
|
|
current_itemconfiginfo(['axis', tagid(id)], slot)
|
|
end
|
|
|
|
def crosshairs_cget(option)
|
|
itemcget('crosshairs', option)
|
|
end
|
|
def crosshairs_cget_strict(option)
|
|
itemcget_strict('crosshairs', option)
|
|
end
|
|
def crosshairs_configure(slot, value=None)
|
|
itemconfigure('crosshairs', slot, value)
|
|
end
|
|
def crosshairs_configinfo(slot=nil)
|
|
itemconfiginfo('crosshairs', slot)
|
|
end
|
|
def current_crosshairs_configinfo(slot=nil)
|
|
current_itemconfiginfo('crosshairs', slot)
|
|
end
|
|
|
|
def element_cget(id, option)
|
|
itemcget(['element', tagid(id)], option)
|
|
end
|
|
def element_cget_strict(id, option)
|
|
itemcget_strict(['element', tagid(id)], option)
|
|
end
|
|
def element_configure(*args)
|
|
slot = args.pop
|
|
if slot.kind_of?(Hash)
|
|
value = None
|
|
else
|
|
value = slot
|
|
slot = args.pop
|
|
end
|
|
id_list = args.flatten.collect!{|id| tagid(id)}.unshift('element')
|
|
itemconfigure(id_list, slot, value)
|
|
end
|
|
def element_configinfo(id, slot=nil)
|
|
itemconfiginfo(['element', tagid(id)], slot)
|
|
end
|
|
def current_element_configinfo(id, slot=nil)
|
|
current_itemconfiginfo(['element', tagid(id)], slot)
|
|
end
|
|
|
|
def bar_cget(id, option)
|
|
itemcget(['bar', tagid(id)], option)
|
|
end
|
|
def bar_cget_strict(id, option)
|
|
itemcget_strict(['bar', tagid(id)], option)
|
|
end
|
|
def bar_configure(*args)
|
|
slot = args.pop
|
|
if slot.kind_of?(Hash)
|
|
value = None
|
|
else
|
|
value = slot
|
|
slot = args.pop
|
|
end
|
|
id_list = args.flatten.collect!{|id| tagid(id)}.unshift('bar')
|
|
itemconfigure(id_list, slot, value)
|
|
end
|
|
def bar_configinfo(id, slot=nil)
|
|
itemconfiginfo(['bar', tagid(id)], slot)
|
|
end
|
|
def current_bar_configinfo(id, slot=nil)
|
|
current_itemconfiginfo(['bar', tagid(id)], slot)
|
|
end
|
|
|
|
def line_cget(id, option)
|
|
itemcget(['line', tagid(id)], option)
|
|
end
|
|
def line_cget_strict(id, option)
|
|
itemcget_strict(['line', tagid(id)], option)
|
|
end
|
|
def line_configure(*args)
|
|
slot = args.pop
|
|
if slot.kind_of?(Hash)
|
|
value = None
|
|
else
|
|
value = slot
|
|
slot = args.pop
|
|
end
|
|
id_list = args.flatten.collect!{|id| tagid(id)}.unshift('line')
|
|
itemconfigure(id_list, slot, value)
|
|
end
|
|
def line_configinfo(id, slot=nil)
|
|
itemconfiginfo(['line', tagid(id)], slot)
|
|
end
|
|
def current_line_configinfo(id, slot=nil)
|
|
current_itemconfiginfo(['line', tagid(id)], slot)
|
|
end
|
|
|
|
def gridline_cget(option)
|
|
itemcget('grid', option)
|
|
end
|
|
def gridline_cget_strict(option)
|
|
itemcget_strict('grid', option)
|
|
end
|
|
def gridline_configure(slot, value=None)
|
|
itemconfigure('grid', slot, value)
|
|
end
|
|
def gridline_configinfo(slot=nil)
|
|
itemconfiginfo('grid', slot)
|
|
end
|
|
def current_gridline_configinfo(slot=nil)
|
|
current_itemconfiginfo('grid', slot)
|
|
end
|
|
|
|
def legend_cget(option)
|
|
itemcget('legend', option)
|
|
end
|
|
def legend_cget_strict(option)
|
|
itemcget_strict('legend', option)
|
|
end
|
|
def legend_configure(slot, value=None)
|
|
itemconfigure('legend', slot, value)
|
|
end
|
|
def legend_configinfo(slot=nil)
|
|
itemconfiginfo('legend', slot)
|
|
end
|
|
def current_legend_configinfo(slot=nil)
|
|
current_itemconfiginfo('legend', slot)
|
|
end
|
|
|
|
def pen_cget(id, option)
|
|
itemcget(['pen', tagid(id)], option)
|
|
end
|
|
def pen_cget_strict(id, option)
|
|
itemcget_strict(['pen', tagid(id)], option)
|
|
end
|
|
def pen_configure(*args)
|
|
slot = args.pop
|
|
if slot.kind_of?(Hash)
|
|
value = None
|
|
else
|
|
value = slot
|
|
slot = args.pop
|
|
end
|
|
id_list = args.flatten.collect!{|id| tagid(id)}.unshift('pen')
|
|
itemconfigure(id_list, slot, value)
|
|
end
|
|
def pen_configinfo(id, slot=nil)
|
|
itemconfiginfo(['pen', tagid(id)], slot)
|
|
end
|
|
def current_pen_configinfo(id, slot=nil)
|
|
current_itemconfiginfo(['pen', tagid(id)], slot)
|
|
end
|
|
|
|
def postscript_cget(option)
|
|
itemcget('postscript', option)
|
|
end
|
|
def postscript_cget_strict(option)
|
|
itemcget_strict('postscript', option)
|
|
end
|
|
def postscript_configure(slot, value=None)
|
|
itemconfigure('postscript', slot, value)
|
|
end
|
|
def postscript_configinfo(slot=nil)
|
|
itemconfiginfo('postscript', slot)
|
|
end
|
|
def current_postscript_configinfo(slot=nil)
|
|
current_itemconfiginfo('postscript', slot)
|
|
end
|
|
|
|
def marker_cget(id, option)
|
|
itemcget(['marker', tagid(id)], option)
|
|
end
|
|
def marker_cget_strict(id, option)
|
|
itemcget_strict(['marker', tagid(id)], option)
|
|
end
|
|
def marker_configure(*args)
|
|
slot = args.pop
|
|
if slot.kind_of?(Hash)
|
|
value = None
|
|
else
|
|
value = slot
|
|
slot = args.pop
|
|
end
|
|
id_list = args.flatten.collect!{|id| tagid(id)}.unshift('marker')
|
|
itemconfigure(id_list, slot, value)
|
|
end
|
|
def marker_configinfo(id, slot=nil)
|
|
itemconfiginfo(['marker', tagid(id)], slot)
|
|
end
|
|
def current_marker_configinfo(id, slot=nil)
|
|
current_itemconfiginfo(['marker', tagid(id)], slot)
|
|
end
|
|
|
|
alias __itemcget itemcget
|
|
alias __itemcget_strict itemcget_strict
|
|
alias __itemconfiginfo itemconfiginfo
|
|
alias __current_itemconfiginfo current_itemconfiginfo
|
|
private :__itemcget, :__itemconfiginfo, :__current_itemconfiginfo
|
|
|
|
def itemcget_strict(tagOrId, option)
|
|
ret = __itemcget(tagid(tagOrId), option)
|
|
if option == 'bindtags' || option == :bindtags
|
|
ret.collect{|tag| TkBindTag.id2obj(tag)}
|
|
else
|
|
ret
|
|
end
|
|
end
|
|
def itemcget(tagOrId, option)
|
|
unless TkItemConfigMethod.__IGNORE_UNKNOWN_CONFIGURE_OPTION__
|
|
itemcget_strict(tagOrId, option)
|
|
else
|
|
begin
|
|
itemcget_strict(tagOrId, option)
|
|
rescue => e
|
|
begin
|
|
if current_itemconfiginfo(tagOrId).has_key?(option.to_s)
|
|
# error on known option
|
|
fail e
|
|
else
|
|
# unknown option
|
|
nil
|
|
end
|
|
rescue
|
|
fail e # tag error
|
|
end
|
|
end
|
|
end
|
|
end
|
|
def itemconfiginfo(tagOrId, slot = nil)
|
|
ret = __itemconfiginfo(tagid(tagOrId), slot)
|
|
|
|
if TkComm::GET_CONFIGINFO_AS_ARRAY
|
|
if slot
|
|
if slot == 'bindtags' || slot == :bindtags
|
|
ret[-2] = ret[-2].collect{|tag| TkBindTag.id2obj(tag)}
|
|
ret[-1] = ret[-1].collect{|tag| TkBindTag.id2obj(tag)}
|
|
end
|
|
else
|
|
if (inf = ret.assoc('bindtags'))
|
|
inf[-2] = inf[-2].collect{|tag| TkBindTag.id2obj(tag)}
|
|
inf[-1] = inf[-1].collect{|tag| TkBindTag.id2obj(tag)}
|
|
end
|
|
end
|
|
|
|
else # ! TkComm::GET_CONFIGINFO_AS_ARRAY
|
|
if (inf = ret['bindtags'])
|
|
inf[-2] = inf[-2].collect{|tag| TkBindTag.id2obj(tag)}
|
|
inf[-1] = inf[-1].collect{|tag| TkBindTag.id2obj(tag)}
|
|
ret['bindtags'] = inf
|
|
end
|
|
end
|
|
|
|
ret
|
|
end
|
|
def current_itemconfiginfo(tagOrId, slot = nil)
|
|
ret = __current_itemconfiginfo(tagid(tagOrId), slot)
|
|
|
|
if (val = ret['bindtags'])
|
|
ret['bindtags'] = val.collect{|tag| TkBindTag.id2obj(tag)}
|
|
end
|
|
|
|
ret
|
|
end
|
|
|
|
private :itemcget, :itemcget_strict
|
|
private :itemconfigure, :itemconfiginfo, :current_itemconfiginfo
|
|
|
|
#################
|
|
|
|
class Axis < TkObject
|
|
(OBJ_ID = ['blt_chart_axis'.freeze, '00000'.taint]).instance_eval{
|
|
@mutex = Mutex.new
|
|
def mutex; @mutex; end
|
|
freeze
|
|
}
|
|
|
|
AxisID_TBL = TkCore::INTERP.create_table
|
|
|
|
TkCore::INTERP.init_ip_env{
|
|
AxisID_TBL.mutex.synchronize{ AxisID_TBL.clear }
|
|
}
|
|
|
|
def self.id2obj(chart, id)
|
|
cpath = chart.path
|
|
AxisID_TBL.mutex.synchronize{
|
|
return id unless AxisID_TBL[cpath]
|
|
AxisID_TBL[cpath][id]? AxisID_TBL[cpath][id]: id
|
|
}
|
|
end
|
|
|
|
def self.new(chart, axis=nil, keys={})
|
|
if axis.kind_of?(Hash)
|
|
keys = axis
|
|
axis = nil
|
|
end
|
|
if keys
|
|
keys = _symbolkey2str(keys)
|
|
not_create = keys.delete('without_creating')
|
|
else
|
|
not_create = false
|
|
end
|
|
|
|
obj = nil
|
|
AxisID_TBL.mutex.synchronize{
|
|
chart_path = chart.path
|
|
AxisID_TBL[chart_path] ||= {}
|
|
if axis && AxisID_TBL[chart_path][axis]
|
|
obj = AxisID_TBL[chart_path][axis]
|
|
else
|
|
(obj = self.allocate).instance_eval{
|
|
if axis
|
|
@axis = @id = axis.to_s
|
|
else
|
|
OBJ_ID.mutex.synchronize{
|
|
@axis = @id = OBJ_ID.join(TkCore::INTERP._ip_id_).freeze
|
|
OBJ_ID[1].succ!
|
|
}
|
|
end
|
|
@path = @id
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
Axis::AxisID_TBL[@cpath][@axis] = self
|
|
unless not_create
|
|
tk_call(@chart, 'axis', 'create', @axis, keys)
|
|
return obj
|
|
end
|
|
}
|
|
end
|
|
}
|
|
|
|
obj.configure(keys) if obj && ! keys.empty?
|
|
obj
|
|
end
|
|
|
|
def initialize(chart, axis=nil, keys={})
|
|
# dummy:: not called by 'new' method
|
|
|
|
if axis.kind_of?(Hash)
|
|
keys = axis
|
|
axis = nil
|
|
end
|
|
if axis
|
|
@axis = @id = axis.to_s
|
|
else
|
|
OBJ_ID.mutex.synchronize{
|
|
@axis = @id = OBJ_ID.join(TkCore::INTERP._ip_id_).freeze
|
|
OBJ_ID[1].succ!
|
|
}
|
|
end
|
|
@path = @id
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
# Axis::AxisID_TBL[@cpath][@axis] = self
|
|
keys = _symbolkey2str(keys)
|
|
unless keys.delete('without_creating')
|
|
# @chart.axis_create(@axis, keys)
|
|
tk_call(@chart, 'axis', 'create', @axis, keys)
|
|
end
|
|
end
|
|
|
|
def id
|
|
@id
|
|
end
|
|
|
|
def to_eval
|
|
@id
|
|
end
|
|
|
|
def cget(option)
|
|
@chart.axis_cget(@id, option)
|
|
end
|
|
def cget_strict(option)
|
|
@chart.axis_cget_strict(@id, option)
|
|
end
|
|
def configure(key, value=None)
|
|
@chart.axis_configure(@id, key, value)
|
|
self
|
|
end
|
|
def configinfo(key=nil)
|
|
@chart.axis_configinfo(@id, key)
|
|
end
|
|
def current_configinfo(key=nil)
|
|
@chart.current_axis_configinfo(@id, key)
|
|
end
|
|
|
|
def command(cmd=nil, &b)
|
|
if cmd
|
|
configure('command', cmd)
|
|
elsif b
|
|
configure('command', Proc.new(&b))
|
|
else
|
|
cget('command')
|
|
end
|
|
end
|
|
|
|
def delete
|
|
@chart.axis_delete(@id)
|
|
self
|
|
end
|
|
|
|
def invtransform(val)
|
|
@chart.axis_invtransform(@id, val)
|
|
end
|
|
|
|
def limits
|
|
@chart.axis_limits(@id)
|
|
end
|
|
|
|
def name
|
|
@axis
|
|
end
|
|
|
|
def transform(val)
|
|
@chart.axis_transform(@id, val)
|
|
end
|
|
|
|
def view
|
|
@chart.axis_view(@id)
|
|
self
|
|
end
|
|
|
|
def use(name=None) # if @id == xaxis | x2axis | yaxis | y2axis
|
|
@chart.axis_use(@id, name)
|
|
end
|
|
|
|
def use_as(axis) # axis := xaxis | x2axis | yaxis | y2axis
|
|
@chart.axis_use(axis, @id)
|
|
end
|
|
end
|
|
|
|
#################
|
|
|
|
class Crosshairs < TkObject
|
|
CrosshairsID_TBL = TkCore::INTERP.create_table
|
|
|
|
TkCore::INTERP.init_ip_env{
|
|
CrosshairsID_TBL.mutex.synchronize{ CrosshairsID_TBL.clear }
|
|
}
|
|
|
|
def self.new(chart, keys={})
|
|
obj = nil
|
|
CrosshairsID_TBL.mutex.synchronize{
|
|
unless (obj = CrosshairsID_TBL[chart.path])
|
|
(obj = self.allocate).instance_eval{
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
@path = @id = 'crosshairs'
|
|
Crosshairs::CrosshairsID_TBL[@cpath] = self
|
|
}
|
|
end
|
|
}
|
|
chart.crosshair_configure(keys) if obj && ! keys.empty?
|
|
obj
|
|
end
|
|
|
|
def initialize(chart, keys={})
|
|
# dummy:: not called by 'new' method
|
|
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
# Crosshairs::CrosshairsID_TBL[@cpath] = self
|
|
@chart.crosshair_configure(keys) unless keys.empty?
|
|
@path = @id = 'crosshairs'
|
|
end
|
|
|
|
def id
|
|
@id
|
|
end
|
|
|
|
def to_eval
|
|
@id
|
|
end
|
|
|
|
def cget(option)
|
|
@chart.crosshair_cget(option)
|
|
end
|
|
def cget_strict(option)
|
|
@chart.crosshair_cget_strict(option)
|
|
end
|
|
def configure(key, value=None)
|
|
@chart.crosshair_configure(key, value)
|
|
self
|
|
end
|
|
def configinfo(key=nil)
|
|
@chart.crosshair_configinfo(key)
|
|
end
|
|
def current_configinfo(key=nil)
|
|
@chart.current_crosshair_configinfo(key)
|
|
end
|
|
|
|
def off
|
|
@chart.crosshair_off
|
|
self
|
|
end
|
|
def on
|
|
@chart.crosshair_on
|
|
self
|
|
end
|
|
def toggle
|
|
@chart.crosshair_toggle
|
|
self
|
|
end
|
|
end
|
|
|
|
#################
|
|
|
|
class Element < TkObject
|
|
extend Tk
|
|
extend TkItemFontOptkeys
|
|
extend TkItemConfigOptkeys
|
|
|
|
extend Tk::BLT::PlotComponent::OptKeys
|
|
|
|
ElementTypeName = 'element'
|
|
ElementTypeToClass = { ElementTypeName=>self }
|
|
|
|
ElementID_TBL = TkCore::INTERP.create_table
|
|
|
|
TkCore::INTERP.init_ip_env{
|
|
ElementID_TBL.mutex.synchronize{ ElementID_TBL.clear }
|
|
}
|
|
|
|
(OBJ_ID = ['blt_chart_element'.freeze, '00000'.taint]).instance_eval{
|
|
@mutex = Mutex.new
|
|
def mutex; @mutex; end
|
|
freeze
|
|
}
|
|
|
|
def Element.type2class(type)
|
|
ElementTypeToClass[type]
|
|
end
|
|
|
|
def Element.id2obj(chart, id)
|
|
cpath = chart.path
|
|
ElementID_TBL.mutex.synchronize{
|
|
return id unless ElementID_TBL[cpath]
|
|
ElementID_TBL[cpath][id]? ElementID_TBL[cpath][id]: id
|
|
}
|
|
end
|
|
|
|
def self.new(chart, element=nil, keys={})
|
|
if element.kind_of?(Hash)
|
|
keys = element
|
|
element = nil
|
|
end
|
|
if keys
|
|
keys = _symbolkey2str(keys)
|
|
not_create = keys.delete('without_creating')
|
|
else
|
|
not_create = false
|
|
end
|
|
|
|
obj = nil
|
|
ElementID_TBL.mutex.synchronize{
|
|
chart_path = chart.path
|
|
ElementID_TBL[chart_path] ||= {}
|
|
if element && ElementID_TBL[chart_path][element]
|
|
obj = ElementID_TBL[chart_path][element]
|
|
else
|
|
(obj = self.allocate).instance_eval{
|
|
if element
|
|
@element = @id = element.to_s
|
|
else
|
|
OBJ_ID.mutex.synchronize{
|
|
@element = @id = OBJ_ID.join(TkCore::INTERP._ip_id_).freeze
|
|
OBJ_ID[1].succ!
|
|
}
|
|
end
|
|
@path = @id
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
@typename = self.class::ElementTypeName
|
|
Element::ElementID_TBL[@cpath][@element] = self
|
|
unless not_create
|
|
tk_call(@chart, @typename, 'create', @element, keys)
|
|
return obj
|
|
end
|
|
}
|
|
end
|
|
}
|
|
|
|
obj.configure(keys) if obj && ! keys.empty?
|
|
obj
|
|
end
|
|
|
|
def initialize(chart, element=nil, keys={})
|
|
# dummy:: not called by 'new' method
|
|
|
|
if element.kind_of?(Hash)
|
|
keys = element
|
|
element = nil
|
|
end
|
|
if element
|
|
@element = @id = element.to_s
|
|
else
|
|
OBJ_ID.mutex.synchronize{
|
|
@element = @id = OBJ_ID.join(TkCore::INTERP._ip_id_).freeze
|
|
OBJ_ID[1].succ!
|
|
}
|
|
end
|
|
@path = @id
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
@typename = self.class::ElementTypeName
|
|
# Element::ElementID_TBL[@cpath][@element] = self
|
|
keys = _symbolkey2str(keys)
|
|
unless keys.delete('without_creating')
|
|
# @chart.element_create(@element, keys)
|
|
tk_call(@chart, @typename, 'create', @element, keys)
|
|
end
|
|
end
|
|
|
|
def id
|
|
@id
|
|
end
|
|
|
|
def to_eval
|
|
@id
|
|
end
|
|
|
|
def cget(option)
|
|
# @chart.element_cget(@id, option)
|
|
@chart.__send__(@typename + '_cget', @id, option)
|
|
end
|
|
def cget_strict(option)
|
|
@chart.__send__(@typename + '_cget_strict', @id, option)
|
|
end
|
|
def configure(key, value=None)
|
|
# @chart.element_configure(@id, key, value)
|
|
@chart.__send__(@typename + '_configure', @id, key, value)
|
|
self
|
|
end
|
|
def configinfo(key=nil)
|
|
# @chart.element_configinfo(@id, key)
|
|
@chart.__send__(@typename + '_configinfo', @id, key)
|
|
end
|
|
def current_configinfo(key=nil)
|
|
# @chart.current_element_configinfo(@id, key)
|
|
@chart.__send__('current_' << @typename << '_configinfo', @id, key)
|
|
end
|
|
|
|
def activate(*args)
|
|
@chart.element_activate(@id, *args)
|
|
end
|
|
|
|
def closest(x, y, var, keys={})
|
|
# @chart.element_closest(x, y, var, @id, keys)
|
|
@chart.__send__(@typename + '_closest', x, y, var, @id, keys)
|
|
end
|
|
|
|
def deactivate
|
|
@chart.element_deactivate(@id)
|
|
self
|
|
end
|
|
|
|
def delete
|
|
@chart.element_delete(@id)
|
|
self
|
|
end
|
|
|
|
def exist?
|
|
@chart.element_exist?(@id)
|
|
end
|
|
|
|
def name
|
|
@element
|
|
end
|
|
|
|
def type
|
|
@chart.element_type(@id)
|
|
end
|
|
end
|
|
|
|
class Bar < Element
|
|
ElementTypeName = 'bar'.freeze
|
|
ElementTypeToClass[ElementTypeName] = self
|
|
end
|
|
class Line < Element
|
|
ElementTypeName = 'line'.freeze
|
|
ElementTypeToClass[ElementTypeName] = self
|
|
end
|
|
|
|
#################
|
|
|
|
class GridLine < TkObject
|
|
GridLineID_TBL = TkCore::INTERP.create_table
|
|
TkCore::INTERP.init_ip_env{
|
|
GridLineID_TBL.mutex.synchronize{ GridLineID_TBL.clear }
|
|
}
|
|
|
|
def self.new(chart, keys={})
|
|
obj = nil
|
|
GridLineID_TBL.mutex.synchronize{
|
|
unless (obj = GridLineID_TBL[chart.path])
|
|
(obj = self.allocate).instance_eval{
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
@path = @id = 'grid'
|
|
GridLine::GridLineID_TBL[@cpath] = self
|
|
}
|
|
end
|
|
}
|
|
chart.gridline_configure(keys) if obj && ! keys.empty?
|
|
obj
|
|
end
|
|
|
|
def initialize(chart, keys={})
|
|
# dummy:: not called by 'new' method
|
|
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
# GridLine::GridLineID_TBL[@cpath] = self
|
|
@chart.gridline_configure(keys) unless keys.empty?
|
|
@path = @id = 'grid'
|
|
end
|
|
|
|
def id
|
|
@id
|
|
end
|
|
|
|
def to_eval
|
|
@id
|
|
end
|
|
|
|
def cget(option)
|
|
@chart.gridline_cget(option)
|
|
end
|
|
def cget_strict(option)
|
|
@chart.gridline_cget_strict(option)
|
|
end
|
|
def configure(key, value=None)
|
|
@chart.gridline_configure(key, value)
|
|
self
|
|
end
|
|
def configinfo(key=nil)
|
|
@chart.gridline_configinfo(key)
|
|
end
|
|
def current_configinfo(key=nil)
|
|
@chart.current_gridline_configinfo(key)
|
|
end
|
|
|
|
def off
|
|
@chart.gridline_off
|
|
self
|
|
end
|
|
def on
|
|
@chart.gridline_on
|
|
self
|
|
end
|
|
def toggle
|
|
@chart.gridline_toggle
|
|
self
|
|
end
|
|
end
|
|
|
|
#################
|
|
|
|
class Legend < TkObject
|
|
LegendID_TBL = TkCore::INTERP.create_table
|
|
|
|
TkCore::INTERP.init_ip_env{
|
|
LegendID_TBL.mutex.synchronize{ LegendID_TBL.clear }
|
|
}
|
|
|
|
def self.new(chart, keys={})
|
|
obj = nil
|
|
LegenedID_TBL.mutex.synchronize{
|
|
unless (obj = LegenedID_TBL[chart.path])
|
|
(obj = self.allocate).instance_eval{
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
@path = @id = 'crosshairs'
|
|
Legend::LegenedID_TBL[@cpath] = self
|
|
}
|
|
end
|
|
}
|
|
chart.legend_configure(keys) if obj && ! keys.empty?
|
|
obj
|
|
end
|
|
|
|
def initialize(chart, keys={})
|
|
# dummy:: not called by 'new' method
|
|
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
# Legend::LegendID_TBL[@cpath] = self
|
|
@chart.legend_configure(keys) unless keys.empty?
|
|
@path = @id = 'legend'
|
|
end
|
|
|
|
def id
|
|
@id
|
|
end
|
|
|
|
def to_eval
|
|
@id
|
|
end
|
|
|
|
def cget(option)
|
|
@chart.legend_cget(option)
|
|
end
|
|
def cget_strict(option)
|
|
@chart.legend_cget_strict(option)
|
|
end
|
|
def configure(key, value=None)
|
|
@chart.legend_configure(key, value)
|
|
self
|
|
end
|
|
def configinfo(key=nil)
|
|
@chart.legend_configinfo(key)
|
|
end
|
|
def current_configinfo(key=nil)
|
|
@chart.current_legend_configinfo(key)
|
|
end
|
|
|
|
def activate(*args)
|
|
@chart.legend_activate(*args)
|
|
end
|
|
|
|
def deactivate(*args)
|
|
@chart.legend_deactivate(*args)
|
|
end
|
|
|
|
def get(pos, y=nil)
|
|
@chart.legend_get(pos, y)
|
|
end
|
|
end
|
|
|
|
#################
|
|
|
|
class Pen < TkObject
|
|
(OBJ_ID = ['blt_chart_pen'.freeze, '00000'.taint]).instance_eval{
|
|
@mutex = Mutex.new
|
|
def mutex; @mutex; end
|
|
freeze
|
|
}
|
|
|
|
PenID_TBL = TkCore::INTERP.create_table
|
|
|
|
TkCore::INTERP.init_ip_env{
|
|
PenID_TBL.mutex.synchronize{ PenID_TBL.clear }
|
|
}
|
|
|
|
def self.id2obj(chart, id)
|
|
cpath = chart.path
|
|
PenID_TBL.mutex.synchronize{
|
|
return id unless PenID_TBL[cpath]
|
|
PenID_TBL[cpath][id]? PenID_TBL[cpath][id]: id
|
|
}
|
|
end
|
|
|
|
def self.new(chart, pen=nil, keys={})
|
|
if pen.kind_of?(Hash)
|
|
keys = pen
|
|
pen = nil
|
|
end
|
|
if keys
|
|
keys = _symbolkey2str(keys)
|
|
not_create = keys.delete('without_creating')
|
|
else
|
|
not_create = false
|
|
end
|
|
|
|
obj = nil
|
|
PenID_TBL.mutex.synchronize{
|
|
chart_path = chart.path
|
|
PenID_TBL[chart_path] ||= {}
|
|
if pen && PenID_TBL[chart_path][pen]
|
|
obj = PenID_TBL[chart_path][pen]
|
|
else
|
|
(obj = self.allocate).instance_eval{
|
|
if pen
|
|
@pen = @id = pen.to_s
|
|
else
|
|
OBJ_ID.mutex.synchronize{
|
|
@pen = @id = OBJ_ID.join(TkCore::INTERP._ip_id_).freeze
|
|
OBJ_ID[1].succ!
|
|
}
|
|
end
|
|
@path = @id
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
Pen::PenID_TBL[@cpath][@pen] = self
|
|
unless not_create
|
|
tk_call(@chart, 'pen', 'create', @pen, keys)
|
|
return obj
|
|
end
|
|
}
|
|
end
|
|
}
|
|
|
|
obj.configure(keys) if obj && ! keys.empty?
|
|
obj
|
|
end
|
|
|
|
def initialize(chart, pen=nil, keys={})
|
|
if pen.kind_of?(Hash)
|
|
keys = pen
|
|
pen = nil
|
|
end
|
|
if pen
|
|
@pen = @id = pen.to_s
|
|
else
|
|
OBJ_ID.mutex.synchronize{
|
|
@pen = @id = OBJ_ID.join(TkCore::INTERP._ip_id_).freeze
|
|
OBJ_ID[1].succ!
|
|
}
|
|
end
|
|
@path = @id
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
Pen::PenID_TBL[@cpath][@pen] = self
|
|
keys = _symbolkey2str(keys)
|
|
unless keys.delete('without_creating')
|
|
# @chart.pen_create(@pen, keys)
|
|
tk_call(@chart, 'pen', 'create', @pen, keys)
|
|
end
|
|
end
|
|
|
|
def id
|
|
@id
|
|
end
|
|
|
|
def to_eval
|
|
@id
|
|
end
|
|
|
|
def cget(option)
|
|
@chart.pen_cget(@id, option)
|
|
end
|
|
def cget_strict(option)
|
|
@chart.pen_cget_strict(@id, option)
|
|
end
|
|
def configure(key, value=None)
|
|
@chart.pen_configure(@id, key, value)
|
|
self
|
|
end
|
|
def configinfo(key=nil)
|
|
@chart.pen_configinfo(@id, key)
|
|
end
|
|
def current_configinfo(key=nil)
|
|
@chart.current_pen_configinfo(@id, key)
|
|
end
|
|
|
|
def delete
|
|
@chart.pen_delete(@id)
|
|
self
|
|
end
|
|
|
|
def name
|
|
@pen
|
|
end
|
|
end
|
|
|
|
#################
|
|
|
|
class Postscript < TkObject
|
|
PostscriptID_TBL = TkCore::INTERP.create_table
|
|
|
|
TkCore::INTERP.init_ip_env{
|
|
PostscriptID_TBL.mutex.synchronize{ PostscriptID_TBL.clear }
|
|
}
|
|
|
|
def self.new(chart, keys={})
|
|
obj = nil
|
|
PostscriptID_TBL.mutex.synchronize{
|
|
unless (obj = PostscriptID_TBL[chart.path])
|
|
(obj = self.allocate).instance_eval{
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
@path = @id = 'postscript'
|
|
Postscript::PostscriptID_TBL[@cpath] = self
|
|
}
|
|
end
|
|
}
|
|
chart.postscript_configure(keys) if obj && ! keys.empty?
|
|
obj
|
|
end
|
|
|
|
def initialize(chart, keys={})
|
|
# dummy:: not called by 'new' method
|
|
|
|
@parent = @chart = chart
|
|
@cpath = @chart.path
|
|
# Postscript::PostscriptID_TBL[@cpath] = self
|
|
@chart.postscript_configure(keys) unless keys.empty?
|
|
@path = @id = 'postscript'
|
|
end
|
|
|
|
def id
|
|
@id
|
|
end
|
|
|
|
def to_eval
|
|
@id
|
|
end
|
|
|
|
def cget(option)
|
|
@chart.postscript_cget(option)
|
|
end
|
|
def cget_strict(option)
|
|
@chart.postscript_cget_strict(option)
|
|
end
|
|
def configure(key, value=None)
|
|
@chart.postscript_configure(key, value)
|
|
self
|
|
end
|
|
def configinfo(key=nil)
|
|
@chart.postscript_configinfo(key)
|
|
end
|
|
def current_configinfo(key=nil)
|
|
@chart.current_postscript_configinfo(key)
|
|
end
|
|
|
|
def output(file=nil, keys={})
|
|
if file.kind_of?(Hash)
|
|
keys = file
|
|
file = nil
|
|
end
|
|
|
|
ret = @chart.postscript_output(file, keys)
|
|
|
|
if file
|
|
self
|
|
else
|
|
ret
|
|
end
|
|
end
|
|
end
|
|
|
|
#################
|
|
class Marker < TkObject
|
|
extend Tk
|
|
extend TkItemFontOptkeys
|
|
extend TkItemConfigOptkeys
|
|
|
|
extend Tk::BLT::PlotComponent::OptKeys
|
|
|
|
MarkerTypeName = nil
|
|
MarkerTypeToClass = {}
|
|
MarkerID_TBL = TkCore::INTERP.create_table
|
|
|
|
TkCore::INTERP.init_ip_env{
|
|
MarkerID_TBL.mutex.synchronize{ MarkerID_TBL.clear }
|
|
}
|
|
|
|
def Marker.type2class(type)
|
|
MarkerTypeToClass[type]
|
|
end
|
|
|
|
def Marker.id2obj(chart, id)
|
|
cpath = chart.path
|
|
MarkerID_TBL.mutex.synchronize{
|
|
if MarkerID_TBL[cpath]
|
|
MarkerID_TBL[cpath][id]? MarkerID_TBL[cpath][id]: id
|
|
else
|
|
id
|
|
end
|
|
}
|
|
end
|
|
|
|
def self._parse_create_args(keys)
|
|
fontkeys = {}
|
|
methodkeys = {}
|
|
if keys.kind_of? Hash
|
|
keys = _symbolkey2str(keys)
|
|
|
|
__item_font_optkeys(nil).each{|key|
|
|
fkey = key.to_s
|
|
fontkeys[fkey] = keys.delete(fkey) if keys.key?(fkey)
|
|
|
|
fkey = "kanji#{key}"
|
|
fontkeys[fkey] = keys.delete(fkey) if keys.key?(fkey)
|
|
|
|
fkey = "latin#{key}"
|
|
fontkeys[fkey] = keys.delete(fkey) if keys.key?(fkey)
|
|
|
|
fkey = "ascii#{key}"
|
|
fontkeys[fkey] = keys.delete(fkey) if keys.key?(fkey)
|
|
}
|
|
|
|
__item_optkey_aliases(nil).each{|alias_name, real_name|
|
|
alias_name = alias_name.to_s
|
|
if keys.has_key?(alias_name)
|
|
keys[real_name.to_s] = keys.delete(alias_name)
|
|
end
|
|
}
|
|
|
|
__item_methodcall_optkeys(nil).each{|key|
|
|
key = key.to_s
|
|
methodkeys[key] = keys.delete(key) if keys.key?(key)
|
|
}
|
|
|
|
__item_ruby2val_optkeys(nil).each{|key, method|
|
|
key = key.to_s
|
|
keys[key] = method.call(keys[key]) if keys.has_key?(key)
|
|
}
|
|
|
|
args = itemconfig_hash_kv(nil, keys)
|
|
else
|
|
args = []
|
|
end
|
|
|
|
[args, fontkeys]
|
|
end
|
|
private_class_method :_parse_create_args
|
|
|
|
def self.create(chart, keys={})
|
|
unless self::MarkerTypeName
|
|
fail RuntimeError, "#{self} is an abstract class"
|
|
end
|
|
args, fontkeys = _parse_create_args(keys)
|
|
idnum = tk_call_without_enc(chart.path, 'marker', 'create',
|
|
self::MarkerTypeName, *args)
|
|
chart.marker_configure(idnum, fontkeys) unless fontkeys.empty?
|
|
idnum.to_i # 'item id' is an integer number
|
|
end
|
|
|
|
def self.create_type(chart, type, keys={})
|
|
args, fontkeys = _parse_create_args(keys)
|
|
idnum = tk_call_without_enc(chart.path, 'marker', 'create',
|
|
type, *args)
|
|
chart.marker_configure(idnum, fontkeys) unless fontkeys.empty?
|
|
id = idnum.to_i # 'item id' is an integer number
|
|
obj = self.allocate
|
|
obj.instance_eval{
|
|
@parent = @chart = chart
|
|
@cpath = chart.path
|
|
@id = id
|
|
Tk::BLT::PlotComponent::Marker::MarkerID_TBL.mutex.synchronize{
|
|
Tk::BLT::PlotComponent::Marker::MarkerID_TBL[@cpath] ||= {}
|
|
Tk::BLT::PlotComponent::Marker::MarkerID_TBL[@cpath][@id] = self
|
|
}
|
|
}
|
|
obj
|
|
end
|
|
|
|
def initialize(parent, *args)
|
|
@parent = @chart = parent
|
|
@cpath = parent.path
|
|
|
|
@path = @id = create_self(*args) # an integer number as 'item id'
|
|
Tk::BLT::PlotComponent::Marker::MarkerID_TBL.mutex.synchronize{
|
|
Tk::BLT::PlotComponent::Marker::MarkerID_TBL[@cpath] ||= {}
|
|
Tk::BLT::PlotComponent::Marker::MarkerID_TBL[@cpath][@id] = self
|
|
}
|
|
end
|
|
def create_self(*args)
|
|
self.class.create(@chart, *args) # return an integer as 'item id'
|
|
end
|
|
private :create_self
|
|
|
|
def id
|
|
@id
|
|
end
|
|
|
|
def to_eval
|
|
@id
|
|
end
|
|
|
|
def cget(option)
|
|
@chart.marker_cget(@id, option)
|
|
end
|
|
def cget_strict(option)
|
|
@chart.marker_cget_strict(@id, option)
|
|
end
|
|
def configure(key, value=None)
|
|
@chart.marker_configure(@id, key, value)
|
|
self
|
|
end
|
|
def configinfo(key=nil)
|
|
@chart.marker_configinfo(@id, key)
|
|
end
|
|
def current_configinfo(key=nil)
|
|
@chart.current_marker_configinfo(@id, key)
|
|
end
|
|
|
|
def after(target=None)
|
|
@chart.marker_after(@id, target)
|
|
end
|
|
|
|
def before(target=None)
|
|
@chart.marker_before(@id, target)
|
|
end
|
|
|
|
def delete
|
|
@chart.marker_delete(@id)
|
|
end
|
|
|
|
def exist?
|
|
@chart.marker_exist(@id)
|
|
end
|
|
|
|
def type
|
|
@chart.marker_type(@id)
|
|
end
|
|
end
|
|
|
|
class TextMarker < Marker
|
|
MarkerTypeName = 'text'.freeze
|
|
MarkerTypeToClass[MarkerTypeName] = self
|
|
end
|
|
class LineMarker < Marker
|
|
MarkerTypeName = 'line'.freeze
|
|
MarkerTypeToClass[MarkerTypeName] = self
|
|
end
|
|
class BitmapMarker < Marker
|
|
MarkerTypeName = 'bitmap'.freeze
|
|
MarkerTypeToClass[MarkerTypeName] = self
|
|
end
|
|
class ImageMarker < Marker
|
|
MarkerTypeName = 'image'.freeze
|
|
MarkerTypeToClass[MarkerTypeName] = self
|
|
end
|
|
class PolygonMarker < Marker
|
|
MarkerTypeName = 'polygon'.freeze
|
|
MarkerTypeToClass[MarkerTypeName] = self
|
|
end
|
|
class WindowMarker < Marker
|
|
MarkerTypeName = 'window'.freeze
|
|
MarkerTypeToClass[MarkerTypeName] = self
|
|
end
|
|
|
|
#################
|
|
|
|
def __destroy_hook__
|
|
Axis::AxisID_TBL.delete(@path)
|
|
Crosshairs::CrosshairsID_TBL.delete(@path)
|
|
Element::ElementID_TBL.delete(@path)
|
|
GridLine::GridLineID_TBL.delete(@path)
|
|
Legend::LegendID_TBL.delete(@path)
|
|
Pen::PenID_TBL.delete(@path)
|
|
Postscript::PostscriptID_TBL.delete(@path)
|
|
Marker::MarkerID_TBL.delete(@path)
|
|
super()
|
|
end
|
|
|
|
#################
|
|
|
|
def tagid(tag)
|
|
if tag.kind_of?(Axis) ||
|
|
tag.kind_of?(Crosshairs) ||
|
|
tag.kind_of?(Element) ||
|
|
tag.kind_of?(GridLine) ||
|
|
tag.kind_of?(Legend) ||
|
|
tag.kind_of?(Pen) ||
|
|
tag.kind_of?(Postscript) ||
|
|
tag.kind_of?(Marker)
|
|
tag.id
|
|
else
|
|
tag # maybe an Array of configure paramters
|
|
end
|
|
end
|
|
|
|
def _component_bind(target, tag, context, *args)
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
|
cmd = args.shift
|
|
else
|
|
cmd = Proc.new
|
|
end
|
|
_bind([path, target, 'bind', tagid(tag)], context, cmd, *args)
|
|
self
|
|
end
|
|
def _component_bind_append(target, tag, context, *args)
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
|
cmd = args.shift
|
|
else
|
|
cmd = Proc.new
|
|
end
|
|
_bind_append([path, target, 'bind', tagid(tag)], context, cmd, *args)
|
|
self
|
|
end
|
|
def _component_bind_remove(target, tag, context)
|
|
_bind_remove([path, target, 'bind', tagid(tag)], context)
|
|
self
|
|
end
|
|
def _component_bindinfo(target, tag, context=nil)
|
|
_bindinfo([path, target, 'bind', tagid(tag)], context)
|
|
end
|
|
private :_component_bind, :_component_bind_append
|
|
private :_component_bind_remove, :_component_bindinfo
|
|
|
|
def axis_bind(tag, context, *args)
|
|
_component_bind('axis', tag, context, *args)
|
|
end
|
|
def axis_bind_append(tag, context, *args)
|
|
_component_bind_append('axis', tag, context, *args)
|
|
end
|
|
def axis_bind_remove(tag, context)
|
|
_component_bind_remove('axis', tag, context)
|
|
end
|
|
def axis_bindinfo(tag, context=nil)
|
|
_component_bindinfo('axis', tag, context)
|
|
end
|
|
|
|
def element_bind(tag, context, *args)
|
|
_component_bind('element', tag, context, *args)
|
|
end
|
|
def element_bind_append(tag, context, *args)
|
|
_component_bind_append('element', tag, context, *args)
|
|
end
|
|
def element_bind_remove(tag, context)
|
|
_component_bind_remove('element', tag, context)
|
|
end
|
|
def element_bindinfo(tag, context=nil)
|
|
_component_bindinfo('element', tag, context)
|
|
end
|
|
|
|
def bar_bind(tag, context, *args)
|
|
_component_bind('bar', tag, context, *args)
|
|
end
|
|
def bar_bind_append(tag, context, *args)
|
|
_component_bind_append('bar', tag, context, *args)
|
|
end
|
|
def bar_bind_remove(tag, context)
|
|
_component_bind_remove('bar', tag, context)
|
|
end
|
|
def bar_bindinfo(tag, context=nil)
|
|
_component_bindinfo('bar', tag, context)
|
|
end
|
|
|
|
def line_bind(tag, context, *args)
|
|
_component_bind('line', tag, context, *args)
|
|
end
|
|
def line_bind_append(tag, context, *args)
|
|
_component_bind_append('line', tag, context, *args)
|
|
end
|
|
def line_bind_remove(tag, context)
|
|
_component_bind_remove('line', tag, context)
|
|
end
|
|
def line_bindinfo(tag, context=nil)
|
|
_component_bindinfo('line', tag, context)
|
|
end
|
|
|
|
def legend_bind(tag, context, *args)
|
|
_component_bind('legend', tag, context, *args)
|
|
end
|
|
def legend_bind_append(tag, context, *args)
|
|
_component_bind_append('legend', tag, context, *args)
|
|
end
|
|
def legend_bind_remove(tag, context)
|
|
_component_bind_remove('legend', tag, context)
|
|
end
|
|
def legend_bindinfo(tag, context=nil)
|
|
_component_bindinfo('legend', tag, context)
|
|
end
|
|
|
|
def marker_bind(tag, context, *args)
|
|
_component_bind('marker', tag, context, *args)
|
|
end
|
|
def marker_bind_append(tag, context, *args)
|
|
_component_bind_append('marker', tag, context, *args)
|
|
end
|
|
def marker_bind_remove(tag, context)
|
|
_component_bind_remove('marker', tag, context)
|
|
end
|
|
def marker_bindinfo(tag, context=nil)
|
|
_component_bindinfo('marker', tag, context)
|
|
end
|
|
|
|
###################
|
|
|
|
def axis_create(id=nil, keys={})
|
|
# tk_send('axis', 'create', tagid(id), keys)
|
|
Tk::BLT::PlotComponent::Axis.new(self, tagid(id), keys)
|
|
end
|
|
def axis_delete(*ids)
|
|
tk_send('axis', 'delete', *(ids.collect{|id| tagid(id)}))
|
|
self
|
|
end
|
|
def axis_invtransform(id, val)
|
|
list(tk_send('axis', 'invtransform', tagid(id), val))
|
|
end
|
|
def axis_limits(id)
|
|
list(tk_send('axis', 'limits', tagid(id)))
|
|
end
|
|
def axis_names(*pats)
|
|
simplelist(tk_send('axis', 'names',
|
|
*(pats.collect{|pat| tagid(pat)}))).collect{|axis|
|
|
Tk::BLT::PlotComponent::Axis.id2obj(self, axis)
|
|
}
|
|
end
|
|
def axis_transform(id, val)
|
|
list(tk_send('axis', 'transform', tagid(id), val))
|
|
end
|
|
def axis_view(id)
|
|
tk_send('axis', 'view', tagid(id))
|
|
self
|
|
end
|
|
def axis_use(id, target=nil)
|
|
if target
|
|
Tk::BLT::PlotComponent::Axis.id2obj(self,
|
|
tk_send('axis', 'use',
|
|
tagid(id), tagid(target)))
|
|
else
|
|
Tk::BLT::PlotComponent::Axis.id2obj(self,
|
|
tk_send('axis', 'use', tagid(id)))
|
|
end
|
|
end
|
|
|
|
###################
|
|
|
|
def crosshairs_off
|
|
tk_send_without_enc('crosshairs', 'off')
|
|
self
|
|
end
|
|
def crosshairs_on
|
|
tk_send_without_enc('crosshairs', 'on')
|
|
self
|
|
end
|
|
def crosshairs_toggle
|
|
tk_send_without_enc('crosshairs', 'toggle')
|
|
self
|
|
end
|
|
|
|
###################
|
|
|
|
def element_create(id=nil, keys={})
|
|
# tk_send('element', 'create', tagid(id), keys)
|
|
Tk::BLT::PlotComponent::Element.new(self, tagid(id), keys)
|
|
end
|
|
def element_activate(*args)
|
|
if args.empty?
|
|
list(tk_send('element', 'activate')).collect{|elem|
|
|
Tk::BLT::PlotComponent::Element.id2obj(self, elem)
|
|
}
|
|
else
|
|
# id, *indices
|
|
id = args.shift
|
|
tk_send('element', 'activate', tagid(id), *args)
|
|
end
|
|
end
|
|
def element_closest(x, y, var, *args)
|
|
if args[-1].kind_of?(Hash)
|
|
keys = args.pop
|
|
bool(tk_send('element', 'closest', x, y, var,
|
|
*(hash_kv(keys).concat(args.collect{|id| tagid(id)}))))
|
|
else
|
|
bool(tk_send('element', 'closest', x, y, var,
|
|
*(args.collect{|id| tagid(id)})))
|
|
end
|
|
end
|
|
def element_deactivate(*ids)
|
|
tk_send('element', 'deactivate', *(ids.collect{|id| tagid(id)}))
|
|
self
|
|
end
|
|
def element_delete(*ids)
|
|
tk_send('element', 'delete', *(ids.collect{|id| tagid(id)}))
|
|
self
|
|
end
|
|
def element_exist?(id)
|
|
bool(tk_send('element', 'exists', tagid(id)))
|
|
end
|
|
def element_names(*pats)
|
|
simplelist(tk_send('element', 'names',
|
|
*(pats.collect{|pat| tagid(pat)}))).collect{|elem|
|
|
Tk::BLT::PlotComponent::Element.id2obj(self, elem)
|
|
}
|
|
end
|
|
def element_show(*names)
|
|
if names.empty?
|
|
simplelist(tk_send('element', 'show'))
|
|
else
|
|
tk_send('element', 'show', *(names.collect{|n| tagid(n)}))
|
|
self
|
|
end
|
|
end
|
|
def element_type(id)
|
|
tk_send('element', 'type', tagid(id))
|
|
end
|
|
|
|
###################
|
|
|
|
def bar_create(id=nil, keys={})
|
|
# tk_send('bar', 'create', tagid(id), keys)
|
|
Tk::BLT::PlotComponent::Bar.new(self, tagid(id), keys)
|
|
end
|
|
alias bar bar_create
|
|
def bar_activate(*args)
|
|
if args.empty?
|
|
list(tk_send('bar', 'activate')).collect{|elem|
|
|
Tk::BLT::PlotComponent::Element.id2obj(self, elem)
|
|
}
|
|
else
|
|
# id, *indices
|
|
id = args.shift
|
|
tk_send('bar', 'activate', tagid(id), *args)
|
|
end
|
|
end
|
|
def bar_closest(x, y, var, *args)
|
|
if args[-1].kind_of?(Hash)
|
|
keys = args.pop
|
|
bool(tk_send('bar', 'closest', x, y, var,
|
|
*(hash_kv(keys).concat(args.collect{|id| tagid(id)}))))
|
|
else
|
|
bool(tk_send('bar', 'closest', x, y, var,
|
|
*(args.collect{|id| tagid(id)})))
|
|
end
|
|
end
|
|
def bar_deactivate(*ids)
|
|
tk_send('bar', 'deactivate', *(ids.collect{|id| tagid(id)}))
|
|
self
|
|
end
|
|
def bar_delete(*ids)
|
|
tk_send('bar', 'delete', *(ids.collect{|id| tagid(id)}))
|
|
self
|
|
end
|
|
def bar_exist?(id)
|
|
bool(tk_send('bar', 'exists', tagid(id)))
|
|
end
|
|
def bar_names(*pats)
|
|
simplelist(tk_send('bar', 'names',
|
|
*(pats.collect{|pat| tagid(pat)}))).collect{|elem|
|
|
Tk::BLT::PlotComponent::Element.id2obj(self, elem)
|
|
}
|
|
end
|
|
def bar_show(*names)
|
|
if names.empty?
|
|
simplelist(tk_send('bar', 'show'))
|
|
else
|
|
tk_send('bar', 'show', *(names.collect{|n| tagid(n)}))
|
|
self
|
|
end
|
|
end
|
|
def bar_type(id)
|
|
tk_send('bar', 'type', tagid(id))
|
|
end
|
|
|
|
###################
|
|
|
|
def line_create(id=nil, keys={})
|
|
# tk_send('line', 'create', tagid(id), keys)
|
|
Tk::BLT::PlotComponent::Line.new(self, tagid(id), keys)
|
|
end
|
|
alias bar line_create
|
|
def line_activate(*args)
|
|
if args.empty?
|
|
list(tk_send('line', 'activate')).collect{|elem|
|
|
Tk::BLT::PlotComponent::Element.id2obj(self, elem)
|
|
}
|
|
else
|
|
# id, *indices
|
|
id = args.shift
|
|
tk_send('line', 'activate', tagid(id), *args)
|
|
end
|
|
end
|
|
def line_closest(x, y, var, *args)
|
|
if args[-1].kind_of?(Hash)
|
|
keys = args.pop
|
|
bool(tk_send('line', 'closest', x, y, var,
|
|
*(hash_kv(keys).concat(args.collect{|id| tagid(id)}))))
|
|
else
|
|
bool(tk_send('line', 'closest', x, y, var,
|
|
*(args.collect{|id| tagid(id)})))
|
|
end
|
|
end
|
|
def line_deactivate(*ids)
|
|
tk_send('line', 'deactivate', *(ids.collect{|id| tagid(id)}))
|
|
self
|
|
end
|
|
def line_delete(*ids)
|
|
tk_send('line', 'delete', *(ids.collect{|id| tagid(id)}))
|
|
self
|
|
end
|
|
def line_exist?(id)
|
|
bool(tk_send('line', 'exists', tagid(id)))
|
|
end
|
|
def line_names(*pats)
|
|
simplelist(tk_send('line', 'names',
|
|
*(pats.collect{|pat| tagid(pat)}))).collect{|elem|
|
|
Tk::BLT::PlotComponent::Element.id2obj(self, elem)
|
|
}
|
|
end
|
|
def line_show(*names)
|
|
if names.empty?
|
|
simplelist(tk_send('line', 'show'))
|
|
else
|
|
tk_send('line', 'show', *(names.collect{|n| tagid(n)}))
|
|
self
|
|
end
|
|
end
|
|
def line_type(id)
|
|
tk_send('line', 'type', tagid(id))
|
|
end
|
|
|
|
###################
|
|
|
|
def gridline_off
|
|
tk_send_without_enc('grid', 'off')
|
|
self
|
|
end
|
|
def gridline_on
|
|
tk_send_without_enc('grid', 'on')
|
|
self
|
|
end
|
|
def gridline_toggle
|
|
tk_send_without_enc('grid', 'toggle')
|
|
self
|
|
end
|
|
|
|
###################
|
|
|
|
def legend_window_create(parent=nil, keys=nil)
|
|
if parent.kind_of?(Hash)
|
|
keys = _symbolkey2str(parent)
|
|
parent = keys.delete('parent')
|
|
widgetname = keys.delete('widgetname')
|
|
keys.delete('without_creating')
|
|
elsif keys
|
|
keys = _symbolkey2str(keys)
|
|
widgetname = keys.delete('widgetname')
|
|
keys.delete('without_creating')
|
|
end
|
|
|
|
legend = self.class.new(parent, :without_creating=>true,
|
|
:widgetname=>widgetname)
|
|
class << legend
|
|
def __destroy_hook__
|
|
TkCore::INTERP.tk_windows.delete(@path)
|
|
end
|
|
end
|
|
|
|
if keys
|
|
self.legend_configure(keys.update('position'=>legend))
|
|
else
|
|
self.legend_configure('position'=>legend)
|
|
end
|
|
legend
|
|
end
|
|
|
|
def legend_activate(*pats)
|
|
list(tk_send('legend', 'activate',
|
|
*(pats.collect{|pat| tagid(pat)}))).collect{|elem|
|
|
Tk::BLT::PlotComponent::Element.id2obj(self, elem)
|
|
}
|
|
end
|
|
def legend_deactivate(*pats)
|
|
list(tk_send('legend', 'deactivate',
|
|
*(pats.collect{|pat| tagid(pat)}))).collect{|elem|
|
|
Tk::BLT::PlotComponent::Element.id2obj(self, elem)
|
|
}
|
|
end
|
|
def legend_get(pos, y=nil)
|
|
if y
|
|
Tk::BLT::PlotComponent::Element.id2obj(self,
|
|
tk_send('legend', 'get',
|
|
_at(pos, y)))
|
|
else
|
|
Tk::BLT::PlotComponent::Element.id2obj(self,
|
|
tk_send('legend', 'get', pos))
|
|
end
|
|
end
|
|
|
|
###################
|
|
|
|
def pen_create(id=nil, keys={})
|
|
# tk_send('pen', 'create', tagid(id), keys)
|
|
Tk::BLT::PlotComponent::Pen.new(self, tagid(id), keys)
|
|
end
|
|
def pen_delete(*ids)
|
|
tk_send('pen', 'delete', *(ids.collect{|id| tagid(id)}))
|
|
self
|
|
end
|
|
def pen_names(*pats)
|
|
simplelist(tk_send('pen', 'names',
|
|
*(pats.collect{|pat| tagid(pat)}))).collect{|pen|
|
|
Tk::BLT::PlotComponent::Pen.id2obj(self, pen)
|
|
}
|
|
end
|
|
|
|
###################
|
|
|
|
def postscript_output(file=nil, keys={})
|
|
if file.kind_of?(Hash)
|
|
keys = file
|
|
file = nil
|
|
end
|
|
|
|
if file
|
|
tk_send('postscript', 'output', file, keys)
|
|
self
|
|
else
|
|
tk_send('postscript', 'output', keys)
|
|
end
|
|
end
|
|
|
|
###################
|
|
|
|
def marker_create(type, keys={})
|
|
case type
|
|
when :text, 'text'
|
|
Tk::BLT::PlotComponent::TextMarker.new(self, keys)
|
|
when :line, 'line'
|
|
Tk::BLT::PlotComponent::LineMarker.new(self, keys)
|
|
when :bitmap, 'bitmap'
|
|
Tk::BLT::PlotComponent::BitmapMarker.new(self, keys)
|
|
when :image, 'image'
|
|
Tk::BLT::PlotComponent::ImageMarker.new(self, keys)
|
|
when :polygon, 'polygon'
|
|
Tk::BLT::PlotComponent::PolygonMarker.new(self, keys)
|
|
when :window, 'window'
|
|
Tk::BLT::PlotComponent::WindowMarker.new(self, keys)
|
|
else
|
|
if type.kind_of?(Tk::BLT::PlotComponent::Marker)
|
|
type.new(self, keys)
|
|
else
|
|
Tk::BLT::PlotComponent::Marker.create_type(self, type, keys)
|
|
end
|
|
end
|
|
end
|
|
def marker_after(id, target=nil)
|
|
if target
|
|
tk_send_without_enc('marker', 'after', tagid(id), tagid(target))
|
|
else
|
|
tk_send_without_enc('marker', 'after', tagid(id))
|
|
end
|
|
self
|
|
end
|
|
def marker_before(id, target=None)
|
|
if target
|
|
tk_send_without_enc('marker', 'before', tagid(id), tagid(target))
|
|
else
|
|
tk_send_without_enc('marker', 'before', tagid(id))
|
|
end
|
|
self
|
|
end
|
|
def marker_delete(*ids)
|
|
tk_send('marker', 'delete', *(ids.collect{|id| tagid(id)}))
|
|
self
|
|
end
|
|
def marker_exist?(id)
|
|
bool(tk_send('marker', 'exists', tagid(id)))
|
|
end
|
|
def marker_names(*pats)
|
|
simplelist(tk_send('marker', 'names',
|
|
*(pats.collect{|pat| tagid(pat)}))).collect{|id|
|
|
Tk::BLT::PlotComponent::Marker.id2obj(self, id)
|
|
}
|
|
end
|
|
def marker_type(id)
|
|
tk_send('marker', 'type', tagid(id))
|
|
end
|
|
|
|
###################
|
|
|
|
def xaxis_cget(option)
|
|
itemcget('xaxis', option)
|
|
end
|
|
def xaxis_cget_strict(option)
|
|
itemcget_strict('xaxis', option)
|
|
end
|
|
def xaxis_configure(slot, value=None)
|
|
if slot.kind_of?(Hash)
|
|
slot = _symbolkey2str(slot)
|
|
if cmd = slot.delete('command')
|
|
slot['command'] = proc{|w, tick|
|
|
cmd.call(TkComm.window(w), TkComm.num_or_str(tick))
|
|
}
|
|
end
|
|
elsif slot == :command || slot == 'command'
|
|
cmd = value
|
|
value = proc{|w, tick|
|
|
cmd.call(TkComm.window(w), TkComm.num_or_str(tick))
|
|
}
|
|
end
|
|
itemconfigure('xaxis', slot, value)
|
|
end
|
|
def xaxis_configinfo(slot=nil)
|
|
itemconfiginfo('xaxis', slot)
|
|
end
|
|
def current_xaxis_configinfo(slot=nil)
|
|
current_itemconfiginfo('xaxis', slot)
|
|
end
|
|
def xaxis_bind(context, *args)
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
|
cmd = args.shift
|
|
else
|
|
cmd = Proc.new
|
|
end
|
|
_bind([path, 'xaxis', 'bind'], context, cmd, *args)
|
|
self
|
|
end
|
|
def xaxis_bind_append(context, *args)
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
|
cmd = args.shift
|
|
else
|
|
cmd = Proc.new
|
|
end
|
|
_bind_append([path, 'xaxis', 'bind'], context, cmd, *args)
|
|
self
|
|
end
|
|
def xaxis_bind_remove(context)
|
|
_bind_remove([path, 'xaxis', 'bind'], context)
|
|
self
|
|
end
|
|
def xaxis_bindinfo(context=nil)
|
|
_bindinfo([path, 'xaxis', 'bind'], context)
|
|
end
|
|
def xaxis_invtransform(val)
|
|
list(tk_send('xaxis', 'invtransform', val))
|
|
end
|
|
def xaxis_limits
|
|
list(tk_send('xaxis', 'limits'))
|
|
end
|
|
def xaxis_transform(val)
|
|
list(tk_send('xaxis', 'transform', val))
|
|
end
|
|
def xaxis_use(target=nil)
|
|
if target
|
|
Tk::BLT::PlotComponent::Axis.id2obj(self,
|
|
tk_send('xaxis', 'use',
|
|
tagid(target)))
|
|
else
|
|
Tk::BLT::PlotComponent::Axis.id2obj(self, tk_send('xaxis', 'use'))
|
|
end
|
|
end
|
|
|
|
def x2axis_cget(option)
|
|
itemcget('x2axis', option)
|
|
end
|
|
def x2axis_cget_strict(option)
|
|
itemcget_strict('x2axis', option)
|
|
end
|
|
def x2axis_configure(slot, value=None)
|
|
if slot.kind_of?(Hash)
|
|
slot = _symbolkey2str(slot)
|
|
if cmd = slot.delete('command')
|
|
slot['command'] = proc{|w, tick|
|
|
cmd.call(TkComm.window(w), TkComm.num_or_str(tick))
|
|
}
|
|
end
|
|
elsif slot == :command || slot == 'command'
|
|
cmd = value
|
|
value = proc{|w, tick|
|
|
cmd.call(TkComm.window(w), TkComm.num_or_str(tick))
|
|
}
|
|
end
|
|
itemconfigure('x2axis', slot, value)
|
|
end
|
|
def x2axis_configinfo(slot=nil)
|
|
itemconfiginfo('x2axis', slot)
|
|
end
|
|
def current_x2axis_configinfo(slot=nil)
|
|
current_itemconfiginfo('x2axis', slot)
|
|
end
|
|
def x2axis_bind(context, *args)
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
|
cmd = args.shift
|
|
else
|
|
cmd = Proc.new
|
|
end
|
|
_bind([path, 'x2axis', 'bind'], context, cmd, *args)
|
|
self
|
|
end
|
|
def x2axis_bind_append(context, *args)
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
|
cmd = args.shift
|
|
else
|
|
cmd = Proc.new
|
|
end
|
|
_bind_append([path, 'x2axis', 'bind'], context, cmd, *args)
|
|
self
|
|
end
|
|
def x2axis_bind_remove(context)
|
|
_bind_remove([path, 'x2axis', 'bind'], context)
|
|
self
|
|
end
|
|
def x2axis_bindinfo(context=nil)
|
|
_bindinfo([path, 'x2axis', 'bind'], context)
|
|
end
|
|
def x2axis_invtransform(val)
|
|
list(tk_send('x2axis', 'invtransform', val))
|
|
end
|
|
def x2axis_limits
|
|
list(tk_send('x2axis', 'limits'))
|
|
end
|
|
def x2axis_transform(val)
|
|
list(tk_send('x2axis', 'transform', val))
|
|
end
|
|
def x2axis_use(target=nil)
|
|
if target
|
|
Tk::BLT::PlotComponent::Axis.id2obj(self,
|
|
tk_send('x2axis', 'use',
|
|
tagid(target)))
|
|
else
|
|
Tk::BLT::PlotComponent::Axis.id2obj(self, tk_send('x2axis', 'use'))
|
|
end
|
|
end
|
|
|
|
def yaxis_cget(option)
|
|
itemcget('yaxis', option)
|
|
end
|
|
def yaxis_cget_strict(option)
|
|
itemcget_strict('yaxis', option)
|
|
end
|
|
def yaxis_configure(slot, value=None)
|
|
if slot.kind_of?(Hash)
|
|
slot = _symbolkey2str(slot)
|
|
if cmd = slot.delete('command')
|
|
slot['command'] = proc{|w, tick|
|
|
cmd.call(TkComm.window(w), TkComm.num_or_str(tick))
|
|
}
|
|
end
|
|
elsif slot == :command || slot == 'command'
|
|
cmd = value
|
|
value = proc{|w, tick|
|
|
cmd.call(TkComm.window(w), TkComm.num_or_str(tick))
|
|
}
|
|
end
|
|
itemconfigure('yaxis', slot, value)
|
|
end
|
|
def yaxis_configinfo(slot=nil)
|
|
itemconfiginfo('yaxis', slot)
|
|
end
|
|
def current_yaxis_configinfo(slot=nil)
|
|
current_itemconfiginfo('yaxis', slot)
|
|
end
|
|
def yaxis_bind(context, *args)
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
|
cmd = args.shift
|
|
else
|
|
cmd = Proc.new
|
|
end
|
|
_bind([path, 'yaxis', 'bind'], context, cmd, *args)
|
|
self
|
|
end
|
|
def yaxis_bind_append(context, *args)
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
|
cmd = args.shift
|
|
else
|
|
cmd = Proc.new
|
|
end
|
|
_bind_append([path, 'yaxis', 'bind'], context, cmd, *args)
|
|
self
|
|
end
|
|
def yaxis_bind_remove(context)
|
|
_bind_remove([path, 'yaxis', 'bind'], context)
|
|
self
|
|
end
|
|
def yaxis_bindinfo(context=nil)
|
|
_bindinfo([path, 'yaxis', 'bind'], context)
|
|
end
|
|
def yaxis_invtransform(val)
|
|
list(tk_send('yaxis', 'invtransform', val))
|
|
end
|
|
def yaxis_limits
|
|
list(tk_send('yaxis', 'limits'))
|
|
end
|
|
def yaxis_transform(val)
|
|
list(tk_send('yaxis', 'transform', val))
|
|
end
|
|
def yaxis_use(target=nil)
|
|
if target
|
|
Tk::BLT::PlotComponent::Axis.id2obj(self,
|
|
tk_send('yaxis', 'use',
|
|
tagid(target)))
|
|
else
|
|
Tk::BLT::PlotComponent::Axis.id2obj(self, tk_send('yaxis', 'use'))
|
|
end
|
|
end
|
|
|
|
def y2axis_cget(option)
|
|
itemcget('y2axis', option)
|
|
end
|
|
def y2axis_cget_strict(option)
|
|
itemcget_strict('y2axis', option)
|
|
end
|
|
def y2axis_configure(slot, value=None)
|
|
if slot.kind_of?(Hash)
|
|
slot = _symbolkey2str(slot)
|
|
if cmd = slot.delete('command')
|
|
slot['command'] = proc{|w, tick|
|
|
cmd.call(TkComm.window(w), TkComm.num_or_str(tick))
|
|
}
|
|
end
|
|
elsif slot == :command || slot == 'command'
|
|
cmd = value
|
|
value = proc{|w, tick|
|
|
cmd.call(TkComm.window(w), TkComm.num_or_str(tick))
|
|
}
|
|
end
|
|
itemconfigure('y2axis', slot, value)
|
|
end
|
|
def y2axis_configinfo(slot=nil)
|
|
axis_configinfo('y2axis', slot)
|
|
end
|
|
def current_y2axis_configinfo(slot=nil)
|
|
current_itemconfiginfo('y2axis', slot)
|
|
end
|
|
def y2axis_bind(context, *args)
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
|
cmd = args.shift
|
|
else
|
|
cmd = Proc.new
|
|
end
|
|
_bind([path, 'y2axis', 'bind'], context, cmd, *args)
|
|
self
|
|
end
|
|
def y2axis_bind_append(context, *args)
|
|
if TkComm._callback_entry?(args[0]) || !block_given?
|
|
cmd = args.shift
|
|
else
|
|
cmd = Proc.new
|
|
end
|
|
_bind_append([path, 'y2axis', 'bind'], context, cmd, *args)
|
|
self
|
|
end
|
|
def y2axis_bind_remove(context)
|
|
_bind_remove([path, 'y2axis', 'bind'], context)
|
|
self
|
|
end
|
|
def y2axis_bindinfo(context=nil)
|
|
_bindinfo([path, 'y2axis', 'bind'], context)
|
|
end
|
|
def y2axis_invtransform(val)
|
|
list(tk_send('y2axis', 'invtransform', val))
|
|
end
|
|
def y2axis_limits
|
|
list(tk_send('y2axis', 'limits'))
|
|
end
|
|
def y2axis_transform(val)
|
|
list(tk_send('y2axis', 'transform', val))
|
|
end
|
|
def y2axis_use(target=nil)
|
|
if target
|
|
Tk::BLT::PlotComponent::Axis.id2obj(self,
|
|
tk_send('y2axis', 'use',
|
|
tagid(target)))
|
|
else
|
|
Tk::BLT::PlotComponent::Axis.id2obj(self, tk_send('y2axis', 'use'))
|
|
end
|
|
end
|
|
end
|
|
end
|