"""The tix commands provide access to miscellaneous elements

def tix_addbitmapdir(self, directory):

"""Tix maintains a list of directories under which

return self.tk.call('tix', 'addbitmapdir', directory)

def tix_cget(self, option):

"""Returns the current value of the configuration

return self.tk.call('tix', 'cget', option)

def tix_configure(self, cnf=None, **kw):

"""Query or modify the configuration options of the Tix application

# Copied from Tkinter.py

if kw:

cnf = _cnfmerge((cnf, kw))

elif cnf:

cnf = _cnfmerge(cnf)

if cnf is None:

cnf = {}

for x in self.tk.split(self.tk.call('tix', 'configure')):

cnf[x[0][1:]] = (x[0][1:],) + x[1:]

return cnf

if isinstance(cnf, StringType):

x = self.tk.split(self.tk.call('tix', 'configure', '-'+cnf))

return (x[0][1:],) + x[1:]

return self.tk.call(('tix', 'configure') + self._options(cnf))

def tix_filedialog(self, dlgclass=None):

"""Returns the file selection dialog that may be shared among

if dlgclass is not None:

return self.tk.call('tix', 'filedialog', dlgclass)

else:

return self.tk.call('tix', 'filedialog')

def tix_getbitmap(self, name):

"""Locates a bitmap file of the name name.xpm or name in one of the

return self.tk.call('tix', 'getbitmap', name)

def tix_getimage(self, name):

"""Locates an image file of the name name.xpm, name.xbm or name.ppm

return self.tk.call('tix', 'getimage', name)

def tix_option_get(self, name):

"""Gets the options manitained by the Tix

# could use self.tk.globalgetvar('tixOption', name)

return self.tk.call('tix', 'option', 'get', name)

def tix_resetoptions(self, newScheme, newFontSet, newScmPrio=None):

"""Resets the scheme and fontset of the Tix application to

if newScmPrio is not None:

return self.tk.call('tix', 'resetoptions', newScheme, newFontSet, newScmPrio)

else:

"""Toplevel widget of Tix which represents mostly the main window

def __init__(self, screenName=None, baseName=None, className='Tix'):

tkinter.Tk.__init__(self, screenName, baseName, className)

tixlib = os.environ.get('TIX_LIBRARY')

self.tk.eval('global auto_path; lappend auto_path [file dir [info nameof]]')

if tixlib is not None:

self.tk.eval('global auto_path; lappend auto_path {%s}' % tixlib)

self.tk.eval('global tcl_pkgPath; lappend tcl_pkgPath {%s}' % tixlib)

# Load Tix - this should work dynamically or statically

# If it's static, tcl/tix8.1/pkgIndex.tcl should have

# 'load {} Tix'

# If it's dynamic under Unix, tcl/tix8.1/pkgIndex.tcl should have

# 'load libtix8.1.8.3.so Tix'

self.tk.eval('package require Tix')

def destroy(self):

# For safety, remove an delete_window binding before destroy

self.protocol("WM_DELETE_WINDOW", "")

"""The Tix Form geometry manager

def config(self, cnf={}, **kw):

self.tk.call('tixForm', self._w, *self._options(cnf, kw))

form = config

def __setitem__(self, key, value):

Form.form(self, {key: value})

def check(self):

return self.tk.call('tixForm', 'check', self._w)

def forget(self):

self.tk.call('tixForm', 'forget', self._w)

def grid(self, xsize=0, ysize=0):

if (not xsize) and (not ysize):

x = self.tk.call('tixForm', 'grid', self._w)

y = self.tk.splitlist(x)

z = ()

for x in y:

z = z + (self.tk.getint(x),)

return z

return self.tk.call('tixForm', 'grid', self._w, xsize, ysize)

def info(self, option=None):

if not option:

return self.tk.call('tixForm', 'info', self._w)

if option[0] != '-':

option = '-' + option

return self.tk.call('tixForm', 'info', self._w, option)

def slaves(self):

return map(self._nametowidget,

self.tk.splitlist(

self.tk.call(

"""A TixWidget class is used to package all (or most) Tix widgets.

def __init__ (self, master=None, widgetName=None,

static_options=None, cnf={}, kw={}):

# Merge keywords and dictionary arguments

if kw:

cnf = _cnfmerge((cnf, kw))

else:

cnf = _cnfmerge(cnf)

