Lib/lib-tk/Tix.py

   1 # -*-mode: python; fill-column: 75; tab-width: 8; coding: iso-latin-1-unix -*-
   2 #
   3 # $Id: Tix.py 81008 2010-05-08 20:59:42Z benjamin.peterson $
   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 # A few useful constants for the Grid widget
  50 ASCII = 'ascii'
  51 CELL = 'cell'
  52 COLUMN = 'column'
  53 DECREASING = 'decreasing'
  54 INCREASING = 'increasing'
  55 INTEGER = 'integer'
  56 MAIN = 'main'
  57 MAX = 'max'
  58 REAL = 'real'
  59 ROW = 'row'
  60 S_REGION = 's-region'
  61 X_REGION = 'x-region'
  62 Y_REGION = 'y-region'
  63
  64 # Some constants used by Tkinter dooneevent()
  65 TCL_DONT_WAIT     = 1 << 1
  66 TCL_WINDOW_EVENTS = 1 << 2
  67 TCL_FILE_EVENTS   = 1 << 3
  68 TCL_TIMER_EVENTS  = 1 << 4
  69 TCL_IDLE_EVENTS   = 1 << 5
  70 TCL_ALL_EVENTS    = 0
  71
  72 # BEWARE - this is implemented by copying some code from the Widget class
  73 #          in Tkinter (to override Widget initialization) and is therefore
  74 #          liable to break.
  75 import Tkinter, os
  76
  77 # Could probably add this to Tkinter.Misc
  78 class tixCommand:
  79     """The tix commands provide access to miscellaneous  elements
  80     of  Tix's  internal state and the Tix application context.
  81     Most of the information manipulated by these  commands pertains
  82     to  the  application  as a whole, or to a screen or
  83     display, rather than to a particular window.
  84
  85     This is a mixin class, assumed to be mixed to Tkinter.Tk
  86     that supports the self.tk.call method.
  87     """
  88
  89     def tix_addbitmapdir(self, directory):
  90         """Tix maintains a list of directories under which
  91         the  tix_getimage  and tix_getbitmap commands will
  92         search for image files. The standard bitmap  directory
  93         is $TIX_LIBRARY/bitmaps. The addbitmapdir command
  94         adds directory into this list. By  using  this
  95         command, the  image  files  of an applications can
  96         also be located using the tix_getimage or tix_getbitmap
  97         command.
  98         """
  99         return self.tk.call('tix', 'addbitmapdir', directory)
 100
 101     def tix_cget(self, option):
 102         """Returns  the  current  value  of the configuration
 103         option given by option. Option may be  any  of  the
 104         options described in the CONFIGURATION OPTIONS section.
 105         """
 106         return self.tk.call('tix', 'cget', option)
 107
 108     def tix_configure(self, cnf=None, **kw):
 109         """Query or modify the configuration options of the Tix application
 110         context. If no option is specified, returns a dictionary all of the
 111         available options.  If option is specified with no value, then the
 112         command returns a list describing the one named option (this list
 113         will be identical to the corresponding sublist of the value
 114         returned if no option is specified).  If one or more option-value
 115         pairs are specified, then the command modifies the given option(s)
 116         to have the given value(s); in this case the command returns an
 117         empty string. Option may be any of the configuration options.
 118         """
 119         # Copied from Tkinter.py
 120         if kw:
 121             cnf = _cnfmerge((cnf, kw))
 122         elif cnf:
 123             cnf = _cnfmerge(cnf)
 124         if cnf is None:
 125             cnf = {}
 126             for x in self.tk.split(self.tk.call('tix', 'configure')):
 127                 cnf[x[0][1:]] = (x[0][1:],) + x[1:]
 128             return cnf
 129         if isinstance(cnf, StringType):
 130             x = self.tk.split(self.tk.call('tix', 'configure', '-'+cnf))
 131             return (x[0][1:],) + x[1:]
 132         return self.tk.call(('tix', 'configure') + self._options(cnf))
 133
 134     def tix_filedialog(self, dlgclass=None):
 135         """Returns the file selection dialog that may be shared among
 136         different calls from this application.  This command will create a
 137         file selection dialog widget when it is called the first time. This
 138         dialog will be returned by all subsequent calls to tix_filedialog.
 139         An optional dlgclass parameter can be passed to specified what type
 140         of file selection dialog widget is desired. Possible options are
 141         tix FileSelectDialog or tixExFileSelectDialog.
 142         """
 143         if dlgclass is not None:
 144             return self.tk.call('tix', 'filedialog', dlgclass)
 145         else:
 146             return self.tk.call('tix', 'filedialog')
 147
 148     def tix_getbitmap(self, name):
 149         """Locates a bitmap file of the name name.xpm or name in one of the
 150         bitmap directories (see the tix_addbitmapdir command above).  By
 151         using tix_getbitmap, you can avoid hard coding the pathnames of the
 152         bitmap files in your application. When successful, it returns the
 153         complete pathname of the bitmap file, prefixed with the character
 154         '@'.  The returned value can be used to configure the -bitmap
 155         option of the TK and Tix widgets.
 156         """
 157         return self.tk.call('tix', 'getbitmap', name)
 158
 159     def tix_getimage(self, name):
 160         """Locates an image file of the name name.xpm, name.xbm or name.ppm
 161         in one of the bitmap directories (see the addbitmapdir command
 162         above). If more than one file with the same name (but different
 163         extensions) exist, then the image type is chosen according to the
 164         depth of the X display: xbm images are chosen on monochrome
 165         displays and color images are chosen on color displays. By using
 166         tix_ getimage, you can advoid hard coding the pathnames of the
 167         image files in your application. When successful, this command
 168         returns the name of the newly created image, which can be used to
 169         configure the -image option of the Tk and Tix widgets.
 170         """
 171         return self.tk.call('tix', 'getimage', name)
 172
 173     def tix_option_get(self, name):
 174         """Gets  the options  manitained  by  the  Tix
 175         scheme mechanism. Available options include:
 176
 177             active_bg       active_fg      bg
 178             bold_font       dark1_bg       dark1_fg
 179             dark2_bg        dark2_fg       disabled_fg
 180             fg              fixed_font     font
 181             inactive_bg     inactive_fg    input1_bg
 182             input2_bg       italic_font    light1_bg
 183             light1_fg       light2_bg      light2_fg
 184             menu_font       output1_bg     output2_bg
 185             select_bg       select_fg      selector
 186             """
 187         # could use self.tk.globalgetvar('tixOption', name)
 188         return self.tk.call('tix', 'option', 'get', name)
 189
 190     def tix_resetoptions(self, newScheme, newFontSet, newScmPrio=None):
 191         """Resets the scheme and fontset of the Tix application to
 192         newScheme and newFontSet, respectively.  This affects only those
 193         widgets created after this call. Therefore, it is best to call the
 194         resetoptions command before the creation of any widgets in a Tix
 195         application.
 196
 197         The optional parameter newScmPrio can be given to reset the
 198         priority level of the Tk options set by the Tix schemes.
 199
 200         Because of the way Tk handles the X option database, after Tix has
 201         been has imported and inited, it is not possible to reset the color
 202         schemes and font sets using the tix config command.  Instead, the
 203         tix_resetoptions command must be used.
 204         """
 205         if newScmPrio is not None:
 206             return self.tk.call('tix', 'resetoptions', newScheme, newFontSet, newScmPrio)
 207         else:
 208             return self.tk.call('tix', 'resetoptions', newScheme, newFontSet)
 209
 210 class Tk(Tkinter.Tk, tixCommand):
 211     """Toplevel widget of Tix which represents mostly the main window
 212     of an application. It has an associated Tcl interpreter."""
 213     def __init__(self, screenName=None, baseName=None, className='Tix'):
 214         Tkinter.Tk.__init__(self, screenName, baseName, className)
 215         tixlib = os.environ.get('TIX_LIBRARY')
 216         self.tk.eval('global auto_path; lappend auto_path [file dir [info nameof]]')
 217         if tixlib is not None:
 218             self.tk.eval('global auto_path; lappend auto_path {%s}' % tixlib)
 219             self.tk.eval('global tcl_pkgPath; lappend tcl_pkgPath {%s}' % tixlib)
 220         # Load Tix - this should work dynamically or statically
 221         # If it's static, tcl/tix8.1/pkgIndex.tcl should have
 222         #               'load {} Tix'
 223         # If it's dynamic under Unix, tcl/tix8.1/pkgIndex.tcl should have
 224         #               'load libtix8.1.8.3.so Tix'
 225         self.tk.eval('package require Tix')
 226
 227     def destroy(self):
 228         # For safety, remove an delete_window binding before destroy
 229         self.protocol("WM_DELETE_WINDOW", "")
 230         Tkinter.Tk.destroy(self)
 231
 232 # The Tix 'tixForm' geometry manager
 233 class Form:
 234     """The Tix Form geometry manager
 235
 236     Widgets can be arranged by specifying attachments to other widgets.
 237     See Tix documentation for complete details"""
 238
 239     def config(self, cnf={}, **kw):
 240         self.tk.call('tixForm', self._w, *self._options(cnf, kw))
 241
 242     form = config
 243
 244     def __setitem__(self, key, value):
 245         Form.form(self, {key: value})
 246
 247     def check(self):
 248         return self.tk.call('tixForm', 'check', self._w)
 249
 250     def forget(self):
 251         self.tk.call('tixForm', 'forget', self._w)
 252
 253     def grid(self, xsize=0, ysize=0):
 254         if (not xsize) and (not ysize):
 255             x = self.tk.call('tixForm', 'grid', self._w)
 256             y = self.tk.splitlist(x)
 257             z = ()
 258             for x in y:
 259                 z = z + (self.tk.getint(x),)
 260             return z
 261         return self.tk.call('tixForm', 'grid', self._w, xsize, ysize)
 262
 263     def info(self, option=None):
 264         if not option:
 265             return self.tk.call('tixForm', 'info', self._w)
 266         if option[0] != '-':
 267             option = '-' + option
 268         return self.tk.call('tixForm', 'info', self._w, option)
 269
 270     def slaves(self):
 271         return map(self._nametowidget,
 272                    self.tk.splitlist(
 273                        self.tk.call(
 274                        'tixForm', 'slaves', self._w)))
 275
 276
 277
 278 Tkinter.Widget.__bases__ = Tkinter.Widget.__bases__ + (Form,)
 279
 280 class TixWidget(Tkinter.Widget):
 281     """A TixWidget class is used to package all (or most) Tix widgets.
 282
 283     Widget initialization is extended in two ways:
 284        1) It is possible to give a list of options which must be part of
 285        the creation command (so called Tix 'static' options). These cannot be
 286        given as a 'config' command later.
 287        2) It is possible to give the name of an existing TK widget. These are
 288        child widgets created automatically by a Tix mega-widget. The Tk call
 289        to create these widgets is therefore bypassed in TixWidget.__init__
 290
 291     Both options are for use by subclasses only.
 292     """
 293     def __init__ (self, master=None, widgetName=None,
 294                 static_options=None, cnf={}, kw={}):
 295         # Merge keywords and dictionary arguments
 296         if kw:
 297             cnf = _cnfmerge((cnf, kw))
 298         else:
 299             cnf = _cnfmerge(cnf)
 300
 301         # Move static options into extra. static_options must be
 302         # a list of keywords (or None).
 303         extra=()
 304
 305         # 'options' is always a static option
 306         if static_options:
 307             static_options.append('options')
 308         else:
 309             static_options = ['options']
 310
 311         for k,v in cnf.items()[:]:
 312             if k in static_options:
 313                 extra = extra + ('-' + k, v)
 314                 del cnf[k]
 315
 316         self.widgetName = widgetName
 317         Widget._setup(self, master, cnf)
 318
 319         # If widgetName is None, this is a dummy creation call where the
 320         # corresponding Tk widget has already been created by Tix
 321         if widgetName:
 322             self.tk.call(widgetName, self._w, *extra)
 323
 324         # Non-static options - to be done via a 'config' command
 325         if cnf:
 326             Widget.config(self, cnf)
 327
 328         # Dictionary to hold subwidget names for easier access. We can't
 329         # use the children list because the public Tix names may not be the
 330         # same as the pathname component
 331         self.subwidget_list = {}
 332
 333     # We set up an attribute access function so that it is possible to
 334     # do w.ok['text'] = 'Hello' rather than w.subwidget('ok')['text'] = 'Hello'
 335     # when w is a StdButtonBox.
 336     # We can even do w.ok.invoke() because w.ok is subclassed from the
 337     # Button class if you go through the proper constructors
 338     def __getattr__(self, name):
 339         if name in self.subwidget_list:
 340             return self.subwidget_list[name]
 341         raise AttributeError, name
 342
 343     def set_silent(self, value):
 344         """Set a variable without calling its action routine"""
 345         self.tk.call('tixSetSilent', self._w, value)
 346
 347     def subwidget(self, name):
 348         """Return the named subwidget (which must have been created by
 349         the sub-class)."""
 350         n = self._subwidget_name(name)
 351         if not n:
 352             raise TclError, "Subwidget " + name + " not child of " + self._name
 353         # Remove header of name and leading dot
 354         n = n[len(self._w)+1:]
 355         return self._nametowidget(n)
 356
 357     def subwidgets_all(self):
 358         """Return all subwidgets."""
 359         names = self._subwidget_names()
 360         if not names:
 361             return []
 362         retlist = []
 363         for name in names:
 364             name = name[len(self._w)+1:]
 365             try:
 366                 retlist.append(self._nametowidget(name))
 367             except:
 368                 # some of the widgets are unknown e.g. border in LabelFrame
 369                 pass
 370         return retlist
 371
 372     def _subwidget_name(self,name):
 373         """Get a subwidget name (returns a String, not a Widget !)"""
 374         try:
 375             return self.tk.call(self._w, 'subwidget', name)
 376         except TclError:
 377             return None
 378
 379     def _subwidget_names(self):
 380         """Return the name of all subwidgets."""
 381         try:
 382             x = self.tk.call(self._w, 'subwidgets', '-all')
 383             return self.tk.split(x)
 384         except TclError:
 385             return None
 386
 387     def config_all(self, option, value):
 388         """Set configuration options for all subwidgets (and self)."""
 389         if option == '':
 390             return
 391         elif not isinstance(option, StringType):
 392             option = repr(option)
 393         if not isinstance(value, StringType):
 394             value = repr(value)
 395         names = self._subwidget_names()
 396         for name in names:
 397             self.tk.call(name, 'configure', '-' + option, value)
 398     # These are missing from Tkinter
 399     def image_create(self, imgtype, cnf={}, master=None, **kw):
 400         if not master:
 401             master = Tkinter._default_root
 402             if not master:
 403                 raise RuntimeError, 'Too early to create image'
 404         if kw and cnf: cnf = _cnfmerge((cnf, kw))
 405         elif kw: cnf = kw
 406         options = ()
 407         for k, v in cnf.items():
 408             if hasattr(v, '__call__'):
 409                 v = self._register(v)
 410             options = options + ('-'+k, v)
 411         return master.tk.call(('image', 'create', imgtype,) + options)
 412     def image_delete(self, imgname):
 413         try:
 414             self.tk.call('image', 'delete', imgname)
 415         except TclError:
 416             # May happen if the root was destroyed
 417             pass
 418
 419 # Subwidgets are child widgets created automatically by mega-widgets.
 420 # In python, we have to create these subwidgets manually to mirror their
 421 # existence in Tk/Tix.
 422 class TixSubWidget(TixWidget):
 423     """Subwidget class.
 424
 425     This is used to mirror child widgets automatically created
 426     by Tix/Tk as part of a mega-widget in Python (which is not informed
 427     of this)"""
 428
 429     def __init__(self, master, name,
 430                destroy_physically=1, check_intermediate=1):
 431         if check_intermediate:
 432             path = master._subwidget_name(name)
 433             try:
 434                 path = path[len(master._w)+1:]
 435                 plist = path.split('.')
 436             except:
 437                 plist = []
 438
 439         if not check_intermediate:
 440             # immediate descendant
 441             TixWidget.__init__(self, master, None, None, {'name' : name})
 442         else:
 443             # Ensure that the intermediate widgets exist
 444             parent = master
 445             for i in range(len(plist) - 1):
 446                 n = '.'.join(plist[:i+1])
 447                 try:
 448                     w = master._nametowidget(n)
 449                     parent = w
 450                 except KeyError:
 451                     # Create the intermediate widget
 452                     parent = TixSubWidget(parent, plist[i],
 453                                           destroy_physically=0,
 454                                           check_intermediate=0)
 455             # The Tk widget name is in plist, not in name
 456             if plist:
 457                 name = plist[-1]
 458             TixWidget.__init__(self, parent, None, None, {'name' : name})
 459         self.destroy_physically = destroy_physically
 460
 461     def destroy(self):
 462         # For some widgets e.g., a NoteBook, when we call destructors,
 463         # we must be careful not to destroy the frame widget since this
 464         # also destroys the parent NoteBook thus leading to an exception
 465         # in Tkinter when it finally calls Tcl to destroy the NoteBook
 466         for c in self.children.values(): c.destroy()
 467         if self._name in self.master.children:
 468             del self.master.children[self._name]
 469         if self._name in self.master.subwidget_list:
 470             del self.master.subwidget_list[self._name]
 471         if self.destroy_physically:
 472             # This is bypassed only for a few widgets
 473             self.tk.call('destroy', self._w)
 474
 475
 476 # Useful func. to split Tcl lists and return as a dict. From Tkinter.py
 477 def _lst2dict(lst):
 478     dict = {}
 479     for x in lst:
 480         dict[x[0][1:]] = (x[0][1:],) + x[1:]
 481     return dict
 482
 483 # Useful class to create a display style - later shared by many items.
 484 # Contributed by Steffen Kremser
 485 class DisplayStyle:
 486     """DisplayStyle - handle configuration options shared by
 487     (multiple) Display Items"""
 488
 489     def __init__(self, itemtype, cnf={}, **kw):
 490         master = _default_root              # global from Tkinter
 491         if not master and 'refwindow' in cnf: master=cnf['refwindow']
 492         elif not master and 'refwindow' in kw:  master= kw['refwindow']
 493         elif not master: raise RuntimeError, "Too early to create display style: no root window"
 494         self.tk = master.tk
 495         self.stylename = self.tk.call('tixDisplayStyle', itemtype,
 496                             *self._options(cnf,kw) )
 497
 498     def __str__(self):
 499         return self.stylename
 500
 501     def _options(self, cnf, kw):
 502         if kw and cnf:
 503             cnf = _cnfmerge((cnf, kw))
 504         elif kw:
 505             cnf = kw
 506         opts = ()
 507         for k, v in cnf.items():
 508             opts = opts + ('-'+k, v)
 509         return opts
 510
 511     def delete(self):
 512         self.tk.call(self.stylename, 'delete')
 513
 514     def __setitem__(self,key,value):
 515         self.tk.call(self.stylename, 'configure', '-%s'%key, value)
 516
 517     def config(self, cnf={}, **kw):
 518         return _lst2dict(
 519             self.tk.split(
 520             self.tk.call(
 521                   self.stylename, 'configure', *self._options(cnf,kw))))
 522
 523     def __getitem__(self,key):
 524         return self.tk.call(self.stylename, 'cget', '-%s'%key)
 525
 526
 527 ######################################################
 528 ### The Tix Widget classes - in alphabetical order ###
 529 ######################################################
 530
 531 class Balloon(TixWidget):
 532     """Balloon help widget.
 533
 534     Subwidget       Class
 535     ---------       -----
 536     label           Label
 537     message         Message"""
 538
 539     # FIXME: It should inherit -superclass tixShell
 540     def __init__(self, master=None, cnf={}, **kw):
 541         # static seem to be -installcolormap -initwait -statusbar -cursor
 542         static = ['options', 'installcolormap', 'initwait', 'statusbar',
 543                   'cursor']
 544         TixWidget.__init__(self, master, 'tixBalloon', static, cnf, kw)
 545         self.subwidget_list['label'] = _dummyLabel(self, 'label',
 546                                                    destroy_physically=0)
 547         self.subwidget_list['message'] = _dummyLabel(self, 'message',
 548                                                      destroy_physically=0)
 549
 550     def bind_widget(self, widget, cnf={}, **kw):
 551         """Bind balloon widget to another.
 552         One balloon widget may be bound to several widgets at the same time"""
 553         self.tk.call(self._w, 'bind', widget._w, *self._options(cnf, kw))
 554
 555     def unbind_widget(self, widget):
 556         self.tk.call(self._w, 'unbind', widget._w)
 557
 558 class ButtonBox(TixWidget):
 559     """ButtonBox - A container for pushbuttons.
 560     Subwidgets are the buttons added with the add method.
 561     """
 562     def __init__(self, master=None, cnf={}, **kw):
 563         TixWidget.__init__(self, master, 'tixButtonBox',
 564                            ['orientation', 'options'], cnf, kw)
 565
 566     def add(self, name, cnf={}, **kw):
 567         """Add a button with given name to box."""
 568
 569         btn = self.tk.call(self._w, 'add', name, *self._options(cnf, kw))
 570         self.subwidget_list[name] = _dummyButton(self, name)
 571         return btn
 572
 573     def invoke(self, name):
 574         if name in self.subwidget_list:
 575             self.tk.call(self._w, 'invoke', name)
 576
 577 class ComboBox(TixWidget):
 578     """ComboBox - an Entry field with a dropdown menu. The user can select a
 579     choice by either typing in the entry subwdget or selecting from the
 580     listbox subwidget.
 581
 582     Subwidget       Class
 583     ---------       -----
 584     entry       Entry
 585     arrow       Button
 586     slistbox    ScrolledListBox
 587     tick        Button
 588     cross       Button : present if created with the fancy option"""
 589
 590     # FIXME: It should inherit -superclass tixLabelWidget
 591     def __init__ (self, master=None, cnf={}, **kw):
 592         TixWidget.__init__(self, master, 'tixComboBox',
 593                            ['editable', 'dropdown', 'fancy', 'options'],
 594                            cnf, kw)
 595         self.subwidget_list['label'] = _dummyLabel(self, 'label')
 596         self.subwidget_list['entry'] = _dummyEntry(self, 'entry')
 597         self.subwidget_list['arrow'] = _dummyButton(self, 'arrow')
 598         self.subwidget_list['slistbox'] = _dummyScrolledListBox(self,
 599                                                                 'slistbox')
 600         try:
 601             self.subwidget_list['tick'] = _dummyButton(self, 'tick')
 602             self.subwidget_list['cross'] = _dummyButton(self, 'cross')
 603         except TypeError:
 604             # unavailable when -fancy not specified
 605             pass
 606
 607     # align
 608
 609     def add_history(self, str):
 610         self.tk.call(self._w, 'addhistory', str)
 611
 612     def append_history(self, str):
 613         self.tk.call(self._w, 'appendhistory', str)
 614
 615     def insert(self, index, str):
 616         self.tk.call(self._w, 'insert', index, str)
 617
 618     def pick(self, index):
 619         self.tk.call(self._w, 'pick', index)
 620
 621 class Control(TixWidget):
 622     """Control - An entry field with value change arrows.  The user can
 623     adjust the value by pressing the two arrow buttons or by entering
 624     the value directly into the entry. The new value will be checked
 625     against the user-defined upper and lower limits.
 626
 627     Subwidget       Class
 628     ---------       -----
 629     incr       Button
 630     decr       Button
 631     entry       Entry
 632     label       Label"""
 633
 634     # FIXME: It should inherit -superclass tixLabelWidget
 635     def __init__ (self, master=None, cnf={}, **kw):
 636         TixWidget.__init__(self, master, 'tixControl', ['options'], cnf, kw)
 637         self.subwidget_list['incr'] = _dummyButton(self, 'incr')
 638         self.subwidget_list['decr'] = _dummyButton(self, 'decr')
 639         self.subwidget_list['label'] = _dummyLabel(self, 'label')
 640         self.subwidget_list['entry'] = _dummyEntry(self, 'entry')
 641
 642     def decrement(self):
 643         self.tk.call(self._w, 'decr')
 644
 645     def increment(self):
 646         self.tk.call(self._w, 'incr')
 647
 648     def invoke(self):
 649         self.tk.call(self._w, 'invoke')
 650
 651     def update(self):
 652         self.tk.call(self._w, 'update')
 653
 654 class DirList(TixWidget):
 655     """DirList - displays a list view of a directory, its previous
 656     directories and its sub-directories. The user can choose one of
 657     the directories displayed in the list or change to another directory.
 658
 659     Subwidget       Class
 660     ---------       -----
 661     hlist       HList
 662     hsb              Scrollbar
 663     vsb              Scrollbar"""
 664
 665     # FIXME: It should inherit -superclass tixScrolledHList
 666     def __init__(self, master, cnf={}, **kw):
 667         TixWidget.__init__(self, master, 'tixDirList', ['options'], cnf, kw)
 668         self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
 669         self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
 670         self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
 671
 672     def chdir(self, dir):
 673         self.tk.call(self._w, 'chdir', dir)
 674
 675 class DirTree(TixWidget):
 676     """DirTree - Directory Listing in a hierarchical view.
 677     Displays a tree view of a directory, its previous directories and its
 678     sub-directories. The user can choose one of the directories displayed
 679     in the list or change to another directory.
 680
 681     Subwidget       Class
 682     ---------       -----
 683     hlist           HList
 684     hsb             Scrollbar
 685     vsb             Scrollbar"""
 686
 687     # FIXME: It should inherit -superclass tixScrolledHList
 688     def __init__(self, master, cnf={}, **kw):
 689         TixWidget.__init__(self, master, 'tixDirTree', ['options'], cnf, kw)
 690         self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
 691         self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
 692         self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
 693
 694     def chdir(self, dir):
 695         self.tk.call(self._w, 'chdir', dir)
 696
 697 class DirSelectBox(TixWidget):
 698     """DirSelectBox - Motif style file select box.
 699     It is generally used for
 700     the user to choose a file. FileSelectBox stores the files mostly
 701     recently selected into a ComboBox widget so that they can be quickly
 702     selected again.
 703
 704     Subwidget       Class
 705     ---------       -----
 706     selection       ComboBox
 707     filter          ComboBox
 708     dirlist         ScrolledListBox
 709     filelist        ScrolledListBox"""
 710
 711     def __init__(self, master, cnf={}, **kw):
 712         TixWidget.__init__(self, master, 'tixDirSelectBox', ['options'], cnf, kw)
 713         self.subwidget_list['dirlist'] = _dummyDirList(self, 'dirlist')
 714         self.subwidget_list['dircbx'] = _dummyFileComboBox(self, 'dircbx')
 715
 716 class ExFileSelectBox(TixWidget):
 717     """ExFileSelectBox - MS Windows style file select box.
 718     It provides an convenient method for the user to select files.
 719
 720     Subwidget       Class
 721     ---------       -----
 722     cancel       Button
 723     ok              Button
 724     hidden       Checkbutton
 725     types       ComboBox
 726     dir              ComboBox
 727     file       ComboBox
 728     dirlist       ScrolledListBox
 729     filelist       ScrolledListBox"""
 730
 731     def __init__(self, master, cnf={}, **kw):
 732         TixWidget.__init__(self, master, 'tixExFileSelectBox', ['options'], cnf, kw)
 733         self.subwidget_list['cancel'] = _dummyButton(self, 'cancel')
 734         self.subwidget_list['ok'] = _dummyButton(self, 'ok')
 735         self.subwidget_list['hidden'] = _dummyCheckbutton(self, 'hidden')
 736         self.subwidget_list['types'] = _dummyComboBox(self, 'types')
 737         self.subwidget_list['dir'] = _dummyComboBox(self, 'dir')
 738         self.subwidget_list['dirlist'] = _dummyDirList(self, 'dirlist')
 739         self.subwidget_list['file'] = _dummyComboBox(self, 'file')
 740         self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist')
 741
 742     def filter(self):
 743         self.tk.call(self._w, 'filter')
 744
 745     def invoke(self):
 746         self.tk.call(self._w, 'invoke')
 747
 748
 749 # Should inherit from a Dialog class
 750 class DirSelectDialog(TixWidget):
 751     """The DirSelectDialog widget presents the directories in the file
 752     system in a dialog window. The user can use this dialog window to
 753     navigate through the file system to select the desired directory.
 754
 755     Subwidgets       Class
 756     ----------       -----
 757     dirbox       DirSelectDialog"""
 758
 759     # FIXME: It should inherit -superclass tixDialogShell
 760     def __init__(self, master, cnf={}, **kw):
 761         TixWidget.__init__(self, master, 'tixDirSelectDialog',
 762                            ['options'], cnf, kw)
 763         self.subwidget_list['dirbox'] = _dummyDirSelectBox(self, 'dirbox')
 764         # cancel and ok buttons are missing
 765
 766     def popup(self):
 767         self.tk.call(self._w, 'popup')
 768
 769     def popdown(self):
 770         self.tk.call(self._w, 'popdown')
 771
 772
 773 # Should inherit from a Dialog class
 774 class ExFileSelectDialog(TixWidget):
 775     """ExFileSelectDialog - MS Windows style file select dialog.
 776     It provides an convenient method for the user to select files.
 777
 778     Subwidgets       Class
 779     ----------       -----
 780     fsbox       ExFileSelectBox"""
 781
 782     # FIXME: It should inherit -superclass tixDialogShell
 783     def __init__(self, master, cnf={}, **kw):
 784         TixWidget.__init__(self, master, 'tixExFileSelectDialog',
 785                            ['options'], cnf, kw)
 786         self.subwidget_list['fsbox'] = _dummyExFileSelectBox(self, 'fsbox')
 787
 788     def popup(self):
 789         self.tk.call(self._w, 'popup')
 790
 791     def popdown(self):
 792         self.tk.call(self._w, 'popdown')
 793
 794 class FileSelectBox(TixWidget):
 795     """ExFileSelectBox - Motif style file select box.
 796     It is generally used for
 797     the user to choose a file. FileSelectBox stores the files mostly
 798     recently selected into a ComboBox widget so that they can be quickly
 799     selected again.
 800
 801     Subwidget       Class
 802     ---------       -----
 803     selection       ComboBox
 804     filter          ComboBox
 805     dirlist         ScrolledListBox
 806     filelist        ScrolledListBox"""
 807
 808     def __init__(self, master, cnf={}, **kw):
 809         TixWidget.__init__(self, master, 'tixFileSelectBox', ['options'], cnf, kw)
 810         self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist')
 811         self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist')
 812         self.subwidget_list['filter'] = _dummyComboBox(self, 'filter')
 813         self.subwidget_list['selection'] = _dummyComboBox(self, 'selection')
 814
 815     def apply_filter(self):              # name of subwidget is same as command
 816         self.tk.call(self._w, 'filter')
 817
 818     def invoke(self):
 819         self.tk.call(self._w, 'invoke')
 820
 821 # Should inherit from a Dialog class
 822 class FileSelectDialog(TixWidget):
 823     """FileSelectDialog - Motif style file select dialog.
 824
 825     Subwidgets       Class
 826     ----------       -----
 827     btns       StdButtonBox
 828     fsbox       FileSelectBox"""
 829
 830     # FIXME: It should inherit -superclass tixStdDialogShell
 831     def __init__(self, master, cnf={}, **kw):
 832         TixWidget.__init__(self, master, 'tixFileSelectDialog',
 833                            ['options'], cnf, kw)
 834         self.subwidget_list['btns'] = _dummyStdButtonBox(self, 'btns')
 835         self.subwidget_list['fsbox'] = _dummyFileSelectBox(self, 'fsbox')
 836
 837     def popup(self):
 838         self.tk.call(self._w, 'popup')
 839
 840     def popdown(self):
 841         self.tk.call(self._w, 'popdown')
 842
 843 class FileEntry(TixWidget):
 844     """FileEntry - Entry field with button that invokes a FileSelectDialog.
 845     The user can type in the filename manually. Alternatively, the user can
 846     press the button widget that sits next to the entry, which will bring
 847     up a file selection dialog.
 848
 849     Subwidgets       Class
 850     ----------       -----
 851     button       Button
 852     entry       Entry"""
 853
 854     # FIXME: It should inherit -superclass tixLabelWidget
 855     def __init__(self, master, cnf={}, **kw):
 856         TixWidget.__init__(self, master, 'tixFileEntry',
 857                            ['dialogtype', 'options'], cnf, kw)
 858         self.subwidget_list['button'] = _dummyButton(self, 'button')
 859         self.subwidget_list['entry'] = _dummyEntry(self, 'entry')
 860
 861     def invoke(self):
 862         self.tk.call(self._w, 'invoke')
 863
 864     def file_dialog(self):
 865         # FIXME: return python object
 866         pass
 867
 868 class HList(TixWidget, XView, YView):
 869     """HList - Hierarchy display  widget can be used to display any data
 870     that have a hierarchical structure, for example, file system directory
 871     trees. The list entries are indented and connected by branch lines
 872     according to their places in the hierachy.
 873
 874     Subwidgets - None"""
 875
 876     def __init__ (self,master=None,cnf={}, **kw):
 877         TixWidget.__init__(self, master, 'tixHList',
 878                            ['columns', 'options'], cnf, kw)
 879
 880     def add(self, entry, cnf={}, **kw):
 881         return self.tk.call(self._w, 'add', entry, *self._options(cnf, kw))
 882
 883     def add_child(self, parent=None, cnf={}, **kw):
 884         if not parent:
 885             parent = ''
 886         return self.tk.call(
 887                      self._w, 'addchild', parent, *self._options(cnf, kw))
 888
 889     def anchor_set(self, entry):
 890         self.tk.call(self._w, 'anchor', 'set', entry)
 891
 892     def anchor_clear(self):
 893         self.tk.call(self._w, 'anchor', 'clear')
 894
 895     def column_width(self, col=0, width=None, chars=None):
 896         if not chars:
 897             return self.tk.call(self._w, 'column', 'width', col, width)
 898         else:
 899             return self.tk.call(self._w, 'column', 'width', col,
 900                                 '-char', chars)
 901
 902     def delete_all(self):
 903         self.tk.call(self._w, 'delete', 'all')
 904
 905     def delete_entry(self, entry):
 906         self.tk.call(self._w, 'delete', 'entry', entry)
 907
 908     def delete_offsprings(self, entry):
 909         self.tk.call(self._w, 'delete', 'offsprings', entry)
 910
 911     def delete_siblings(self, entry):
 912         self.tk.call(self._w, 'delete', 'siblings', entry)
 913
 914     def dragsite_set(self, index):
 915         self.tk.call(self._w, 'dragsite', 'set', index)
 916
 917     def dragsite_clear(self):
 918         self.tk.call(self._w, 'dragsite', 'clear')
 919
 920     def dropsite_set(self, index):
 921         self.tk.call(self._w, 'dropsite', 'set', index)
 922
 923     def dropsite_clear(self):
 924         self.tk.call(self._w, 'dropsite', 'clear')
 925
 926     def header_create(self, col, cnf={}, **kw):
 927         self.tk.call(self._w, 'header', 'create', col, *self._options(cnf, kw))
 928
 929     def header_configure(self, col, cnf={}, **kw):
 930         if cnf is None:
 931             return _lst2dict(
 932                 self.tk.split(
 933                 self.tk.call(self._w, 'header', 'configure', col)))
 934         self.tk.call(self._w, 'header', 'configure', col,
 935                      *self._options(cnf, kw))
 936
 937     def header_cget(self,  col, opt):
 938         return self.tk.call(self._w, 'header', 'cget', col, opt)
 939
 940     def header_exists(self,  col):
 941         return self.tk.call(self._w, 'header', 'exists', col)
 942
 943     def header_delete(self, col):
 944         self.tk.call(self._w, 'header', 'delete', col)
 945
 946     def header_size(self, col):
 947         return self.tk.call(self._w, 'header', 'size', col)
 948
 949     def hide_entry(self, entry):
 950         self.tk.call(self._w, 'hide', 'entry', entry)
 951
 952     def indicator_create(self, entry, cnf={}, **kw):
 953         self.tk.call(
 954               self._w, 'indicator', 'create', entry, *self._options(cnf, kw))
 955
 956     def indicator_configure(self, entry, cnf={}, **kw):
 957         if cnf is None:
 958             return _lst2dict(
 959                 self.tk.split(
 960                 self.tk.call(self._w, 'indicator', 'configure', entry)))
 961         self.tk.call(
 962               self._w, 'indicator', 'configure', entry, *self._options(cnf, kw))
 963
 964     def indicator_cget(self,  entry, opt):
 965         return self.tk.call(self._w, 'indicator', 'cget', entry, opt)
 966
 967     def indicator_exists(self,  entry):
 968         return self.tk.call (self._w, 'indicator', 'exists', entry)
 969
 970     def indicator_delete(self, entry):
 971         self.tk.call(self._w, 'indicator', 'delete', entry)
 972
 973     def indicator_size(self, entry):
 974         return self.tk.call(self._w, 'indicator', 'size', entry)
 975
 976     def info_anchor(self):
 977         return self.tk.call(self._w, 'info', 'anchor')
 978
 979     def info_bbox(self, entry):
 980         return self._getints(
 981                 self.tk.call(self._w, 'info', 'bbox', entry)) or None
 982
 983     def info_children(self, entry=None):
 984         c = self.tk.call(self._w, 'info', 'children', entry)
 985         return self.tk.splitlist(c)
 986
 987     def info_data(self, entry):
 988         return self.tk.call(self._w, 'info', 'data', entry)
 989
 990     def info_dragsite(self):
 991         return self.tk.call(self._w, 'info', 'dragsite')
 992
 993     def info_dropsite(self):
 994         return self.tk.call(self._w, 'info', 'dropsite')
 995
 996     def info_exists(self, entry):
 997         return self.tk.call(self._w, 'info', 'exists', entry)
 998
 999     def info_hidden(self, entry):
