1 # -*-mode: python; fill-column: 75; tab-width: 8; coding: iso-latin-1-unix -*-

     2 #

     3 # $Id: Tix.py 52785 2006-11-18 18:42:22Z martin.v.loewis $

     4 #

     5 # Tix.py -- Tix widget wrappers.

     6 #

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

     8 #

     9 #       - Sudhir Shenoy (sshenoy@gol.com), Dec. 1995.

    10 #         based on an idea of Jean-Marc Lugrin (lugrin@ms.com)

    11 #

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

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

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

    15 #

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

    17 # inheritance of base classes.

    18 #

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

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

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

    22 # or even       w.ok.invoke()

    23 # etc.

    24 #

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

    26 # appreciate the advantages.

    27 #

    28 

    29 from Tkinter import *

    30 from Tkinter import _flatten, _cnfmerge, _default_root

    31 

    32 # WARNING - TkVersion is a limited precision floating point number

    33 if TkVersion < 3.999:

    34     raise ImportError, "This version of Tix.py requires Tk 4.0 or higher"

    35 

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

    37 

    38 # Some more constants (for consistency with Tkinter)

    39 WINDOW = 'window'

    40 TEXT = 'text'

    41 STATUS = 'status'

    42 IMMEDIATE = 'immediate'

    43 IMAGE = 'image'

    44 IMAGETEXT = 'imagetext'

    45 BALLOON = 'balloon'

    46 AUTO = 'auto'

    47 ACROSSTOP = 'acrosstop'

    48 

    49 # Some constants used by Tkinter dooneevent()

    50 TCL_DONT_WAIT     = 1 << 1

    51 TCL_WINDOW_EVENTS = 1 << 2

    52 TCL_FILE_EVENTS   = 1 << 3

    53 TCL_TIMER_EVENTS  = 1 << 4

    54 TCL_IDLE_EVENTS   = 1 << 5

    55 TCL_ALL_EVENTS    = 0

    56 

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

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

    59 #          liable to break.

    60 import Tkinter, os

    61 

    62 # Could probably add this to Tkinter.Misc

    63 class tixCommand:

    64     """The tix commands provide access to miscellaneous  elements

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

    66     Most of the information manipulated by these  commands pertains

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

    68     display, rather than to a particular window.

    69 

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

    71     that supports the self.tk.call method.

    72     """

    73 

    74     def tix_addbitmapdir(self, directory):

    75         """Tix maintains a list of directories under which

    76         the  tix_getimage  and tix_getbitmap commands will

    77         search for image files. The standard bitmap  directory

    78         is $TIX_LIBRARY/bitmaps. The addbitmapdir command

    79         adds directory into this list. By  using  this

    80         command, the  image  files  of an applications can

    81         also be located using the tix_getimage or tix_getbitmap

    82         command.

    83         """

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

    85 

    86     def tix_cget(self, option):

    87         """Returns  the  current  value  of the configuration

    88         option given by option. Option may be  any  of  the

    89         options described in the CONFIGURATION OPTIONS section.

    90         """

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

    92 

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

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

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

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

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

    98         will be identical to the corresponding sublist of the value

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

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

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

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

   103         """

   104         # Copied from Tkinter.py

   105         if kw:

   106             cnf = _cnfmerge((cnf, kw))

   107         elif cnf:

   108             cnf = _cnfmerge(cnf)

   109         if cnf is None:

   110             cnf = {}

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

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

   113             return cnf

   114         if isinstance(cnf, StringType):

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

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

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

   118 

   119     def tix_filedialog(self, dlgclass=None):

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

   121         different calls from this application.  This command will create a

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

   123         dialog will be returned by all subsequent calls to tix_filedialog.

   124         An optional dlgclass parameter can be passed to specified what type

   125         of file selection dialog widget is desired. Possible options are

   126         tix FileSelectDialog or tixExFileSelectDialog.

   127         """

   128         if dlgclass is not None:

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

   130         else:

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

   132 

   133     def tix_getbitmap(self, name):

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

   135         bitmap directories (see the tix_addbitmapdir command above).  By

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

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

   138         complete pathname of the bitmap file, prefixed with the character

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

   140         option of the TK and Tix widgets.

   141         """

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

   143 

   144     def tix_getimage(self, name):

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

   146         in one of the bitmap directories (see the addbitmapdir command

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

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

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

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

   151         tix_ getimage, you can advoid hard coding the pathnames of the

   152         image files in your application. When successful, this command

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

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

   155         """

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

   157 

   158     def tix_option_get(self, name):

   159         """Gets  the options  manitained  by  the  Tix

   160         scheme mechanism. Available options include:

   161 

   162             active_bg       active_fg      bg

   163             bold_font       dark1_bg       dark1_fg

   164             dark2_bg        dark2_fg       disabled_fg

   165             fg              fixed_font     font

   166             inactive_bg     inactive_fg    input1_bg

   167             input2_bg       italic_font    light1_bg

   168             light1_fg       light2_bg      light2_fg

   169             menu_font       output1_bg     output2_bg

   170             select_bg       select_fg      selector

   171             """

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

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

   174 

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

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

   177         newScheme and newFontSet, respectively.  This affects only those

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

   179         resetoptions command before the creation of any widgets in a Tix

   180         application.

   181 

   182         The optional parameter newScmPrio can be given to reset the

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

   184 

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

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

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

   188         tix_resetoptions command must be used.

   189         """

   190         if newScmPrio is not None:

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

   192         else:

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

   194 

   195 class Tk(Tkinter.Tk, tixCommand):

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

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

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

   199         Tkinter.Tk.__init__(self, screenName, baseName, className)

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

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

   202         if tixlib is not None:

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

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

   205         # Load Tix - this should work dynamically or statically

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

   207         #               'load {} Tix'

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

   209         #               'load libtix8.1.8.3.so Tix'

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

   211 

   212     def destroy(self):

   213         # For safety, remove an delete_window binding before destroy

   214         self.protocol("WM_DELETE_WINDOW", "")

   215         Tkinter.Tk.destroy(self)

   216 

   217 # The Tix 'tixForm' geometry manager

   218 class Form:

   219     """The Tix Form geometry manager

   220 

   221     Widgets can be arranged by specifying attachments to other widgets.

   222     See Tix documentation for complete details"""

   223 

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

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

   226 

   227     form = config

   228 

   229     def __setitem__(self, key, value):

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

   231 

   232     def check(self):

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

   234 

   235     def forget(self):

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

   237 

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

   239         if (not xsize) and (not ysize):

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

   241             y = self.tk.splitlist(x)

   242             z = ()

   243             for x in y:

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

   245             return z

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

   247 

   248     def info(self, option=None):

   249         if not option:

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

   251         if option[0] != '-':

   252             option = '-' + option

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

   254 

   255     def slaves(self):

   256         return map(self._nametowidget,

   257                    self.tk.splitlist(

   258                        self.tk.call(

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

   260 

   261 

   262 

   263 Tkinter.Widget.__bases__ = Tkinter.Widget.__bases__ + (Form,)

   264 

   265 class TixWidget(Tkinter.Widget):

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

   267 

   268     Widget initialization is extended in two ways:

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

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

   271        given as a 'config' command later.

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

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

   274        to create these widgets is therefore bypassed in TixWidget.__init__

   275 

   276     Both options are for use by subclasses only.

   277     """

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

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

   280         # Merge keywords and dictionary arguments

   281         if kw:

   282             cnf = _cnfmerge((cnf, kw))

   283         else:

   284             cnf = _cnfmerge(cnf)

   285 

   286         # Move static options into extra. static_options must be

   287         # a list of keywords (or None).

   288         extra=()

   289 

   290         # 'options' is always a static option

   291         if static_options:

   292             static_options.append('options')

   293         else:

   294             static_options = ['options']

   295 

   296         for k,v in cnf.items()[:]:

   297             if k in static_options:

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

   299                 del cnf[k]

   300 

   301         self.widgetName = widgetName

   302         Widget._setup(self, master, cnf)

   303 

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

   305         # corresponding Tk widget has already been created by Tix

   306         if widgetName:

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

   308 

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

   310         if cnf:

   311             Widget.config(self, cnf)

   312 

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

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

   315         # same as the pathname component

   316         self.subwidget_list = {}

   317 

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

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

   320     # when w is a StdButtonBox.

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

   322     # Button class if you go through the proper constructors

   323     def __getattr__(self, name):

   324         if self.subwidget_list.has_key(name):

   325             return self.subwidget_list[name]

   326         raise AttributeError, name

   327 

   328     def set_silent(self, value):

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

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

   331 

   332     def subwidget(self, name):

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

   334         the sub-class)."""

   335         n = self._subwidget_name(name)

   336         if not n:

   337             raise TclError, "Subwidget " + name + " not child of " + self._name

   338         # Remove header of name and leading dot

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

   340         return self._nametowidget(n)

   341 

   342     def subwidgets_all(self):

   343         """Return all subwidgets."""

   344         names = self._subwidget_names()

   345         if not names:

   346             return []

   347         retlist = []

   348         for name in names:

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

   350             try:

   351                 retlist.append(self._nametowidget(name))

   352             except:

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

   354                 pass

   355         return retlist

   356 

   357     def _subwidget_name(self,name):

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

   359         try:

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

   361         except TclError:

   362             return None

   363 

   364     def _subwidget_names(self):

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

   366         try:

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

   368             return self.tk.split(x)

   369         except TclError:

   370             return None

   371 

   372     def config_all(self, option, value):

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

   374         if option == '':

   375             return

   376         elif not isinstance(option, StringType):

   377             option = repr(option)

   378         if not isinstance(value, StringType):

   379             value = repr(value)

   380         names = self._subwidget_names()

   381         for name in names:

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

   383     # These are missing from Tkinter

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

   385         if not master:

   386             master = Tkinter._default_root

   387             if not master:

   388                 raise RuntimeError, 'Too early to create image'

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

   390         elif kw: cnf = kw

   391         options = ()

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

   393             if callable(v):

   394                 v = self._register(v)

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

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

   397     def image_delete(self, imgname):

   398         try:

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

   400         except TclError:

   401             # May happen if the root was destroyed

   402             pass

   403 

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

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

   406 # existence in Tk/Tix.

   407 class TixSubWidget(TixWidget):

   408     """Subwidget class.

   409 

   410     This is used to mirror child widgets automatically created

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

   412     of this)"""

   413 

   414     def __init__(self, master, name,

   415                destroy_physically=1, check_intermediate=1):

   416         if check_intermediate:

   417             path = master._subwidget_name(name)

   418             try:

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

   420                 plist = path.split('.')

   421             except:

   422                 plist = []

   423 

   424         if not check_intermediate:

   425             # immediate descendant

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

   427         else:

   428             # Ensure that the intermediate widgets exist

   429             parent = master

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

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

   432                 try:

   433                     w = master._nametowidget(n)

   434                     parent = w

   435                 except KeyError:

   436                     # Create the intermediate widget

   437                     parent = TixSubWidget(parent, plist[i],

   438                                           destroy_physically=0,

   439                                           check_intermediate=0)

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

   441             if plist:

   442                 name = plist[-1]

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

   444         self.destroy_physically = destroy_physically

   445 

   446     def destroy(self):

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

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

   449         # also destroys the parent NoteBook thus leading to an exception

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

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

   452         if self.master.children.has_key(self._name):

   453             del self.master.children[self._name]

   454         if self.master.subwidget_list.has_key(self._name):

   455             del self.master.subwidget_list[self._name]

   456         if self.destroy_physically:

   457             # This is bypassed only for a few widgets

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

   459 

   460 

   461 # Useful func. to split Tcl lists and return as a dict. From Tkinter.py

   462 def _lst2dict(lst):

   463     dict = {}

   464     for x in lst:

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

   466     return dict

   467 

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

   469 # Contributed by Steffen Kremser

   470 class DisplayStyle:

   471     """DisplayStyle - handle configuration options shared by

   472     (multiple) Display Items"""

   473 

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

   475         master = _default_root              # global from Tkinter

   476         if not master and cnf.has_key('refwindow'): master=cnf['refwindow']

   477         elif not master and kw.has_key('refwindow'):  master= kw['refwindow']

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

   479         self.tk = master.tk

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

   481                             *self._options(cnf,kw) )

   482 

   483     def __str__(self):

   484         return self.stylename

   485 

   486     def _options(self, cnf, kw):

   487         if kw and cnf:

   488             cnf = _cnfmerge((cnf, kw))

   489         elif kw:

   490             cnf = kw

   491         opts = ()

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

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

   494         return opts

   495 

   496     def delete(self):

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

   498 

   499     def __setitem__(self,key,value):

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

   501 

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

   503         return _lst2dict(

   504             self.tk.split(

   505             self.tk.call(

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

   507 

   508     def __getitem__(self,key):

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

   510 

   511 

   512 ######################################################

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

   514 ######################################################

   515 

   516 class Balloon(TixWidget):

   517     """Balloon help widget.

   518 

   519     Subwidget       Class

   520     ---------       -----

   521     label           Label

   522     message         Message"""

   523 

   524     # FIXME: It should inherit -superclass tixShell

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

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

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

   528                   'cursor']

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

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

   531                                                    destroy_physically=0)

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

   533                                                      destroy_physically=0)

   534 

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

   536         """Bind balloon widget to another.

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

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

   539 

   540     def unbind_widget(self, widget):

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

   542 

   543 class ButtonBox(TixWidget):

   544     """ButtonBox - A container for pushbuttons.

   545     Subwidgets are the buttons added with the add method.

   546     """

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

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

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

   550 

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

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

   553 

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

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

   556         return btn

   557 

   558     def invoke(self, name):

   559         if self.subwidget_list.has_key(name):

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

   561 

   562 class ComboBox(TixWidget):

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

   564     choice by either typing in the entry subwdget or selecting from the

   565     listbox subwidget.

   566 

   567     Subwidget       Class

   568     ---------       -----

   569     entry       Entry

   570     arrow       Button

   571     slistbox    ScrolledListBox

   572     tick        Button

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

   574 

   575     # FIXME: It should inherit -superclass tixLabelWidget

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

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

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

   579                            cnf, kw)

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

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

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

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

   584                                                                 'slistbox')

   585         try:

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

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

   588         except TypeError:

   589             # unavailable when -fancy not specified

   590             pass

   591 

   592     # align

   593 

   594     def add_history(self, str):

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

   596 

   597     def append_history(self, str):

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

   599 

   600     def insert(self, index, str):

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

   602 

   603     def pick(self, index):

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

   605 

   606 class Control(TixWidget):

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

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

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

   610     against the user-defined upper and lower limits.

   611 

   612     Subwidget       Class

   613     ---------       -----

   614     incr       Button

   615     decr       Button

   616     entry       Entry

   617     label       Label"""

   618 

   619     # FIXME: It should inherit -superclass tixLabelWidget

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

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

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

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

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

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

   626 

   627     def decrement(self):

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

   629 

   630     def increment(self):

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

   632 

   633     def invoke(self):

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

   635 

   636     def update(self):

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

   638 

   639 class DirList(TixWidget):

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

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

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

   643 

   644     Subwidget       Class

   645     ---------       -----

   646     hlist       HList

   647     hsb              Scrollbar

   648     vsb              Scrollbar"""

   649 

   650     # FIXME: It should inherit -superclass tixScrolledHList

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

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

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

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

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

   656 

   657     def chdir(self, dir):

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

   659 

   660 class DirTree(TixWidget):

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

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

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

   664     in the list or change to another directory.

   665 

   666     Subwidget       Class

   667     ---------       -----

   668     hlist           HList

   669     hsb             Scrollbar

   670     vsb             Scrollbar"""

   671 

   672     # FIXME: It should inherit -superclass tixScrolledHList

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

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

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

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

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

   678 

   679     def chdir(self, dir):

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

   681 

   682 class DirSelectBox(TixWidget):

   683     """DirSelectBox - Motif style file select box.

   684     It is generally used for

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

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

   687     selected again.

   688 

   689     Subwidget       Class

   690     ---------       -----

   691     selection       ComboBox

   692     filter          ComboBox

   693     dirlist         ScrolledListBox

   694     filelist        ScrolledListBox"""

   695 

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

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

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

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

   700 

   701 class ExFileSelectBox(TixWidget):

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

   703     It provides an convenient method for the user to select files.

   704 

   705     Subwidget       Class

   706     ---------       -----

   707     cancel       Button

   708     ok              Button

   709     hidden       Checkbutton

   710     types       ComboBox

   711     dir              ComboBox

   712     file       ComboBox

   713     dirlist       ScrolledListBox

   714     filelist       ScrolledListBox"""

   715 

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

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

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

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

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

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

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

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

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

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

   726 

   727     def filter(self):

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

   729 

   730     def invoke(self):

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

   732 

   733 

   734 # Should inherit from a Dialog class

   735 class DirSelectDialog(TixWidget):

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

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

   738     navigate through the file system to select the desired directory.

   739 

   740     Subwidgets       Class

   741     ----------       -----

   742     dirbox       DirSelectDialog"""

   743 

   744     # FIXME: It should inherit -superclass tixDialogShell

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

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

   747                            ['options'], cnf, kw)

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

   749         # cancel and ok buttons are missing

   750 

   751     def popup(self):

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

   753 

   754     def popdown(self):

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

   756 

   757 

   758 # Should inherit from a Dialog class

   759 class ExFileSelectDialog(TixWidget):

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

   761     It provides an convenient method for the user to select files.

   762 

   763     Subwidgets       Class

   764     ----------       -----

   765     fsbox       ExFileSelectBox"""

   766 

   767     # FIXME: It should inherit -superclass tixDialogShell

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

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

   770                            ['options'], cnf, kw)

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

   772 

   773     def popup(self):

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

   775 

   776     def popdown(self):

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

   778 

   779 class FileSelectBox(TixWidget):

   780     """ExFileSelectBox - Motif style file select box.

   781     It is generally used for

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

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

   784     selected again.

   785 

   786     Subwidget       Class

   787     ---------       -----

   788     selection       ComboBox

   789     filter          ComboBox

   790     dirlist         ScrolledListBox

   791     filelist        ScrolledListBox"""

   792 

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

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

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

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

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

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

   799 

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

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

   802 

   803     def invoke(self):

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

   805 

   806 # Should inherit from a Dialog class

   807 class FileSelectDialog(TixWidget):

   808     """FileSelectDialog - Motif style file select dialog.

   809 

   810     Subwidgets       Class

   811     ----------       -----

   812     btns       StdButtonBox

   813     fsbox       FileSelectBox"""

   814 

   815     # FIXME: It should inherit -superclass tixStdDialogShell

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

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

   818                            ['options'], cnf, kw)

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

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

   821 

   822     def popup(self):

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

   824 

   825     def popdown(self):

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

   827 

   828 class FileEntry(TixWidget):

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

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

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

   832     up a file selection dialog.

   833 

   834     Subwidgets       Class

   835     ----------       -----

   836     button       Button

   837     entry       Entry"""

   838 

   839     # FIXME: It should inherit -superclass tixLabelWidget

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

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

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

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

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

   845 

   846     def invoke(self):

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

   848 

   849     def file_dialog(self):

   850         # FIXME: return python object

   851         pass

   852 

   853 class HList(TixWidget):

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

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

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

   857     according to their places in the hierachy.

   858 

   859     Subwidgets - None"""

   860 

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

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

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

   864 

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

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

   867 

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

   869         if not parent:

   870             parent = ''

   871         return self.tk.call(

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

   873 

   874     def anchor_set(self, entry):

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

   876 

   877     def anchor_clear(self):

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

   879 

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

   881         if not chars:

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

   883         else:

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

   885                                 '-char', chars)

   886 

   887     def delete_all(self):

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

   889 

   890     def delete_entry(self, entry):

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

   892 

   893     def delete_offsprings(self, entry):

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

   895 

   896     def delete_siblings(self, entry):

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

   898 

   899     def dragsite_set(self, index):

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

   901 

   902     def dragsite_clear(self):

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

   904 

   905     def dropsite_set(self, index):

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

   907 

   908     def dropsite_clear(self):

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

   910 

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

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

   913 

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

   915         if cnf is None:

   916             return _lst2dict(

   917                 self.tk.split(

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

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

   920                      *self._options(cnf, kw))

   921 

   922     def header_cget(self,  col, opt):

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

   924 

   925     def header_exists(self,  col):

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

   927 

   928     def header_delete(self, col):

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

   930 

   931     def header_size(self, col):

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

   933 

   934     def hide_entry(self, entry):

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

   936 

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

   938         self.tk.call(

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

   940 

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

   942         if cnf is None:

   943             return _lst2dict(

   944                 self.tk.split(

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

   946         self.tk.call(

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

   948 

   949     def indicator_cget(self,  entry, opt):

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

   951 

   952     def indicator_exists(self,  entry):

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

   954 

   955     def indicator_delete(self, entry):

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

   957 

   958     def indicator_size(self, entry):

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

   960 

   961     def info_anchor(self):

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

   963 

   964     def info_children(self, entry=None):

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

   966         return self.tk.splitlist(c)

   967 

   968     def info_data(self, entry):

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

   970 

   971     def info_exists(self, entry):

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

   973 

   974     def info_hidden(self, entry):

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

   976 

   977     def info_next(self, entry):

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

   979 

   980     def info_parent(self, entry):

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

   982 

   983     def info_prev(self, entry):

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

   985 

   986     def info_selection(self):

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

   988         return self.tk.splitlist(c)

   989 

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

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

   992 

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

   994         if cnf is None:

   995             return _lst2dict(

   996                 self.tk.split(

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

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

   999               *self._options(cnf, kw))

  1000 

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

  1002         self.tk.call(

  1003               self._w, 'item', 'create', entry, col, *self._options(cnf, kw))

  1004 

  1005     def item_exists(self, entry, col):

  1006         return self.tk.call(self._w, 'item', 'exists', entry, col)

  1007 

  1008     def item_delete(self, entry, col):

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

  1010 

  1011     def entrycget(self, entry, opt):

  1012         return self.tk.call(self._w, 'entrycget', entry, opt)

  1013 

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

  1015         if cnf is None:

  1016             return _lst2dict(

  1017                 self.tk.split(

  1018                 self.tk.call(self._w, 'entryconfigure', entry)))

  1019         self.tk.call(self._w, 'entryconfigure', entry,

  1020               *self._options(cnf, kw))

  1021 

  1022     def nearest(self, y):

  1023         return self.tk.call(self._w, 'nearest', y)

  1024 

  1025     def see(self, entry):

  1026         self.tk.call(self._w, 'see', entry)

  1027 

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

  1029         self.tk.call(self._w, 'selection', 'clear', *self._options(cnf, kw))

  1030 

  1031     def selection_includes(self, entry):

  1032         return self.tk.call(self._w, 'selection', 'includes', entry)

  1033 

  1034     def selection_set(self, first, last=None):

  1035         self.tk.call(self._w, 'selection', 'set', first, last)

  1036 

  1037     def show_entry(self, entry):

  1038         return self.tk.call(self._w, 'show', 'entry', entry)

  1039 

  1040     def xview(self, *args):

  1041         self.tk.call(self._w, 'xview', *args)

  1042 

  1043     def yview(self, *args):

  1044         self.tk.call(self._w, 'yview', *args)

  1045 

  1046 class InputOnly(TixWidget):

  1047     """InputOnly - Invisible widget. Unix only.

  1048 

  1049     Subwidgets - None"""

  1050 

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

  1052         TixWidget.__init__(self, master, 'tixInputOnly', None, cnf, kw)

  1053 

  1054 class LabelEntry(TixWidget):

  1055     """LabelEntry - Entry field with label. Packages an entry widget

  1056     and a label into one mega widget. It can beused be used to simplify

  1057     the creation of ``entry-form'' type of interface.

  1058 

  1059     Subwidgets       Class

  1060     ----------       -----

  1061     label       Label

  1062     entry       Entry"""

  1063 

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

  1065         TixWidget.__init__(self, master, 'tixLabelEntry',

  1066                            ['labelside','options'], cnf, kw)

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

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

  1069 

  1070 class LabelFrame(TixWidget):

  1071     """LabelFrame - Labelled Frame container. Packages a frame widget

  1072     and a label into one mega widget. To create widgets inside a

  1073     LabelFrame widget, one creates the new widgets relative to the

  1074     frame subwidget and manage them inside the frame subwidget.

  1075 

  1076     Subwidgets       Class

  1077     ----------       -----

  1078     label       Label

  1079     frame       Frame"""

  1080 

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

  1082         TixWidget.__init__(self, master, 'tixLabelFrame',

  1083                            ['labelside','options'], cnf, kw)

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

  1085         self.subwidget_list['frame'] = _dummyFrame(self, 'frame')

  1086 

  1087 

  1088 class ListNoteBook(TixWidget):

  1089     """A ListNoteBook widget is very similar to the TixNoteBook widget:

  1090     it can be used to display many windows in a limited space using a

  1091     notebook metaphor. The notebook is divided into a stack of pages

  1092     (windows). At one time only one of these pages can be shown.

  1093     The user can navigate through these pages by

  1094     choosing the name of the desired page in the hlist subwidget."""

  1095 

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

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

  1098         # Is this necessary? It's not an exposed subwidget in Tix.

  1099         self.subwidget_list['pane'] = _dummyPanedWindow(self, 'pane',

  1100                                                         destroy_physically=0)

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

  1102         self.subwidget_list['shlist'] = _dummyScrolledHList(self, 'shlist')

  1103 

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

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

  1106         self.subwidget_list[name] = TixSubWidget(self, name)

  1107         return self.subwidget_list[name]

  1108 

  1109     def page(self, name):

  1110         return self.subwidget(name)

  1111 

  1112     def pages(self):

  1113         # Can't call subwidgets_all directly because we don't want .nbframe

  1114         names = self.tk.split(self.tk.call(self._w, 'pages'))

  1115         ret = []

  1116         for x in names:

  1117             ret.append(self.subwidget(x))

  1118         return ret

  1119 

  1120     def raise_page(self, name):              # raise is a python keyword

  1121         self.tk.call(self._w, 'raise', name)

  1122 

  1123 class Meter(TixWidget):

  1124     """The Meter widget can be used to show the progress of a background

  1125     job which may take a long time to execute.

  1126     """

  1127 

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

  1129         TixWidget.__init__(self, master, 'tixMeter',

  1130                            ['options'], cnf, kw)

  1131 

  1132 class NoteBook(TixWidget):

  1133     """NoteBook - Multi-page container widget (tabbed notebook metaphor).

  1134 

  1135     Subwidgets       Class