# Move static options into extra. static_options must be

# a list of keywords (or None).

extra=()

# 'options' is always a static option

if static_options:

static_options.append('options')

else:

static_options = ['options']

for k,v in list(cnf.items()):

if k in static_options:

extra = extra + ('-' + k, v)

del cnf[k]

self.widgetName = widgetName

Widget._setup(self, master, cnf)

# If widgetName is None, this is a dummy creation call where the

# corresponding Tk widget has already been created by Tix

if widgetName:

self.tk.call(widgetName, self._w, *extra)

# Non-static options - to be done via a 'config' command

if cnf:

Widget.config(self, cnf)

# Dictionary to hold subwidget names for easier access. We can't

# use the children list because the public Tix names may not be the

# same as the pathname component

self.subwidget_list = {}

# We set up an attribute access function so that it is possible to

# do w.ok['text'] = 'Hello' rather than w.subwidget('ok')['text'] = 'Hello'

# when w is a StdButtonBox.

# We can even do w.ok.invoke() because w.ok is subclassed from the

# Button class if you go through the proper constructors

def __getattr__(self, name):

if name in self.subwidget_list:

return self.subwidget_list[name]

raise AttributeError(name)

def set_silent(self, value):

"""Set a variable without calling its action routine"""

self.tk.call('tixSetSilent', self._w, value)

def subwidget(self, name):

"""Return the named subwidget (which must have been created by

n = self._subwidget_name(name)

if not n:

raise TclError("Subwidget " + name + " not child of " + self._name)

# Remove header of name and leading dot

n = n[len(self._w)+1:]

return self._nametowidget(n)

def subwidgets_all(self):

"""Return all subwidgets."""

names = self._subwidget_names()

if not names:

return []

retlist = []

for name in names:

name = name[len(self._w)+1:]

try:

retlist.append(self._nametowidget(name))

except:

# some of the widgets are unknown e.g. border in LabelFrame

pass

return retlist

def _subwidget_name(self,name):

"""Get a subwidget name (returns a String, not a Widget !)"""

try:

return self.tk.call(self._w, 'subwidget', name)

except TclError:

return None

def _subwidget_names(self):

"""Return the name of all subwidgets."""

try:

x = self.tk.call(self._w, 'subwidgets', '-all')

return self.tk.split(x)

except TclError:

return None

def config_all(self, option, value):

"""Set configuration options for all subwidgets (and self)."""

if option == '':

return

elif not isinstance(option, StringType):

option = repr(option)

if not isinstance(value, StringType):

value = repr(value)

names = self._subwidget_names()

for name in names:

self.tk.call(name, 'configure', '-' + option, value)

# These are missing from Tkinter

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

if not master:

master = tkinter._default_root

if not master:

raise RuntimeError('Too early to create image')

if kw and cnf: cnf = _cnfmerge((cnf, kw))

elif kw: cnf = kw

options = ()

for k, v in cnf.items():

if hasattr(v, '__call__'):

v = self._register(v)

options = options + ('-'+k, v)

return master.tk.call(('image', 'create', imgtype,) + options)

def image_delete(self, imgname):

try:

self.tk.call('image', 'delete', imgname)

except TclError:

# May happen if the root was destroyed

"""Subwidget class.

def __init__(self, master, name,

destroy_physically=1, check_intermediate=1):

if check_intermediate:

path = master._subwidget_name(name)

try:

path = path[len(master._w)+1:]

plist = path.split('.')

except:

plist = []

if not check_intermediate:

# immediate descendant

TixWidget.__init__(self, master, None, None, {'name' : name})

else:

# Ensure that the intermediate widgets exist

parent = master

for i in range(len(plist) - 1):

n = '.'.join(plist[:i+1])

try:

w = master._nametowidget(n)

parent = w

except KeyError:

# Create the intermediate widget

parent = TixSubWidget(parent, plist[i],

destroy_physically=0,

check_intermediate=0)

# The Tk widget name is in plist, not in name

if plist:

name = plist[-1]

TixWidget.__init__(self, parent, None, None, {'name' : name})

self.destroy_physically = destroy_physically

def destroy(self):

# For some widgets e.g., a NoteBook, when we call destructors,

# we must be careful not to destroy the frame widget since this

# also destroys the parent NoteBook thus leading to an exception

