import string
import types
import Tkinter
_busyCommand = '::blt::busy'
_vectorCommand = '::blt::vector'
_graphCommand = '::blt::graph'
_testCommand = '::blt::*'
_chartCommand = '::blt::stripchart'
_tabsetCommand = '::blt::tabset'
_haveBlt = None
_haveBltBusy = None
def _checkForBlt(window):

    global _haveBlt
    global _haveBltBusy
    try:
	window.tk.call('package', 'require', 'BLT')
    except Tkinter.TclError:
	try:
	    window.tk.call('load', '', 'Blt')
	except Tkinter.TclError:
	    pass
    _haveBlt= (window.tk.call('info', 'commands', _testCommand) != '')
    _haveBltBusy = (window.tk.call('info', 'commands', _busyCommand) != '')
def haveblt(window):

    if _haveBlt is None:
	_checkForBlt(window)
    return _haveBlt
def havebltbusy(window):

    if _haveBlt is None:
	_checkForBlt(window)
    return _haveBltBusy
def _loadBlt(window):

    if _haveBlt is None:
	if window is None:
	    window = Tkinter._default_root
	    if window is None:
	    	window = Tkinter.Tk()
	_checkForBlt(window)
def busy_hold(window, cursor = None):

    _loadBlt(window)
    if cursor is None:
        window.tk.call(_busyCommand, 'hold', window._w)
    else:
        window.tk.call(_busyCommand, 'hold', window._w, '-cursor', cursor)
def busy_release(window):

    _loadBlt(window)
    window.tk.call(_busyCommand, 'release', window._w)
def busy_forget(window):

    _loadBlt(window)
    window.tk.call(_busyCommand, 'forget', window._w)
def vector_expr(expression):

    tk = Tkinter._default_root.tk
    strList = tk.splitlist(tk.call(_vectorCommand, 'expr', expression))
    return tuple(map(string.atof, strList))
def vector_names(pattern = None):

    tk = Tkinter._default_root.tk
    return tk.splitlist(tk.call(_vectorCommand, 'names', pattern))
class Vector:


    _varnum = 0
    def __init__(self, size=None, master=None):

	_loadBlt(master)
	if master:
	    self._master = master
	else:
	    self._master = Tkinter._default_root
	self.tk = self._master.tk
	self._name = 'PY_VEC' + str(Vector._varnum)
	Vector._varnum = Vector._varnum + 1
	if size is None:
	    self.tk.call(_vectorCommand, 'create', self._name)
	else:
	  self.tk.call(_vectorCommand, 'create', '%s(%s)' % (self._name, size))
    def __del__(self):

	self.tk.call(_vectorCommand, 'destroy', self._name)
    def __str__(self):

	return self._name
    def __repr__(self):

	return '[' + string.join(map(str, self), ', ') + ']'
    def __cmp__(self, list):

	return cmp(self[:], list)
    def __len__(self):

	return self.tk.getint(self.tk.call(self._name, 'length'))
    def __getitem__(self, key):

	oldkey = key
	if key < 0:
	    key = key + len(self)
	try:
	    return self.tk.getdouble(self.tk.globalgetvar(self._name, str(key)))
        except Tkinter.TclError:
	    raise IndexError, oldkey
    def __setitem__(self, key, value):

	if key < 0:
	    key = key + len(self)
	return self.tk.globalsetvar(self._name, str(key), float(value))
    def __delitem__(self, key):

	if key < 0:
	    key = key + len(self)
	return self.tk.globalunsetvar(self._name, str(key))
    def __getslice__(self, start, end):

	length = len(self)
	if start < 0:
	    start = 0
	if end > length:
	    end = length
	if start >= end:
	    return []
	end = end - 1
	text = self.tk.globalgetvar(self._name, str(start) + ':' + str(end))
	return map(self.tk.getdouble, self.tk.splitlist(text))
    def __setslice__(self, start, end, list):

	if start > end:
	    end = start
	self.set(self[:start] + list + self[end:])
    def __delslice__(self, start, end):

	if start < end:
	    self.set(self[:start] + self[end:])
    def __add__(self, list):

	return self[:] + list
    def __radd__(self, list):

	return list + self[:]
    def __mul__(self, n):

	return self[:] * n
    __rmul__ = __mul__
    def append(self, *args):

	self.tk.call(self._name, 'append', args)
    def count(self, obj):

	return self[:].count(obj)
    def index(self, value):

	return self[:].index(value)
    def insert(self, index, value):

	self[index:index] = [value]
    def remove(self, value):

	del self[self.index(value)]
    def reverse(self):

	s = self[:]
	s.reverse()
	self.set(s)
    def sort(self, *args):

	s = self[:]
	s.sort()
	self.set(s)
    def clear(self):

	self.tk.call(self._name, 'clear')
    def delete(self, *args):

	self.tk.call((self._name, 'delete') + args)
    def expr(self, expression):

	self.tk.call(self._name, 'expr', expression)
    def length(self, newSize=None):

	return self.tk.getint(self.tk.call(self._name, 'length', newSize))
    def range(self, first, last=None):

	text = self.tk.call(self._name, 'range', first, last)
	return map(self.tk.getdouble, self.tk.splitlist(text))
    def search(self, start, end=None):

	return self._master._getints(self.tk.call(
		self._name, 'search', start, end))
    def set(self, list):

	if type(list) != types.TupleType:
	    list = tuple(list)
	self.tk.call(self._name, 'set', list)
    def blt_sort(self, *args):

	self.tk.call((self._name, 'sort') + args)
    def blt_sort_reverse(self, *args):

	self.tk.call((self._name, 'sort', '-reverse') + args)
    def min(self):

	return self.tk.getdouble(self.tk.globalgetvar(self._name, 'min'))
    def max(self):

	return self.tk.getdouble(self.tk.globalgetvar(self._name, 'max'))
    def get(self):

	return self[:]
