# -*-mode: python; fill-column: 75; tab-width: 8 -*-

#

# $Id$

#

# Tix.py -- Tix widget wrappers.

#

# For Tix, see http://tix.sourceforge.net

#

# - Sudhir Shenoy ([email protected]), Dec. 1995.

# based on an idea of Jean-Marc Lugrin ([email protected])

#

# NOTE: In order to minimize changes to Tkinter.py, some of the code here

# (TixWidget.__init__) has been taken from Tkinter (Widget.__init__)

# and will break if there are major changes in Tkinter.

#

# The Tix widgets are represented by a class hierarchy in python with proper

# inheritance of base classes.

#

# As a result after creating a 'w = StdButtonBox', I can write

# w.ok['text'] = 'Who Cares'

# or w.ok['bg'] = w['bg']

# or even w.ok.invoke()

# etc.

#

# Compare the demo tixwidgets.py to the original Tcl program and you will

# appreciate the advantages.

#

import os

import tkinter

from tkinter import *

from tkinter import _cnfmerge

# WARNING - TkVersion is a limited precision floating point number

if TkVersion < 3.999:

raise ImportError("This version of Tix.py requires Tk 4.0 or higher")

import _tkinter # If this fails your Python may not be configured for Tk

# Some more constants (for consistency with Tkinter)

WINDOW = 'window'

TEXT = 'text'

STATUS = 'status'

IMMEDIATE = 'immediate'

IMAGE = 'image'

IMAGETEXT = 'imagetext'

BALLOON = 'balloon'

AUTO = 'auto'

ACROSSTOP = 'acrosstop'

# A few useful constants for the Grid widget

ASCII = 'ascii'

CELL = 'cell'

COLUMN = 'column'

DECREASING = 'decreasing'

INCREASING = 'increasing'

INTEGER = 'integer'

MAIN = 'main'

MAX = 'max'

REAL = 'real'

ROW = 'row'

S_REGION = 's-region'

X_REGION = 'x-region'

Y_REGION = 'y-region'

# Some constants used by Tkinter dooneevent()

TCL_DONT_WAIT = 1 << 1

TCL_WINDOW_EVENTS = 1 << 2

TCL_FILE_EVENTS = 1 << 3

TCL_TIMER_EVENTS = 1 << 4

TCL_IDLE_EVENTS = 1 << 5

TCL_ALL_EVENTS = 0

# BEWARE - this is implemented by copying some code from the Widget class

# in Tkinter (to override Widget initialization) and is therefore

# liable to break.

# Could probably add this to Tkinter.Misc

class tixCommand:

"""The tix commands provide access to miscellaneous elements

of Tix's internal state and the Tix application context.

Most of the information manipulated by these commands pertains

to the application as a whole, or to a screen or

display, rather than to a particular window.

This is a mixin class, assumed to be mixed to Tkinter.Tk

that supports the self.tk.call method.

"""

def tix_addbitmapdir(self, directory):

"""Tix maintains a list of directories under which

the tix_getimage and tix_getbitmap commands will

search for image files. The standard bitmap directory

is $TIX_LIBRARY/bitmaps. The addbitmapdir command

adds directory into this list. By using this

command, the image files of an applications can

also be located using the tix_getimage or tix_getbitmap

command.

"""

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

def tix_cget(self, option):

"""Returns the current value of the configuration

option given by option. Option may be any of the

options described in the CONFIGURATION OPTIONS section.

"""

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

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

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

context. If no option is specified, returns a dictionary all of the

available options. If option is specified with no value, then the

command returns a list describing the one named option (this list

will be identical to the corresponding sublist of the value

returned if no option is specified). If one or more option-value

pairs are specified, then the command modifies the given option(s)

to have the given value(s); in this case the command returns an

empty string. Option may be any of the configuration options.

"""

# Copied from Tkinter.py

if kw:

cnf = _cnfmerge((cnf, kw))

elif cnf:

cnf = _cnfmerge(cnf)

if cnf is None:

return self._getconfigure('tix', 'configure')

if isinstance(cnf, str):

return self._getconfigure1('tix', 'configure', '-'+cnf)

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

different calls from this application. This command will create a

file selection dialog widget when it is called the first time. This

dialog will be returned by all subsequent calls to tix_filedialog.

An optional dlgclass parameter can be passed to specified what type

of file selection dialog widget is desired. Possible options are

tix FileSelectDialog or tixExFileSelectDialog.

"""

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