# in Tkinter when it finally calls Tcl to destroy the NoteBook

for c in list(self.children.values()): c.destroy()

if self._name in self.master.children:

del self.master.children[self._name]

if self._name in self.master.subwidget_list:

del self.master.subwidget_list[self._name]

if self.destroy_physically:

# This is bypassed only for a few widgets

dict = {}

for x in lst:

dict[x[0][1:]] = (x[0][1:],) + x[1:]

"""DisplayStyle - handle configuration options shared by

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

master = _default_root # global from Tkinter

if not master and 'refwindow' in cnf: master=cnf['refwindow']

elif not master and 'refwindow' in kw: master= kw['refwindow']

elif not master: raise RuntimeError("Too early to create display style: no root window")

self.tk = master.tk

self.stylename = self.tk.call('tixDisplayStyle', itemtype,

*self._options(cnf,kw) )

def __str__(self):

return self.stylename

def _options(self, cnf, kw):

if kw and cnf:

cnf = _cnfmerge((cnf, kw))

elif kw:

cnf = kw

opts = ()

for k, v in cnf.items():

opts = opts + ('-'+k, v)

return opts

def delete(self):

self.tk.call(self.stylename, 'delete')

def __setitem__(self,key,value):

self.tk.call(self.stylename, 'configure', '-%s'%key, value)

def config(self, cnf={}, **kw):

return _lst2dict(

self.tk.split(

self.tk.call(

self.stylename, 'configure', *self._options(cnf,kw))))

def __getitem__(self,key):

"""Balloon help widget.

# FIXME: It should inherit -superclass tixShell

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

# static seem to be -installcolormap -initwait -statusbar -cursor

static = ['options', 'installcolormap', 'initwait', 'statusbar',

'cursor']

TixWidget.__init__(self, master, 'tixBalloon', static, cnf, kw)

self.subwidget_list['label'] = _dummyLabel(self, 'label',

destroy_physically=0)

self.subwidget_list['message'] = _dummyLabel(self, 'message',

destroy_physically=0)

def bind_widget(self, widget, cnf={}, **kw):

"""Bind balloon widget to another.

self.tk.call(self._w, 'bind', widget._w, *self._options(cnf, kw))

def unbind_widget(self, widget):

"""ButtonBox - A container for pushbuttons.

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

TixWidget.__init__(self, master, 'tixButtonBox',

['orientation', 'options'], cnf, kw)

def add(self, name, cnf={}, **kw):

"""Add a button with given name to box."""

btn = self.tk.call(self._w, 'add', name, *self._options(cnf, kw))

self.subwidget_list[name] = _dummyButton(self, name)

return btn

def invoke(self, name):

if name in self.subwidget_list:

"""ComboBox - an Entry field with a dropdown menu. The user can select a

# FIXME: It should inherit -superclass tixLabelWidget

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

TixWidget.__init__(self, master, 'tixComboBox',

['editable', 'dropdown', 'fancy', 'options'],

cnf, kw)

self.subwidget_list['label'] = _dummyLabel(self, 'label')

self.subwidget_list['entry'] = _dummyEntry(self, 'entry')

self.subwidget_list['arrow'] = _dummyButton(self, 'arrow')

self.subwidget_list['slistbox'] = _dummyScrolledListBox(self,

'slistbox')

try:

self.subwidget_list['tick'] = _dummyButton(self, 'tick')

self.subwidget_list['cross'] = _dummyButton(self, 'cross')

except TypeError:

# unavailable when -fancy not specified

pass

# align

def add_history(self, str):

self.tk.call(self._w, 'addhistory', str)

def append_history(self, str):

self.tk.call(self._w, 'appendhistory', str)

def insert(self, index, str):

self.tk.call(self._w, 'insert', index, str)

def pick(self, index):

"""Control - An entry field with value change arrows. The user can

# FIXME: It should inherit -superclass tixLabelWidget

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

TixWidget.__init__(self, master, 'tixControl', ['options'], cnf, kw)

self.subwidget_list['incr'] = _dummyButton(self, 'incr')

self.subwidget_list['decr'] = _dummyButton(self, 'decr')

self.subwidget_list['label'] = _dummyLabel(self, 'label')

self.subwidget_list['entry'] = _dummyEntry(self, 'entry')

def decrement(self):

self.tk.call(self._w, 'decr')