def _doConfigure(widget, subcommand, option, kw):

    if not option and not kw:
        ret = {}
        options = widget.tk.splitlist(widget.tk.call(subcommand))
        for optionString in options:
            optionInfo = widget.tk.splitlist(optionString)
            option = optionInfo[0][1:]
            ret[option] = (option,) + optionInfo[1:]
        return ret
    if option:
        if kw:
            raise ValueError, 'cannot have option argument with keywords'
        option = '-' + option
        optionInfo = widget.tk.splitlist(widget.tk.call(subcommand + (option,)))
        return (optionInfo[0][1:],) + optionInfo[1:]
    widget.tk.call(subcommand + widget._options(kw))
class Graph(Tkinter.Widget):


    def __init__(self, master=None, cnf={}, **kw):

	_loadBlt(master)
	Tkinter.Widget.__init__(self, master, _graphCommand, cnf, kw)
    def bar_create(self, name, **kw):

	self.tk.call((self._w, 'bar', 'create', name) + self._options(kw))
    def line_create(self, name, **kw):

	self.tk.call((self._w, 'line', 'create', name) + self._options(kw))
    def extents(self, item):

	return self.tk.getint(self.tk.call(self._w, 'extents', item))
    def invtransform(self, winX, winY):

	return self._getdoubles(
		self.tk.call(self._w, 'invtransform', winX, winY))
    def inside(self, x, y):

	return self.tk.getint(self.tk.call(self._w, 'inside', x, y))
    def snap(self, photoName):

	self.tk.call(self._w, 'snap', photoName)
    def transform(self, x, y):

	return self._getdoubles(self.tk.call(self._w, 'transform', x, y))
    def axis_cget(self, axisName, key):

	return self.tk.call(self._w, 'axis', 'cget', axisName, '-' + key)
    def axis_configure(self, axes, option=None, **kw):

	if type(axes) == types.StringType:
            axes = [axes]
	subcommand = (self._w, 'axis', 'configure') + tuple(axes)
	return _doConfigure(self, subcommand, option, kw)
    def axis_create(self, axisName, **kw):

	self.tk.call((self._w, 'axis', 'create', axisName) + self._options(kw))
    def axis_delete(self, *args):

	self.tk.call((self._w, 'axis', 'delete') + args)
    def axis_invtransform(self, axisName, value):

	return self.tk.getdouble(self.tk.call(
		self._w, 'axis', 'invtransform', axisName, value))
    def axis_limits(self, axisName):

	return self._getdoubles(self.tk.call(
		self._w, 'axis', 'limits', axisName))
    def axis_names(self, *args):

        return self.tk.splitlist(
                self.tk.call((self._w, 'axis', 'names') + args))
    def axis_transform(self, axisName, value):

	return self.tk.getint(self.tk.call(
		self._w, 'axis', 'transform', axisName, value))
    def xaxis_cget(self, key):

	return self.tk.call(self._w, 'xaxis', 'cget', '-' + key)
    def xaxis_configure(self, option=None, **kw):

	subcommand = (self._w, 'xaxis', 'configure')
	return _doConfigure(self, subcommand, option, kw)
    def xaxis_invtransform(self, value):

	return self.tk.getdouble(self.tk.call(
		self._w, 'xaxis', 'invtransform', value))
    def xaxis_limits(self):

	return self._getdoubles(self.tk.call(self._w, 'xaxis', 'limits'))
    def xaxis_transform(self, value):

	return self.tk.getint(self.tk.call(
		self._w, 'xaxis', 'transform', value))
    def xaxis_use(self, axisName = None):

	return self.tk.call(self._w, 'xaxis', 'use', axisName)
    def x2axis_cget(self, key):

	return self.tk.call(self._w, 'x2axis', 'cget', '-' + key)
    def x2axis_configure(self, option=None, **kw):

	subcommand = (self._w, 'x2axis', 'configure')
	return _doConfigure(self, subcommand, option, kw)
    def x2axis_invtransform(self, value):

	return self.tk.getdouble(self.tk.call(
		self._w, 'x2axis', 'invtransform', value))
    def x2axis_limits(self):

	return self._getdoubles(self.tk.call(self._w, 'x2axis', 'limits'))
    def x2axis_transform(self, value):

	return self.tk.getint(self.tk.call(
		self._w, 'x2axis', 'transform', value))
    def x2axis_use(self, axisName = None):

	return self.tk.call(self._w, 'x2axis', 'use', axisName)
    def yaxis_cget(self, key):

	return self.tk.call(self._w, 'yaxis', 'cget', '-' + key)
    def yaxis_configure(self, option=None, **kw):

	subcommand = (self._w, 'yaxis', 'configure')
	return _doConfigure(self, subcommand, option, kw)
    def yaxis_invtransform(self, value):

	return self.tk.getdouble(self.tk.call(
		self._w, 'yaxis', 'invtransform', value))
    def yaxis_limits(self):

	return self._getdoubles(self.tk.call(self._w, 'yaxis', 'limits'))
    def yaxis_transform(self, value):

	return self.tk.getint(self.tk.call(
		self._w, 'yaxis', 'transform', value))
    def yaxis_use(self, axisName = None):

	return self.tk.call(self._w, 'yaxis', 'use', axisName)
    def y2axis_cget(self, key):

	return self.tk.call(self._w, 'y2axis', 'cget', '-' + key)
    def y2axis_configure(self, option=None, **kw):

	subcommand = (self._w, 'y2axis', 'configure')
	return _doConfigure(self, subcommand, option, kw)
    def y2axis_invtransform(self, value):

	return self.tk.getdouble(self.tk.call(
		self._w, 'y2axis', 'invtransform', value))
    def y2axis_limits(self):

	return self._getdoubles(self.tk.call(self._w, 'y2axis', 'limits'))
    def y2axis_transform(self, value):

	return self.tk.getint(self.tk.call(
		self._w, 'y2axis', 'transform', value))
    def y2axis_use(self, axisName = None):

	return self.tk.call(self._w, 'y2axis', 'use', axisName)
    def crosshairs_cget(self, key):

	return self.tk.call(self._w, 'crosshairs', 'cget', '-' + key)
    def crosshairs_configure(self, option=None, **kw):

	subcommand = (self._w, 'crosshairs', 'configure')
	return _doConfigure(self, subcommand, option, kw)
    def crosshairs_off(self):

	self.tk.call(self._w, 'crosshairs', 'off')
    def crosshairs_on(self):

	self.tk.call(self._w, 'crosshairs', 'on')
    def crosshairs_toggle(self):

	self.tk.call(self._w, 'crosshairs', 'toggle')
    def element_activate(self, name, *args):

	self.tk.call((self._w, 'element', 'activate', name) + args)
    def element_bind(self, tagName, sequence=None, func=None, add=None):

        return self._bind((self._w, 'element', 'bind', tagName),
                sequence, func, add)
    def element_unbind(self, tagName, sequence, funcid=None):

        self.tk.call(self._w, 'element', 'bind', tagName, sequence, '')
        if funcid:
            self.deletecommand(funcid)
    def element_cget(self, name, key):

	return self.tk.call(self._w, 'element', 'cget', name, '-' + key)
    def element_closest(self, x, y, *args, **kw):

        var = 'python_private_1'
	success = self.tk.getint(self.tk.call(
                (self._w, 'element', 'closest', x, y, var) +
                        self._options(kw) + args))
	if success:
	    rtn = {}
	    rtn['dist'] = self.tk.getdouble(self.tk.globalgetvar(var, 'dist'))
	    rtn['x'] = self.tk.getdouble(self.tk.globalgetvar(var, 'x'))
	    rtn['y'] = self.tk.getdouble(self.tk.globalgetvar(var, 'y'))
	    rtn['index'] = self.tk.getint(self.tk.globalgetvar(var, 'index'))
	    rtn['name'] = self.tk.globalgetvar(var, 'name')
	    return rtn
	else:
	    return None
    def element_configure(self, names, option=None, **kw):

	if type(names) == types.StringType:
            names = [names]
	subcommand = (self._w, 'element', 'configure') + tuple(names)
	return _doConfigure(self, subcommand, option, kw)
    def element_deactivate(self, *args):

	self.tk.call((self._w, 'element', 'deactivate') + args)
    def element_delete(self, *args):

	self.tk.call((self._w, 'element', 'delete') + args)
    def element_exists(self, name):

	return self.tk.getboolean(
		self.tk.call(self._w, 'element', 'exists', name))
    def element_names(self, *args):

        return self.tk.splitlist(
                self.tk.call((self._w, 'element', 'names') + args))
    def element_show(self, nameList=None):

	if nameList is not None:
	    nameList = tuple(nameList)
	return self.tk.splitlist(
		self.tk.call(self._w, 'element', 'show', nameList))
    def element_type(self, name):

	return self.tk.call(self._w, 'element', 'type', name)
    def grid_cget(self, key):

	return self.tk.call(self._w, 'grid', 'cget', '-' + key)
    def grid_configure(self, option=None, **kw):

	subcommand = (self._w, 'grid', 'configure')
	return _doConfigure(self, subcommand, option, kw)
    def grid_off(self):

	self.tk.call(self._w, 'grid', 'off')
    def grid_on(self):

	self.tk.call(self._w, 'grid', 'on')
    def grid_toggle(self):

	self.tk.call(self._w, 'grid', 'toggle')
    def legend_activate(self, *args):

	self.tk.call((self._w, 'legend', 'activate') + args)
    def legend_bind(self, tagName, sequence=None, func=None, add=None):

        return self._bind((self._w, 'legend', 'bind', tagName),
                sequence, func, add)
    def legend_unbind(self, tagName, sequence, funcid=None):

        self.tk.call(self._w, 'legend', 'bind', tagName, sequence, '')
        if funcid:
            self.deletecommand(funcid)
    def legend_cget(self, key):

	return self.tk.call(self._w, 'legend', 'cget', '-' + key)
    def legend_configure(self, option=None, **kw):

	subcommand = (self._w, 'legend', 'configure')
	return _doConfigure(self, subcommand, option, kw)
    def legend_deactivate(self, *args):

	self.tk.call((self._w, 'legend', 'deactivate') + args)
    def legend_get(self, pos):

	return self.tk.call(self._w, 'legend', 'get', pos)
    def pen_cget(self, name, key):

	return self.tk.call(self._w, 'pen', 'cget', name, '-' + key)
    def pen_configure(self, names, option=None, **kw):

	if type(names) == types.StringType:
            names = [names]
	subcommand = (self._w, 'pen', 'configure') + tuple(names)
	return _doConfigure(self, subcommand, option, kw)
    def pen_create(self, name, **kw):

	self.tk.call((self._w, 'pen', 'create', name) + self._options(kw))
    def pen_delete(self, *args):

	self.tk.call((self._w, 'pen', 'delete') + args)
    def pen_names(self, *args):

        return self.tk.splitlist(self.tk.call((self._w, 'pen', 'names') + args))
    def postscript_cget(self, key):

	return self.tk.call(self._w, 'postscript', 'cget', '-' + key)
    def postscript_configure(self, option=None, **kw):

	subcommand = (self._w, 'postscript', 'configure')
	return _doConfigure(self, subcommand, option, kw)
    def postscript_output(self, fileName=None, **kw):

	prefix = (self._w, 'postscript', 'output')
	if fileName is None:
	    return self.tk.call(prefix + self._options(kw))
	else:
	    self.tk.call(prefix + (fileName,) + self._options(kw))
    def marker_after(self, first, second=None):

	self.tk.call(self._w, 'marker', 'after', first, second)
    def marker_before(self, first, second=None):

	self.tk.call(self._w, 'marker', 'before', first, second)
    def marker_bind(self, tagName, sequence=None, func=None, add=None):

        return self._bind((self._w, 'marker', 'bind', tagName),
                sequence, func, add)
    def marker_unbind(self, tagName, sequence, funcid=None):

        self.tk.call(self._w, 'marker', 'bind', tagName, sequence, '')
        if funcid:
            self.deletecommand(funcid)
    def marker_cget(self, name, key):

	return self.tk.call(self._w, 'marker', 'cget', name, '-' + key)
    def marker_configure(self, names, option=None, **kw):

	if type(names) == types.StringType:
            names = [names]
	subcommand = (self._w, 'marker', 'configure') + tuple(names)
	return _doConfigure(self, subcommand, option, kw)
    def marker_create(self, type, **kw):

	return self.tk.call(
                (self._w, 'marker', 'create', type) + self._options(kw))
    def marker_delete(self, *args):

	self.tk.call((self._w, 'marker', 'delete') + args)
    def marker_exists(self, name):

	return self.tk.getboolean(
		self.tk.call(self._w, 'marker', 'exists', name))
    def marker_names(self, *args):

        return self.tk.splitlist(
                self.tk.call((self._w, 'marker', 'names') + args))
    def marker_type(self, name):

	type = self.tk.call(self._w, 'marker', 'type', name)
	if type == '':
	    type = None
	return type