1000         return self.tk.call(self._w, 'info', 'hidden', entry)
1001
1002     def info_next(self, entry):
1003         return self.tk.call(self._w, 'info', 'next', entry)
1004
1005     def info_parent(self, entry):
1006         return self.tk.call(self._w, 'info', 'parent', entry)
1007
1008     def info_prev(self, entry):
1009         return self.tk.call(self._w, 'info', 'prev', entry)
1010
1011     def info_selection(self):
1012         c = self.tk.call(self._w, 'info', 'selection')
1013         return self.tk.splitlist(c)
1014
1015     def item_cget(self, entry, col, opt):
1016         return self.tk.call(self._w, 'item', 'cget', entry, col, opt)
1017
1018     def item_configure(self, entry, col, cnf={}, **kw):
1019         if cnf is None:
1020             return _lst2dict(
1021                 self.tk.split(
1022                 self.tk.call(self._w, 'item', 'configure', entry, col)))
1023         self.tk.call(self._w, 'item', 'configure', entry, col,
1024               *self._options(cnf, kw))
1025
1026     def item_create(self, entry, col, cnf={}, **kw):
1027         self.tk.call(
1028               self._w, 'item', 'create', entry, col, *self._options(cnf, kw))
1029
1030     def item_exists(self, entry, col):
1031         return self.tk.call(self._w, 'item', 'exists', entry, col)
1032
1033     def item_delete(self, entry, col):
1034         self.tk.call(self._w, 'item', 'delete', entry, col)
1035
1036     def entrycget(self, entry, opt):
1037         return self.tk.call(self._w, 'entrycget', entry, opt)
1038
1039     def entryconfigure(self, entry, cnf={}, **kw):
1040         if cnf is None:
1041             return _lst2dict(
1042                 self.tk.split(
1043                 self.tk.call(self._w, 'entryconfigure', entry)))
1044         self.tk.call(self._w, 'entryconfigure', entry,
1045               *self._options(cnf, kw))
1046
1047     def nearest(self, y):
1048         return self.tk.call(self._w, 'nearest', y)
1049
1050     def see(self, entry):
1051         self.tk.call(self._w, 'see', entry)
1052
1053     def selection_clear(self, cnf={}, **kw):
1054         self.tk.call(self._w, 'selection', 'clear', *self._options(cnf, kw))
1055
1056     def selection_includes(self, entry):
1057         return self.tk.call(self._w, 'selection', 'includes', entry)
1058
1059     def selection_set(self, first, last=None):
1060         self.tk.call(self._w, 'selection', 'set', first, last)
1061
1062     def show_entry(self, entry):
1063         return self.tk.call(self._w, 'show', 'entry', entry)
1064
1065 class InputOnly(TixWidget):
1066     """InputOnly - Invisible widget. Unix only.
1067
1068     Subwidgets - None"""
1069
1070     def __init__ (self,master=None,cnf={}, **kw):
1071         TixWidget.__init__(self, master, 'tixInputOnly', None, cnf, kw)
1072
1073 class LabelEntry(TixWidget):
1074     """LabelEntry - Entry field with label. Packages an entry widget
1075     and a label into one mega widget. It can beused be used to simplify
1076     the creation of ``entry-form'' type of interface.
1077
1078     Subwidgets       Class
1079     ----------       -----
1080     label       Label
1081     entry       Entry"""
1082
1083     def __init__ (self,master=None,cnf={}, **kw):
1084         TixWidget.__init__(self, master, 'tixLabelEntry',
1085                            ['labelside','options'], cnf, kw)
1086         self.subwidget_list['label'] = _dummyLabel(self, 'label')
1087         self.subwidget_list['entry'] = _dummyEntry(self, 'entry')
1088
1089 class LabelFrame(TixWidget):
1090     """LabelFrame - Labelled Frame container. Packages a frame widget
1091     and a label into one mega widget. To create widgets inside a
1092     LabelFrame widget, one creates the new widgets relative to the
1093     frame subwidget and manage them inside the frame subwidget.
1094
1095     Subwidgets       Class
1096     ----------       -----
1097     label       Label
1098     frame       Frame"""
1099
1100     def __init__ (self,master=None,cnf={}, **kw):
1101         TixWidget.__init__(self, master, 'tixLabelFrame',
1102                            ['labelside','options'], cnf, kw)
1103         self.subwidget_list['label'] = _dummyLabel(self, 'label')
1104         self.subwidget_list['frame'] = _dummyFrame(self, 'frame')
1105
1106
1107 class ListNoteBook(TixWidget):
1108     """A ListNoteBook widget is very similar to the TixNoteBook widget:
1109     it can be used to display many windows in a limited space using a
1110     notebook metaphor. The notebook is divided into a stack of pages
1111     (windows). At one time only one of these pages can be shown.
1112     The user can navigate through these pages by
1113     choosing the name of the desired page in the hlist subwidget."""
1114
1115     def __init__(self, master, cnf={}, **kw):
1116         TixWidget.__init__(self, master, 'tixListNoteBook', ['options'], cnf, kw)
1117         # Is this necessary? It's not an exposed subwidget in Tix.
1118         self.subwidget_list['pane'] = _dummyPanedWindow(self, 'pane',
1119                                                         destroy_physically=0)
1120         self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
1121         self.subwidget_list['shlist'] = _dummyScrolledHList(self, 'shlist')
1122
1123     def add(self, name, cnf={}, **kw):
1124         self.tk.call(self._w, 'add', name, *self._options(cnf, kw))
1125         self.subwidget_list[name] = TixSubWidget(self, name)
1126         return self.subwidget_list[name]
1127
1128     def page(self, name):
1129         return self.subwidget(name)
1130
1131     def pages(self):
1132         # Can't call subwidgets_all directly because we don't want .nbframe
1133         names = self.tk.split(self.tk.call(self._w, 'pages'))
1134         ret = []
1135         for x in names:
1136             ret.append(self.subwidget(x))
1137         return ret
1138
1139     def raise_page(self, name):              # raise is a python keyword
1140         self.tk.call(self._w, 'raise', name)
1141
1142 class Meter(TixWidget):
1143     """The Meter widget can be used to show the progress of a background
1144     job which may take a long time to execute.
1145     """
1146
1147     def __init__(self, master=None, cnf={}, **kw):
1148         TixWidget.__init__(self, master, 'tixMeter',
1149                            ['options'], cnf, kw)
1150
1151 class NoteBook(TixWidget):
1152     """NoteBook - Multi-page container widget (tabbed notebook metaphor).
1153
1154     Subwidgets       Class
1155     ----------       -----
1156     nbframe       NoteBookFrame
1157     <pages>       page widgets added dynamically with the add method"""
1158
1159     def __init__ (self,master=None,cnf={}, **kw):
1160         TixWidget.__init__(self,master,'tixNoteBook', ['options'], cnf, kw)
1161         self.subwidget_list['nbframe'] = TixSubWidget(self, 'nbframe',
1162                                                       destroy_physically=0)
1163
1164     def add(self, name, cnf={}, **kw):
1165         self.tk.call(self._w, 'add', name, *self._options(cnf, kw))
1166         self.subwidget_list[name] = TixSubWidget(self, name)
1167         return self.subwidget_list[name]
1168
1169     def delete(self, name):
1170         self.tk.call(self._w, 'delete', name)
1171         self.subwidget_list[name].destroy()
1172         del self.subwidget_list[name]
1173
1174     def page(self, name):
1175         return self.subwidget(name)
1176
1177     def pages(self):
1178         # Can't call subwidgets_all directly because we don't want .nbframe
1179         names = self.tk.split(self.tk.call(self._w, 'pages'))
1180         ret = []
1181         for x in names:
1182             ret.append(self.subwidget(x))
1183         return ret
1184
1185     def raise_page(self, name):              # raise is a python keyword
1186         self.tk.call(self._w, 'raise', name)
1187
1188     def raised(self):
1189         return self.tk.call(self._w, 'raised')
1190
1191 class NoteBookFrame(TixWidget):
1192     # FIXME: This is dangerous to expose to be called on its own.
1193     pass
1194
1195 class OptionMenu(TixWidget):
1196     """OptionMenu - creates a menu button of options.
1197
1198     Subwidget       Class
1199     ---------       -----
1200     menubutton      Menubutton
1201     menu            Menu"""
1202
1203     def __init__(self, master, cnf={}, **kw):
1204         TixWidget.__init__(self, master, 'tixOptionMenu',
1205                 ['labelside', 'options'], cnf, kw)
1206         self.subwidget_list['menubutton'] = _dummyMenubutton(self, 'menubutton')
1207         self.subwidget_list['menu'] = _dummyMenu(self, 'menu')
1208
1209     def add_command(self, name, cnf={}, **kw):
1210         self.tk.call(self._w, 'add', 'command', name, *self._options(cnf, kw))
1211
1212     def add_separator(self, name, cnf={}, **kw):
1213         self.tk.call(self._w, 'add', 'separator', name, *self._options(cnf, kw))
1214
1215     def delete(self, name):
1216         self.tk.call(self._w, 'delete', name)
1217
1218     def disable(self, name):
1219         self.tk.call(self._w, 'disable', name)
1220
1221     def enable(self, name):
1222         self.tk.call(self._w, 'enable', name)
1223
1224 class PanedWindow(TixWidget):
1225     """PanedWindow - Multi-pane container widget
1226     allows the user to interactively manipulate the sizes of several
1227     panes. The panes can be arranged either vertically or horizontally.The
1228     user changes the sizes of the panes by dragging the resize handle
1229     between two panes.
1230
1231     Subwidgets       Class
1232     ----------       -----
1233     <panes>       g/p widgets added dynamically with the add method."""
1234
1235     def __init__(self, master, cnf={}, **kw):
1236         TixWidget.__init__(self, master, 'tixPanedWindow', ['orientation', 'options'], cnf, kw)
1237
1238     # add delete forget panecget paneconfigure panes setsize
1239     def add(self, name, cnf={}, **kw):
1240         self.tk.call(self._w, 'add', name, *self._options(cnf, kw))
1241         self.subwidget_list[name] = TixSubWidget(self, name,
1242                                                  check_intermediate=0)
1243         return self.subwidget_list[name]
1244
1245     def delete(self, name):
1246         self.tk.call(self._w, 'delete', name)
1247         self.subwidget_list[name].destroy()
1248         del self.subwidget_list[name]
1249
1250     def forget(self, name):
1251         self.tk.call(self._w, 'forget', name)
1252
1253     def panecget(self,  entry, opt):
1254         return self.tk.call(self._w, 'panecget', entry, opt)
1255
1256     def paneconfigure(self, entry, cnf={}, **kw):
1257         if cnf is None:
1258             return _lst2dict(
1259                 self.tk.split(
1260                 self.tk.call(self._w, 'paneconfigure', entry)))
1261         self.tk.call(self._w, 'paneconfigure', entry, *self._options(cnf, kw))
1262
1263     def panes(self):
1264         names = self.tk.splitlist(self.tk.call(self._w, 'panes'))
1265         return [self.subwidget(x) for x in names]
1266
1267 class PopupMenu(TixWidget):
1268     """PopupMenu widget can be used as a replacement of the tk_popup command.
1269     The advantage of the Tix PopupMenu widget is it requires less application
1270     code to manipulate.
1271
1272
1273     Subwidgets       Class
1274     ----------       -----
1275     menubutton       Menubutton
1276     menu       Menu"""
1277
1278     # FIXME: It should inherit -superclass tixShell
1279     def __init__(self, master, cnf={}, **kw):
1280         TixWidget.__init__(self, master, 'tixPopupMenu', ['options'], cnf, kw)
1281         self.subwidget_list['menubutton'] = _dummyMenubutton(self, 'menubutton')
1282         self.subwidget_list['menu'] = _dummyMenu(self, 'menu')
1283
1284     def bind_widget(self, widget):
1285         self.tk.call(self._w, 'bind', widget._w)
1286
1287     def unbind_widget(self, widget):
1288         self.tk.call(self._w, 'unbind', widget._w)
1289
1290     def post_widget(self, widget, x, y):
1291         self.tk.call(self._w, 'post', widget._w, x, y)
1292
1293 class ResizeHandle(TixWidget):
1294     """Internal widget to draw resize handles on Scrolled widgets."""
1295     def __init__(self, master, cnf={}, **kw):
1296         # There seems to be a Tix bug rejecting the configure method
1297         # Let's try making the flags -static
1298         flags = ['options', 'command', 'cursorfg', 'cursorbg',
1299                  'handlesize', 'hintcolor', 'hintwidth',
1300                  'x', 'y']
1301         # In fact, x y height width are configurable
1302         TixWidget.__init__(self, master, 'tixResizeHandle',
1303                            flags, cnf, kw)
1304
1305     def attach_widget(self, widget):
1306         self.tk.call(self._w, 'attachwidget', widget._w)
1307
1308     def detach_widget(self, widget):
1309         self.tk.call(self._w, 'detachwidget', widget._w)
1310
1311     def hide(self, widget):
1312         self.tk.call(self._w, 'hide', widget._w)
1313
1314     def show(self, widget):
1315         self.tk.call(self._w, 'show', widget._w)
1316
1317 class ScrolledHList(TixWidget):
1318     """ScrolledHList - HList with automatic scrollbars."""
1319
1320     # FIXME: It should inherit -superclass tixScrolledWidget
1321     def __init__(self, master, cnf={}, **kw):
1322         TixWidget.__init__(self, master, 'tixScrolledHList', ['options'],
1323                            cnf, kw)
1324         self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
1325         self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
1326         self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
1327
1328 class ScrolledListBox(TixWidget):
1329     """ScrolledListBox - Listbox with automatic scrollbars."""
1330
1331     # FIXME: It should inherit -superclass tixScrolledWidget
1332     def __init__(self, master, cnf={}, **kw):
1333         TixWidget.__init__(self, master, 'tixScrolledListBox', ['options'], cnf, kw)
1334         self.subwidget_list['listbox'] = _dummyListbox(self, 'listbox')
1335         self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
1336         self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
1337
1338 class ScrolledText(TixWidget):
1339     """ScrolledText - Text with automatic scrollbars."""
1340
1341     # FIXME: It should inherit -superclass tixScrolledWidget
1342     def __init__(self, master, cnf={}, **kw):
1343         TixWidget.__init__(self, master, 'tixScrolledText', ['options'], cnf, kw)
1344         self.subwidget_list['text'] = _dummyText(self, 'text')
1345         self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
1346         self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
1347
1348 class ScrolledTList(TixWidget):
1349     """ScrolledTList - TList with automatic scrollbars."""
1350
1351     # FIXME: It should inherit -superclass tixScrolledWidget
1352     def __init__(self, master, cnf={}, **kw):
1353         TixWidget.__init__(self, master, 'tixScrolledTList', ['options'],
1354                            cnf, kw)
1355         self.subwidget_list['tlist'] = _dummyTList(self, 'tlist')
1356         self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
1357         self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
1358
1359 class ScrolledWindow(TixWidget):
1360     """ScrolledWindow - Window with automatic scrollbars."""
1361
1362     # FIXME: It should inherit -superclass tixScrolledWidget
1363     def __init__(self, master, cnf={}, **kw):
1364         TixWidget.__init__(self, master, 'tixScrolledWindow', ['options'], cnf, kw)
1365         self.subwidget_list['window'] = _dummyFrame(self, 'window')
1366         self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
1367         self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
1368
1369 class Select(TixWidget):
1370     """Select - Container of button subwidgets. It can be used to provide
1371     radio-box or check-box style of selection options for the user.
1372
1373     Subwidgets are buttons added dynamically using the add method."""
1374
1375     # FIXME: It should inherit -superclass tixLabelWidget
1376     def __init__(self, master, cnf={}, **kw):
1377         TixWidget.__init__(self, master, 'tixSelect',
1378                            ['allowzero', 'radio', 'orientation', 'labelside',
1379                             'options'],
1380                            cnf, kw)
1381         self.subwidget_list['label'] = _dummyLabel(self, 'label')
1382
1383     def add(self, name, cnf={}, **kw):
1384         self.tk.call(self._w, 'add', name, *self._options(cnf, kw))
1385         self.subwidget_list[name] = _dummyButton(self, name)
1386         return self.subwidget_list[name]
1387
1388     def invoke(self, name):
1389         self.tk.call(self._w, 'invoke', name)
1390
1391 class Shell(TixWidget):
1392     """Toplevel window.
1393
1394     Subwidgets - None"""
1395
1396     def __init__ (self,master=None,cnf={}, **kw):
1397         TixWidget.__init__(self, master, 'tixShell', ['options', 'title'], cnf, kw)
1398
1399 class DialogShell(TixWidget):
1400     """Toplevel window, with popup popdown and center methods.
1401     It tells the window manager that it is a dialog window and should be
1402     treated specially. The exact treatment depends on the treatment of
1403     the window manager.
1404
1405     Subwidgets - None"""
1406
1407     # FIXME: It should inherit from  Shell
1408     def __init__ (self,master=None,cnf={}, **kw):
1409         TixWidget.__init__(self, master,
1410                            'tixDialogShell',
1411                            ['options', 'title', 'mapped',
1412                             'minheight', 'minwidth',
1413                             'parent', 'transient'], cnf, kw)
1414
1415     def popdown(self):
1416         self.tk.call(self._w, 'popdown')
1417
1418     def popup(self):
1419         self.tk.call(self._w, 'popup')
1420
1421     def center(self):
1422         self.tk.call(self._w, 'center')
1423
1424 class StdButtonBox(TixWidget):
1425     """StdButtonBox - Standard Button Box (OK, Apply, Cancel and Help) """
1426
1427     def __init__(self, master=None, cnf={}, **kw):
1428         TixWidget.__init__(self, master, 'tixStdButtonBox',
1429                            ['orientation', 'options'], cnf, kw)
1430         self.subwidget_list['ok'] = _dummyButton(self, 'ok')
1431         self.subwidget_list['apply'] = _dummyButton(self, 'apply')
1432         self.subwidget_list['cancel'] = _dummyButton(self, 'cancel')
1433         self.subwidget_list['help'] = _dummyButton(self, 'help')
1434
1435     def invoke(self, name):
1436         if name in self.subwidget_list:
1437             self.tk.call(self._w, 'invoke', name)
1438
1439 class TList(TixWidget, XView, YView):
1440     """TList - Hierarchy display widget which can be
1441     used to display data in a tabular format. The list entries of a TList
1442     widget are similar to the entries in the Tk listbox widget. The main
1443     differences are (1) the TList widget can display the list entries in a
1444     two dimensional format and (2) you can use graphical images as well as
1445     multiple colors and fonts for the list entries.
1446
1447     Subwidgets - None"""
1448
1449     def __init__ (self,master=None,cnf={}, **kw):
1450         TixWidget.__init__(self, master, 'tixTList', ['options'], cnf, kw)
1451
1452     def active_set(self, index):
1453         self.tk.call(self._w, 'active', 'set', index)
1454
1455     def active_clear(self):
1456         self.tk.call(self._w, 'active', 'clear')
1457
1458     def anchor_set(self, index):
1459         self.tk.call(self._w, 'anchor', 'set', index)
1460
1461     def anchor_clear(self):
1462         self.tk.call(self._w, 'anchor', 'clear')
1463
1464     def delete(self, from_, to=None):
1465         self.tk.call(self._w, 'delete', from_, to)
1466
1467     def dragsite_set(self, index):
1468         self.tk.call(self._w, 'dragsite', 'set', index)
1469
1470     def dragsite_clear(self):
1471         self.tk.call(self._w, 'dragsite', 'clear')
1472
1473     def dropsite_set(self, index):
1474         self.tk.call(self._w, 'dropsite', 'set', index)
1475
1476     def dropsite_clear(self):
1477         self.tk.call(self._w, 'dropsite', 'clear')
1478
1479     def insert(self, index, cnf={}, **kw):
1480         self.tk.call(self._w, 'insert', index, *self._options(cnf, kw))
1481
1482     def info_active(self):
1483         return self.tk.call(self._w, 'info', 'active')
1484
1485     def info_anchor(self):
1486         return self.tk.call(self._w, 'info', 'anchor')
1487
1488     def info_down(self, index):
1489         return self.tk.call(self._w, 'info', 'down', index)
1490
1491     def info_left(self, index):
1492         return self.tk.call(self._w, 'info', 'left', index)
1493
1494     def info_right(self, index):
1495         return self.tk.call(self._w, 'info', 'right', index)
1496
1497     def info_selection(self):
1498         c = self.tk.call(self._w, 'info', 'selection')
1499         return self.tk.splitlist(c)
1500
1501     def info_size(self):
1502         return self.tk.call(self._w, 'info', 'size')
1503
1504     def info_up(self, index):
1505         return self.tk.call(self._w, 'info', 'up', index)
1506
1507     def nearest(self, x, y):
1508         return self.tk.call(self._w, 'nearest', x, y)
1509
1510     def see(self, index):
1511         self.tk.call(self._w, 'see', index)
1512
1513     def selection_clear(self, cnf={}, **kw):
1514         self.tk.call(self._w, 'selection', 'clear', *self._options(cnf, kw))
1515
1516     def selection_includes(self, index):
1517         return self.tk.call(self._w, 'selection', 'includes', index)
1518
1519     def selection_set(self, first, last=None):
1520         self.tk.call(self._w, 'selection', 'set', first, last)
1521
1522 class Tree(TixWidget):
1523     """Tree - The tixTree widget can be used to display hierachical
1524     data in a tree form. The user can adjust
1525     the view of the tree by opening or closing parts of the tree."""
1526
1527     # FIXME: It should inherit -superclass tixScrolledWidget
1528     def __init__(self, master=None, cnf={}, **kw):
1529         TixWidget.__init__(self, master, 'tixTree',
1530                            ['options'], cnf, kw)
1531         self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
1532         self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
1533         self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
1534
1535     def autosetmode(self):
1536         '''This command calls the setmode method for all the entries in this
1537      Tree widget: if an entry has no child entries, its mode is set to
1538      none. Otherwise, if the entry has any hidden child entries, its mode is
1539      set to open; otherwise its mode is set to close.'''
1540         self.tk.call(self._w, 'autosetmode')
1541
1542     def close(self, entrypath):
1543         '''Close the entry given by entryPath if its mode is close.'''
1544         self.tk.call(self._w, 'close', entrypath)
1545
1546     def getmode(self, entrypath):
1547         '''Returns the current mode of the entry given by entryPath.'''
1548         return self.tk.call(self._w, 'getmode', entrypath)
1549
1550     def open(self, entrypath):
1551         '''Open the entry given by entryPath if its mode is open.'''
1552         self.tk.call(self._w, 'open', entrypath)
1553
1554     def setmode(self, entrypath, mode='none'):
1555         '''This command is used to indicate whether the entry given by
1556      entryPath has children entries and whether the children are visible. mode
1557      must be one of open, close or none. If mode is set to open, a (+)
1558      indicator is drawn next to the entry. If mode is set to close, a (-)
1559      indicator is drawn next to the entry. If mode is set to none, no
1560      indicators will be drawn for this entry. The default mode is none. The
1561      open mode indicates the entry has hidden children and this entry can be
1562      opened by the user. The close mode indicates that all the children of the
1563      entry are now visible and the entry can be closed by the user.'''
1564         self.tk.call(self._w, 'setmode', entrypath, mode)
1565
1566
1567 # Could try subclassing Tree for CheckList - would need another arg to init
1568 class CheckList(TixWidget):
1569     """The CheckList widget
1570     displays a list of items to be selected by the user. CheckList acts
1571     similarly to the Tk checkbutton or radiobutton widgets, except it is
1572     capable of handling many more items than checkbuttons or radiobuttons.
1573     """
1574     # FIXME: It should inherit -superclass tixTree
1575     def __init__(self, master=None, cnf={}, **kw):
1576         TixWidget.__init__(self, master, 'tixCheckList',
1577                            ['options', 'radio'], cnf, kw)
1578         self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
1579         self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
1580         self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
1581
1582     def autosetmode(self):
1583         '''This command calls the setmode method for all the entries in this
1584      Tree widget: if an entry has no child entries, its mode is set to
1585      none. Otherwise, if the entry has any hidden child entries, its mode is
1586      set to open; otherwise its mode is set to close.'''
1587         self.tk.call(self._w, 'autosetmode')
1588
1589     def close(self, entrypath):
1590         '''Close the entry given by entryPath if its mode is close.'''
1591         self.tk.call(self._w, 'close', entrypath)
1592
1593     def getmode(self, entrypath):
1594         '''Returns the current mode of the entry given by entryPath.'''
1595         return self.tk.call(self._w, 'getmode', entrypath)
1596
1597     def open(self, entrypath):
1598         '''Open the entry given by entryPath if its mode is open.'''
1599         self.tk.call(self._w, 'open', entrypath)
1600
1601     def getselection(self, mode='on'):
1602         '''Returns a list of items whose status matches status. If status is
1603      not specified, the list of items in the "on" status will be returned.
1604      Mode can be on, off, default'''
1605         c = self.tk.split(self.tk.call(self._w, 'getselection', mode))
1606         return self.tk.splitlist(c)
1607
1608     def getstatus(self, entrypath):
1609         '''Returns the current status of entryPath.'''
1610         return self.tk.call(self._w, 'getstatus', entrypath)
1611
1612     def setstatus(self, entrypath, mode='on'):
1613         '''Sets the status of entryPath to be status. A bitmap will be
1614      displayed next to the entry its status is on, off or default.'''
1615         self.tk.call(self._w, 'setstatus', entrypath, mode)
1616
1617
1618 ###########################################################################
1619 ### The subclassing below is used to instantiate the subwidgets in each ###
1620 ### mega widget. This allows us to access their methods directly.       ###
1621 ###########################################################################
1622
1623 class _dummyButton(Button, TixSubWidget):
1624     def __init__(self, master, name, destroy_physically=1):
1625         TixSubWidget.__init__(self, master, name, destroy_physically)
1626
1627 class _dummyCheckbutton(Checkbutton, TixSubWidget):
1628     def __init__(self, master, name, destroy_physically=1):
1629         TixSubWidget.__init__(self, master, name, destroy_physically)
1630
1631 class _dummyEntry(Entry, TixSubWidget):
1632     def __init__(self, master, name, destroy_physically=1):
1633         TixSubWidget.__init__(self, master, name, destroy_physically)
1634
1635 class _dummyFrame(Frame, TixSubWidget):
1636     def __init__(self, master, name, destroy_physically=1):
1637         TixSubWidget.__init__(self, master, name, destroy_physically)
1638
1639 class _dummyLabel(Label, TixSubWidget):
1640     def __init__(self, master, name, destroy_physically=1):
1641         TixSubWidget.__init__(self, master, name, destroy_physically)
1642
1643 class _dummyListbox(Listbox, TixSubWidget):
1644     def __init__(self, master, name, destroy_physically=1):
1645         TixSubWidget.__init__(self, master, name, destroy_physically)
1646
1647 class _dummyMenu(Menu, TixSubWidget):
1648     def __init__(self, master, name, destroy_physically=1):
1649         TixSubWidget.__init__(self, master, name, destroy_physically)
1650
1651 class _dummyMenubutton(Menubutton, TixSubWidget):
1652     def __init__(self, master, name, destroy_physically=1):
1653         TixSubWidget.__init__(self, master, name, destroy_physically)
1654
1655 class _dummyScrollbar(Scrollbar, TixSubWidget):
1656     def __init__(self, master, name, destroy_physically=1):
1657         TixSubWidget.__init__(self, master, name, destroy_physically)
1658
1659 class _dummyText(Text, TixSubWidget):
1660     def __init__(self, master, name, destroy_physically=1):
1661         TixSubWidget.__init__(self, master, name, destroy_physically)
1662
1663 class _dummyScrolledListBox(ScrolledListBox, TixSubWidget):
1664     def __init__(self, master, name, destroy_physically=1):
1665         TixSubWidget.__init__(self, master, name, destroy_physically)
1666         self.subwidget_list['listbox'] = _dummyListbox(self, 'listbox')
1667         self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
1668         self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
1669
1670 class _dummyHList(HList, TixSubWidget):
1671     def __init__(self, master, name, destroy_physically=1):
1672         TixSubWidget.__init__(self, master, name, destroy_physically)
1673
1674 class _dummyScrolledHList(ScrolledHList, TixSubWidget):
1675     def __init__(self, master, name, destroy_physically=1):
1676         TixSubWidget.__init__(self, master, name, destroy_physically)
1677         self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
1678         self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
1679         self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
1680
1681 class _dummyTList(TList, TixSubWidget):
1682     def __init__(self, master, name, destroy_physically=1):
1683         TixSubWidget.__init__(self, master, name, destroy_physically)
1684
1685 class _dummyComboBox(ComboBox, TixSubWidget):
1686     def __init__(self, master, name, destroy_physically=1):
1687         TixSubWidget.__init__(self, master, name, ['fancy',destroy_physically])
1688         self.subwidget_list['label'] = _dummyLabel(self, 'label')
1689         self.subwidget_list['entry'] = _dummyEntry(self, 'entry')
1690         self.subwidget_list['arrow'] = _dummyButton(self, 'arrow')
1691
1692         self.subwidget_list['slistbox'] = _dummyScrolledListBox(self,
1693                                                                 'slistbox')
1694         try:
1695             self.subwidget_list['tick'] = _dummyButton(self, 'tick')
1696             #cross Button : present if created with the fancy option
1697             self.subwidget_list['cross'] = _dummyButton(self, 'cross')
1698         except TypeError:
1699             # unavailable when -fancy not specified
1700             pass
1701
1702 class _dummyDirList(DirList, TixSubWidget):
1703     def __init__(self, master, name, destroy_physically=1):
1704         TixSubWidget.__init__(self, master, name, destroy_physically)
1705         self.subwidget_list['hlist'] = _dummyHList(self, 'hlist')
1706         self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb')
1707         self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb')
1708
1709 class _dummyDirSelectBox(DirSelectBox, TixSubWidget):
1710     def __init__(self, master, name, destroy_physically=1):
1711         TixSubWidget.__init__(self, master, name, destroy_physically)
1712         self.subwidget_list['dirlist'] = _dummyDirList(self, 'dirlist')
1713         self.subwidget_list['dircbx'] = _dummyFileComboBox(self, 'dircbx')
1714
1715 class _dummyExFileSelectBox(ExFileSelectBox, TixSubWidget):
1716     def __init__(self, master, name, destroy_physically=1):
1717         TixSubWidget.__init__(self, master, name, destroy_physically)
1718         self.subwidget_list['cancel'] = _dummyButton(self, 'cancel')
1719         self.subwidget_list['ok'] = _dummyButton(self, 'ok')
1720         self.subwidget_list['hidden'] = _dummyCheckbutton(self, 'hidden')
1721         self.subwidget_list['types'] = _dummyComboBox(self, 'types')
1722         self.subwidget_list['dir'] = _dummyComboBox(self, 'dir')
1723         self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist')
1724         self.subwidget_list['file'] = _dummyComboBox(self, 'file')
1725         self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist')
1726
1727 class _dummyFileSelectBox(FileSelectBox, TixSubWidget):
1728     def __init__(self, master, name, destroy_physically=1):
1729         TixSubWidget.__init__(self, master, name, destroy_physically)
1730         self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist')
1731         self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist')
1732         self.subwidget_list['filter'] = _dummyComboBox(self, 'filter')
1733         self.subwidget_list['selection'] = _dummyComboBox(self, 'selection')
1734
1735 class _dummyFileComboBox(ComboBox, TixSubWidget):
1736     def __init__(self, master, name, destroy_physically=1):
1737         TixSubWidget.__init__(self, master, name, destroy_physically)
1738         self.subwidget_list['dircbx'] = _dummyComboBox(self, 'dircbx')
1739
1740 class _dummyStdButtonBox(StdButtonBox, TixSubWidget):
1741     def __init__(self, master, name, destroy_physically=1):
1742         TixSubWidget.__init__(self, master, name, destroy_physically)
1743         self.subwidget_list['ok'] = _dummyButton(self, 'ok')
1744         self.subwidget_list['apply'] = _dummyButton(self, 'apply')
1745         self.subwidget_list['cancel'] = _dummyButton(self, 'cancel')
1746         self.subwidget_list['help'] = _dummyButton(self, 'help')
1747
1748 class _dummyNoteBookFrame(NoteBookFrame, TixSubWidget):
1749     def __init__(self, master, name, destroy_physically=0):
1750         TixSubWidget.__init__(self, master, name, destroy_physically)
1751
1752 class _dummyPanedWindow(PanedWindow, TixSubWidget):
1753     def __init__(self, master, name, destroy_physically=1):
1754         TixSubWidget.__init__(self, master, name, destroy_physically)
1755
1756 ########################
1757 ### Utility Routines ###
1758 ########################
1759
1760 #mike Should tixDestroy be exposed as a wrapper? - but not for widgets.
1761
1762 def OptionName(widget):
1763     '''Returns the qualified path name for the widget. Normally used to set
1764     default options for subwidgets. See tixwidgets.py'''
1765     return widget.tk.call('tixOptionName', widget._w)
1766
1767 # Called with a dictionary argument of the form
1768 # {'*.c':'C source files', '*.txt':'Text Files', '*':'All files'}
1769 # returns a string which can be used to configure the fsbox file types
1770 # in an ExFileSelectBox. i.e.,
1771 # '{{*} {* - All files}} {{*.c} {*.c - C source files}} {{*.txt} {*.txt - Text Files}}'
1772 def FileTypeList(dict):
1773     s = ''
1774     for type in dict.keys():
1775         s = s + '{{' + type + '} {' + type + ' - ' + dict[type] + '}} '
1776     return s
1777
1778 # Still to be done:
1779 # tixIconView
1780 class CObjView(TixWidget):
1781     """This file implements the Canvas Object View widget. This is a base
1782     class of IconView. It implements automatic placement/adjustment of the
1783     scrollbars according to the canvas objects inside the canvas subwidget.
1784     The scrollbars are adjusted so that the canvas is just large enough
1785     to see all the objects.
1786     """
1787     # FIXME: It should inherit -superclass tixScrolledWidget
1788     pass
1789
1790
1791 class Grid(TixWidget, XView, YView):
1792     '''The Tix Grid command creates a new window  and makes it into a
1793     tixGrid widget. Additional options, may be specified on the command
1794     line or in the option database to configure aspects such as its cursor
1795     and relief.
1796
1797     A Grid widget displays its contents in a two dimensional grid of cells.
1798     Each cell may contain one Tix display item, which may be in text,
1799     graphics or other formats. See the DisplayStyle class for more information
1800     about Tix display items. Individual cells, or groups of cells, can be
1801     formatted with a wide range of attributes, such as its color, relief and
1802     border.
1803
1804     Subwidgets - None'''
1805     # valid specific resources as of Tk 8.4
1806     # editdonecmd, editnotifycmd, floatingcols, floatingrows, formatcmd,
1807     # highlightbackground, highlightcolor, leftmargin, itemtype, selectmode,
1808     # selectunit, topmargin,
1809     def __init__(self, master=None, cnf={}, **kw):
1810         static= []
1811         self.cnf= cnf
1812         TixWidget.__init__(self, master, 'tixGrid', static, cnf, kw)
1813
1814     # valid options as of Tk 8.4
1815     # anchor, bdtype, cget, configure, delete, dragsite, dropsite, entrycget,
1816     # edit, entryconfigure, format, geometryinfo, info, index, move, nearest,
1817     # selection, set, size, unset, xview, yview
1818     def anchor_clear(self):
1819         """Removes the selection anchor."""
1820         self.tk.call(self, 'anchor', 'clear')
1821
1822     def anchor_get(self):
1823         "Get the (x,y) coordinate of the current anchor cell"
1824         return self._getints(self.tk.call(self, 'anchor', 'get'))
1825
1826     def anchor_set(self, x, y):
1827         """Set the selection anchor to the cell at (x, y)."""
1828         self.tk.call(self, 'anchor', 'set', x, y)
1829
1830     def delete_row(self, from_, to=None):
1831         """Delete rows between from_ and to inclusive.
1832         If to is not provided,  delete only row at from_"""
1833         if to is None:
1834             self.tk.call(self, 'delete', 'row', from_)
1835         else:
1836             self.tk.call(self, 'delete', 'row', from_, to)
1837
1838     def delete_column(self, from_, to=None):
1839         """Delete columns between from_ and to inclusive.
1840         If to is not provided,  delete only column at from_"""
1841         if to is None:
1842             self.tk.call(self, 'delete', 'column', from_)
1843         else:
1844             self.tk.call(self, 'delete', 'column', from_, to)
1845
1846     def edit_apply(self):
1847         """If any cell is being edited, de-highlight the cell  and  applies
1848         the changes."""
1849         self.tk.call(self, 'edit', 'apply')
1850
1851     def edit_set(self, x, y):
1852         """Highlights  the  cell  at  (x, y) for editing, if the -editnotify
1853         command returns True for this cell."""
1854         self.tk.call(self, 'edit', 'set', x, y)
1855
1856     def entrycget(self, x, y, option):
1857         "Get the option value for cell at (x,y)"
1858         if option and option[0] != '-':
1859             option = '-' + option
1860         return self.tk.call(self, 'entrycget', x, y, option)
1861
1862     def entryconfigure(self, x, y, cnf=None, **kw):
1863         return self._configure(('entryconfigure', x, y), cnf, kw)
1864
1865     # def format
1866     # def index
1867
1868     def info_exists(self, x, y):
1869         "Return True if display item exists at (x,y)"
1870         return self._getboolean(self.tk.call(self, 'info', 'exists', x, y))
1871
1872     def info_bbox(self, x, y):
1873         # This seems to always return '', at least for 'text' displayitems
1874         return self.tk.call(self, 'info', 'bbox', x, y)
1875
1876     def move_column(self, from_, to, offset):
1877         """Moves the the range of columns from position FROM through TO by
1878         the distance indicated by OFFSET. For example, move_column(2, 4, 1)
1879         moves the columns 2,3,4 to columns 3,4,5."""
1880         self.tk.call(self, 'move', 'column', from_, to, offset)
1881
1882     def move_row(self, from_, to, offset):
1883         """Moves the the range of rows from position FROM through TO by
1884         the distance indicated by OFFSET.
1885         For example, move_row(2, 4, 1) moves the rows 2,3,4 to rows 3,4,5."""
1886         self.tk.call(self, 'move', 'row', from_, to, offset)
1887
1888     def nearest(self, x, y):
1889         "Return coordinate of cell nearest pixel coordinate (x,y)"
1890         return self._getints(self.tk.call(self, 'nearest', x, y))
1891
1892     # def selection adjust
1893     # def selection clear
1894     # def selection includes
1895     # def selection set
1896     # def selection toggle
1897
1898     def set(self, x, y, itemtype=None, **kw):
1899         args= self._options(self.cnf, kw)
1900         if itemtype is not None:
1901             args= ('-itemtype', itemtype) + args
1902         self.tk.call(self, 'set', x, y, *args)
1903
1904     def size_column(self, index, **kw):
1905         """Queries  or  sets the size of the column given by
1906         INDEX.  INDEX may be any  non-negative
1907         integer  that  gives  the  position  of a given column.
1908         INDEX can also be the string "default"; in this case, this command
1909         queries or sets the default size of all columns.
1910         When  no  option-value  pair is given, this command returns a tuple
1911         containing the current size setting of the given  column.  When
1912         option-value  pairs  are  given,  the corresponding options of the
1913         size setting of the given column are changed. Options may be one
1914         of  the  follwing:
1915               pad0 pixels
1916                      Specifies the paddings to the left of a column.
1917               pad1 pixels
1918                      Specifies the paddings to the right of a  column.
1919               size val
1920                      Specifies  the  width of a column .
1921                      Val may be: "auto" -- the width of the column is set the
1922                      the widest cell in the column; a valid Tk screen distance
1923                      unit; or a real number following by the word chars
1924                      (e.g. 3.4chars) that sets the width of the column to the
1925                      given number of characters."""
1926         return self.tk.split(self.tk.call(self._w, 'size', 'column', index,
1927                              *self._options({}, kw)))
1928
1929     def size_row(self, index, **kw):
1930         """Queries  or  sets the size of the row given by
1931         INDEX. INDEX may be any  non-negative
1932         integer  that  gives  the  position  of a given row .
1933         INDEX can also be the string "default"; in this case, this command
1934         queries or sets the default size of all rows.
1935         When  no option-value pair is given, this command returns a list con-
1936         taining the current size setting of the given  row . When option-value
1937         pairs are given, the corresponding options of the size setting of the
1938         given row are changed. Options may be one of the follwing:
1939               pad0 pixels
1940                      Specifies the paddings to the top of a row.
1941               pad1 pixels
1942                      Specifies the paddings to the the bottom of a row.
1943               size val
1944                      Specifies  the height of a row.
1945                      Val may be: "auto" -- the height of the row  is  set  the
1946                      the highest cell in the row; a valid Tk screen distance
1947                      unit; or a real number following by the word chars
1948                      (e.g. 3.4chars) that sets the height of the row to the
1949                      given number of characters."""
1950         return self.tk.split(self.tk.call(
1951                     self, 'size', 'row', index, *self._options({}, kw)))
1952
1953     def unset(self, x, y):
1954         """Clears the cell at (x, y) by removing its display item."""
1955         self.tk.call(self._w, 'unset', x, y)
1956
1957
1958 class ScrolledGrid(Grid):
1959     '''Scrolled Grid widgets'''
1960
1961     # FIXME: It should inherit -superclass tixScrolledWidget
1962     def __init__(self, master=None, cnf={}, **kw):
1963         static= []
1964         self.cnf= cnf
1965         TixWidget.__init__(self, master, 'tixScrolledGrid', static, cnf, kw)