bitmap directories (see the tix_addbitmapdir command above). By

using tix_getbitmap, you can avoid hard coding the pathnames of the

bitmap files in your application. When successful, it returns the

complete pathname of the bitmap file, prefixed with the character

'@'. The returned value can be used to configure the -bitmap

option of the TK and Tix widgets.

"""

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

in one of the bitmap directories (see the addbitmapdir command

above). If more than one file with the same name (but different

extensions) exist, then the image type is chosen according to the

depth of the X display: xbm images are chosen on monochrome

displays and color images are chosen on color displays. By using

tix_ getimage, you can avoid hard coding the pathnames of the

image files in your application. When successful, this command

returns the name of the newly created image, which can be used to

configure the -image option of the Tk and Tix widgets.

"""

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

def tix_option_get(self, name):

"""Gets the options maintained by the Tix

scheme mechanism. Available options include:

active_bg active_fg bg

bold_font dark1_bg dark1_fg

dark2_bg dark2_fg disabled_fg

fg fixed_font font

inactive_bg inactive_fg input1_bg

input2_bg italic_font light1_bg

light1_fg light2_bg light2_fg

menu_font output1_bg output2_bg

select_bg select_fg selector

"""

# 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

newScheme and newFontSet, respectively. This affects only those

widgets created after this call. Therefore, it is best to call the

resetoptions command before the creation of any widgets in a Tix

application.

The optional parameter newScmPrio can be given to reset the

priority level of the Tk options set by the Tix schemes.

Because of the way Tk handles the X option database, after Tix has

been has imported and inited, it is not possible to reset the color

schemes and font sets using the tix config command. Instead, the

tix_resetoptions command must be used.

"""

if newScmPrio is not None:

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

else:

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

class Tk(tkinter.Tk, tixCommand):

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

of an application. It has an associated Tcl interpreter."""

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 the delete_window binding before destroy

self.protocol("WM_DELETE_WINDOW", "")

tkinter.Tk.destroy(self)

# The Tix 'tixForm' geometry manager

class Form:

"""The Tix Form geometry manager

Widgets can be arranged by specifying attachments to other widgets.

See Tix documentation for complete details"""

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 [self._nametowidget(x) for x in

self.tk.splitlist(

self.tk.call(

'tixForm', 'slaves', self._w))]

tkinter.Widget.__bases__ = tkinter.Widget.__bases__ + (Form,)

class TixWidget(tkinter.Widget):

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

Widget initialization is extended in two ways:

1) It is possible to give a list of options which must be part of

the creation command (so called Tix 'static' options). These cannot be

given as a 'config' command later.

2) It is possible to give the name of an existing TK widget. These are

child widgets created automatically by a Tix mega-widget. The Tk call

to create these widgets is therefore bypassed in TixWidget.__init__

Both options are for use by subclasses only.

"""

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

the sub-class)."""

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.splitlist(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, str):

option = repr(option)

if not isinstance(value, str):

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 callable(v):

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

pass

# Subwidgets are child widgets created automatically by mega-widgets.

# In python, we have to create these subwidgets manually to mirror their

# existence in Tk/Tix.

class TixSubWidget(TixWidget):

"""Subwidget class.

This is used to mirror child widgets automatically created

by Tix/Tk as part of a mega-widget in Python (which is not informed

of this)"""

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

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

# Useful class to create a display style - later shared by many items.

# Contributed by Steffen Kremser

class DisplayStyle:

"""DisplayStyle - handle configuration options shared by

(multiple) Display Items"""

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