class Stripchart(Graph):


    def __init__(self, master=None, cnf={}, **kw):

	_loadBlt(master)
	Tkinter.Widget.__init__(self, master, _chartCommand, cnf, kw)
class Tabset(Tkinter.Widget):


    def __init__(self, master=None, cnf={}, **kw):

	_loadBlt(master)
	Tkinter.Widget.__init__(self, master, _tabsetCommand, cnf, kw)
    def activate(self, tabIndex):

        self.tk.call(self._w, 'activate', tabIndex)
    def tag_bind(self, tagName, sequence=None, func=None, add=None):

        return self._bind((self._w, 'bind', tagName), sequence, func, add)
    def tag_unbind(self, tagName, sequence, funcid=None):

        self.tk.call(self._w, 'bind', tagName, sequence, '')
        if funcid:
            self.deletecommand(funcid)
    def delete(self, first, last = None):

    	self.tk.call(self._w, 'delete', first, last)
    def tab_focus(self, tabIndex):

    	self.tk.call(self._w, 'focus', tabIndex)
    def get(self, tabIndex):

	return self.tk.call(self._w, 'get', tabIndex)
    def index(self, tabIndex):

	index = self.tk.call(self._w, 'index', tabIndex)
        if index == '':
            return None
        else:
            return self.tk.getint(self.tk.call(self._w, 'index', tabIndex))
    def insert(self, position, name1, *names, **kw):

	self.tk.call(
            (self._w, 'insert', position, name1) + names + self._options(kw))
    def invoke(self, tabIndex):

    	return self.tk.call(self._w, 'invoke', tabIndex)
    def move(self, tabIndex1, beforeOrAfter, tabIndex2):

    	self.tk.call(self._w, 'move', tabIndex1, beforeOrAfter, tabIndex2)
    def nearest(self, x, y):

    	return self.tk.call(self._w, 'nearest', x, y)
    def scan_mark(self, x, y):

        self.tk.call(self._w, 'scan', 'mark', x, y)
    def scan_dragto(self, x, y):

        self.tk.call(self._w, 'scan', 'dragto', x, y)
    def see(self, index):

        self.tk.call(self._w, 'see', index)
    def see(self, tabIndex):

    	self.tk.call(self._w,'see',tabIndex)
    def size(self):

	return self.tk.getint(self.tk.call(self._w, 'size'))
    def tab_cget(self, tabIndex, option):

        if option[:1] != '-':
            option = '-' + option
        if option[-1:] == '_':
            option = option[:-1]
        return self.tk.call(self._w, 'tab', 'cget', tabIndex, option)
    def tab_configure(self, tabIndexes, option=None, **kw):

	if type(tabIndexes) in (types.StringType, types.IntType):
            tabIndexes = [tabIndexes]
	subcommand = (self._w, 'tab', 'configure') + tuple(tabIndexes)
	return _doConfigure(self, subcommand, option, kw)
    def tab_names(self, *args):

        return self.tk.splitlist(self.tk.call((self._w, 'tab', 'names') + args))
    def tab_tearoff(self, tabIndex, newName = None):

        if newName is None:
            name = self.tk.call(self._w, 'tab', 'tearoff', tabIndex)
            return self.nametowidget(name)
        else:
            self.tk.call(self._w, 'tab', 'tearoff', tabIndex, newName)
    def view(self):

        s = self.tk.call(self._w, 'view')
        return tuple(map(self.tk.getint, self.tk.splitlist(s)))
    def view_moveto(self, fraction):

        self.tk.call(self._w, 'view', 'moveto', fraction)
    def view_scroll(self, number, what):

        self.tk.call(self._w, 'view', 'scroll', number, what)