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