source: titan/mediathek/localhoster/lib/python2.7/lib-tk/Tix.py @ 40114

Last change on this file since 40114 was 40094, checked in by obi, 5 years ago

tithek add yoztube-dl support

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