master = tkinter._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 self._getconfigure(

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

def __getitem__(self,key):

return self.tk.call(self.stylename, 'cget', '-%s'%key)

######################################################

### The Tix Widget classes - in alphabetical order ###

######################################################

class Balloon(TixWidget):

"""Balloon help widget.

Subwidget Class

--------- -----

label Label

message Message"""

# 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.

One balloon widget may be bound to several widgets at the same time"""

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

def unbind_widget(self, widget):

self.tk.call(self._w, 'unbind', widget._w)

class ButtonBox(TixWidget):

"""ButtonBox - A container for pushbuttons.

Subwidgets are the buttons added with the add method.

"""

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:

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

class ComboBox(TixWidget):

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

choice by either typing in the entry subwidget or selecting from the

listbox subwidget.

Subwidget Class

--------- -----

entry Entry

arrow Button

slistbox ScrolledListBox

tick Button

cross Button : present if created with the fancy option"""

# 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):

self.tk.call(self._w, 'pick', index)

class Control(TixWidget):

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

adjust the value by pressing the two arrow buttons or by entering

the value directly into the entry. The new value will be checked

against the user-defined upper and lower limits.

Subwidget Class

--------- -----

incr Button

decr Button

entry Entry

label Label"""

# 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):

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

class DirList(TixWidget):

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

directories and its sub-directories. The user can choose one of

the directories displayed in the list or change to another directory.

Subwidget Class

--------- -----

hlist HList

hsb Scrollbar

vsb Scrollbar"""

# 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):

self.tk.call(self._w, 'chdir', dir)

class DirTree(TixWidget):

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

Displays a tree view of a directory, its previous directories and its

sub-directories. The user can choose one of the directories displayed

in the list or change to another directory.

Subwidget Class

--------- -----

hlist HList

hsb Scrollbar

vsb Scrollbar"""

# 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):

self.tk.call(self._w, 'chdir', dir)

class DirSelectBox(TixWidget):

"""DirSelectBox - Motif style file select box.

It is generally used for

the user to choose a file. FileSelectBox stores the files mostly

recently selected into a ComboBox widget so that they can be quickly

selected again.

Subwidget Class

--------- -----

selection ComboBox

filter ComboBox

dirlist ScrolledListBox

filelist ScrolledListBox"""

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

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

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

self.subwidget_list['dircbx'] = _dummyFileComboBox(self, 'dircbx')

class ExFileSelectBox(TixWidget):

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

It provides a convenient method for the user to select files.

Subwidget Class

--------- -----

cancel Button

ok Button

hidden Checkbutton

types ComboBox

dir ComboBox

file ComboBox

dirlist ScrolledListBox

filelist ScrolledListBox"""

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):

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

# Should inherit from a Dialog class

class DirSelectDialog(TixWidget):

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

system in a dialog window. The user can use this dialog window to

navigate through the file system to select the desired directory.

Subwidgets Class

---------- -----

dirbox DirSelectDialog"""

# 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):

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

# Should inherit from a Dialog class

class ExFileSelectDialog(TixWidget):

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

It provides a convenient method for the user to select files.

Subwidgets Class

---------- -----

fsbox ExFileSelectBox"""

# 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):

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

class FileSelectBox(TixWidget):

"""ExFileSelectBox - Motif style file select box.

It is generally used for

the user to choose a file. FileSelectBox stores the files mostly

recently selected into a ComboBox widget so that they can be quickly

selected again.

Subwidget Class

--------- -----

selection ComboBox

filter ComboBox

dirlist ScrolledListBox

filelist ScrolledListBox"""

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):

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

# Should inherit from a Dialog class

class FileSelectDialog(TixWidget):

"""FileSelectDialog - Motif style file select dialog.

Subwidgets Class

---------- -----

btns StdButtonBox

fsbox FileSelectBox"""

# 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):

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

class FileEntry(TixWidget):

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

The user can type in the filename manually. Alternatively, the user can

press the button widget that sits next to the entry, which will bring

up a file selection dialog.

Subwidgets Class

---------- -----

button Button

entry Entry"""

# 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

pass

class HList(TixWidget, XView, YView):

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

that have a hierarchical structure, for example, file system directory

trees. The list entries are indented and connected by branch lines

according to their places in the hierarchy.

Subwidgets - None"""

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 self._getconfigure(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 self._getconfigure(

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_bbox(self, entry):

return self._getints(

self.tk.call(self._w, 'info', 'bbox', entry)) or None

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_dragsite(self):

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

def info_dropsite(self):

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

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):