def increment(self):

self.tk.call(self._w, 'incr')

def invoke(self):

self.tk.call(self._w, 'invoke')

def update(self):

"""DirList - displays a list view of a directory, its previous

# FIXME: It should inherit -superclass tixScrolledHList

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

TixWidget.__init__(self, master, 'tixDirList', ['options'], cnf, kw)

self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')

self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')

self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')

def chdir(self, dir):

"""DirTree - Directory Listing in a hierarchical view.

# FIXME: It should inherit -superclass tixScrolledHList

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

TixWidget.__init__(self, master, 'tixDirTree', ['options'], cnf, kw)

self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')

self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')

self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')

def chdir(self, dir):

"""DirSelectBox - Motif style file select box.

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

TixWidget.__init__(self, master, 'tixDirSelectBox', ['options'], cnf, kw)

self.subwidget_list['dirlist'] = _dummyDirList(self, 'dirlist')

"""ExFileSelectBox - MS Windows style file select box.

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

TixWidget.__init__(self, master, 'tixExFileSelectBox', ['options'], cnf, kw)

self.subwidget_list['cancel'] = _dummyButton(self, 'cancel')

self.subwidget_list['ok'] = _dummyButton(self, 'ok')

self.subwidget_list['hidden'] = _dummyCheckbutton(self, 'hidden')

self.subwidget_list['types'] = _dummyComboBox(self, 'types')

self.subwidget_list['dir'] = _dummyComboBox(self, 'dir')

self.subwidget_list['dirlist'] = _dummyDirList(self, 'dirlist')

self.subwidget_list['file'] = _dummyComboBox(self, 'file')

self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist')

def filter(self):

self.tk.call(self._w, 'filter')

def invoke(self):

"""The DirSelectDialog widget presents the directories in the file

# FIXME: It should inherit -superclass tixDialogShell

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

TixWidget.__init__(self, master, 'tixDirSelectDialog',

['options'], cnf, kw)

self.subwidget_list['dirbox'] = _dummyDirSelectBox(self, 'dirbox')

# cancel and ok buttons are missing

def popup(self):

self.tk.call(self._w, 'popup')

def popdown(self):

"""ExFileSelectDialog - MS Windows style file select dialog.

# FIXME: It should inherit -superclass tixDialogShell

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

TixWidget.__init__(self, master, 'tixExFileSelectDialog',

['options'], cnf, kw)

self.subwidget_list['fsbox'] = _dummyExFileSelectBox(self, 'fsbox')

def popup(self):

self.tk.call(self._w, 'popup')

def popdown(self):

"""ExFileSelectBox - Motif style file select box.

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

TixWidget.__init__(self, master, 'tixFileSelectBox', ['options'], cnf, kw)

self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist')

self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist')

self.subwidget_list['filter'] = _dummyComboBox(self, 'filter')

self.subwidget_list['selection'] = _dummyComboBox(self, 'selection')

def apply_filter(self): # name of subwidget is same as command

self.tk.call(self._w, 'filter')

def invoke(self):

"""FileSelectDialog - Motif style file select dialog.

# FIXME: It should inherit -superclass tixStdDialogShell

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

TixWidget.__init__(self, master, 'tixFileSelectDialog',

['options'], cnf, kw)

self.subwidget_list['btns'] = _dummyStdButtonBox(self, 'btns')

self.subwidget_list['fsbox'] = _dummyFileSelectBox(self, 'fsbox')

def popup(self):

self.tk.call(self._w, 'popup')

def popdown(self):

"""FileEntry - Entry field with button that invokes a FileSelectDialog.

# FIXME: It should inherit -superclass tixLabelWidget

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

TixWidget.__init__(self, master, 'tixFileEntry',

['dialogtype', 'options'], cnf, kw)

self.subwidget_list['button'] = _dummyButton(self, 'button')

self.subwidget_list['entry'] = _dummyEntry(self, 'entry')

def invoke(self):

self.tk.call(self._w, 'invoke')

def file_dialog(self):

# FIXME: return python object

"""HList - Hierarchy display widget can be used to display any data

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

TixWidget.__init__(self, master, 'tixHList',

['columns', 'options'], cnf, kw)

def add(self, entry, cnf={}, **kw):

return self.tk.call(self._w, 'add', entry, *self._options(cnf, kw))

