source: python/trunk/Lib/lib-tk/Tix.py@ 388

Last change on this file since 388 was 2, checked in by Yuri Dario, 15 years ago

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