def add_child(self, parent=None, cnf={}, **kw):

if not parent:

parent = ''

return self.tk.call(

self._w, 'addchild', parent, *self._options(cnf, kw))

def anchor_set(self, entry):

self.tk.call(self._w, 'anchor', 'set', entry)

def anchor_clear(self):

self.tk.call(self._w, 'anchor', 'clear')

def column_width(self, col=0, width=None, chars=None):

if not chars:

return self.tk.call(self._w, 'column', 'width', col, width)

else:

return self.tk.call(self._w, 'column', 'width', col,

'-char', chars)

def delete_all(self):

self.tk.call(self._w, 'delete', 'all')

def delete_entry(self, entry):

self.tk.call(self._w, 'delete', 'entry', entry)

def delete_offsprings(self, entry):

self.tk.call(self._w, 'delete', 'offsprings', entry)

def delete_siblings(self, entry):

self.tk.call(self._w, 'delete', 'siblings', entry)

def dragsite_set(self, index):

self.tk.call(self._w, 'dragsite', 'set', index)

def dragsite_clear(self):

self.tk.call(self._w, 'dragsite', 'clear')

def dropsite_set(self, index):

self.tk.call(self._w, 'dropsite', 'set', index)

def dropsite_clear(self):

self.tk.call(self._w, 'dropsite', 'clear')

def header_create(self, col, cnf={}, **kw):

self.tk.call(self._w, 'header', 'create', col, *self._options(cnf, kw))

def header_configure(self, col, cnf={}, **kw):

if cnf is None:

return _lst2dict(

self.tk.split(

self.tk.call(self._w, 'header', 'configure', col)))

self.tk.call(self._w, 'header', 'configure', col,

*self._options(cnf, kw))

def header_cget(self, col, opt):

return self.tk.call(self._w, 'header', 'cget', col, opt)

def header_exists(self, col):

return self.tk.call(self._w, 'header', 'exists', col)

def header_delete(self, col):

self.tk.call(self._w, 'header', 'delete', col)

def header_size(self, col):

return self.tk.call(self._w, 'header', 'size', col)

def hide_entry(self, entry):

self.tk.call(self._w, 'hide', 'entry', entry)

def indicator_create(self, entry, cnf={}, **kw):

self.tk.call(

self._w, 'indicator', 'create', entry, *self._options(cnf, kw))

def indicator_configure(self, entry, cnf={}, **kw):

if cnf is None:

return _lst2dict(

self.tk.split(

self.tk.call(self._w, 'indicator', 'configure', entry)))

self.tk.call(

self._w, 'indicator', 'configure', entry, *self._options(cnf, kw))

def indicator_cget(self, entry, opt):

return self.tk.call(self._w, 'indicator', 'cget', entry, opt)

def indicator_exists(self, entry):

return self.tk.call (self._w, 'indicator', 'exists', entry)

def indicator_delete(self, entry):

self.tk.call(self._w, 'indicator', 'delete', entry)

def indicator_size(self, entry):

return self.tk.call(self._w, 'indicator', 'size', entry)

def info_anchor(self):

return self.tk.call(self._w, 'info', 'anchor')

def info_children(self, entry=None):

c = self.tk.call(self._w, 'info', 'children', entry)

return self.tk.splitlist(c)

def info_data(self, entry):

return self.tk.call(self._w, 'info', 'data', entry)

def info_exists(self, entry):

return self.tk.call(self._w, 'info', 'exists', entry)

def info_hidden(self, entry):

return self.tk.call(self._w, 'info', 'hidden', entry)

def info_next(self, entry):

return self.tk.call(self._w, 'info', 'next', entry)

def info_parent(self, entry):

return self.tk.call(self._w, 'info', 'parent', entry)

def info_prev(self, entry):

return self.tk.call(self._w, 'info', 'prev', entry)

def info_selection(self):

c = self.tk.call(self._w, 'info', 'selection')

return self.tk.splitlist(c)

def item_cget(self, entry, col, opt):

return self.tk.call(self._w, 'item', 'cget', entry, col, opt)

def item_configure(self, entry, col, cnf={}, **kw):

if cnf is None:

return _lst2dict(

self.tk.split(

self.tk.call(self._w, 'item', 'configure', entry, col)))

self.tk.call(self._w, 'item', 'configure', entry, col,

*self._options(cnf, kw))