| # |
| # $Id$ |
| # |
| # Tix.py -- Tix widget wrappers, part of PyTix. |
| # |
| # - Sudhir Shenoy (sshenoy@gol.com), Dec. 1995. |
| # based on an idea (and a little code !!) of Jean-Marc Lugrin |
| # (lugrin@ms.com) |
| # |
| # NOTE: In order to minimize changes to Tkinter.py, some of the code here |
| # (TixWidget.__init__) has been taken from Tkinter (Widget.__init__) |
| # and will break if there are major changes in Tkinter. |
| # |
| # The Tix widgets are represented by a class hierarchy in python with proper |
| # inheritance of base classes. |
| # |
| # As a result after creating a 'w = StdButtonBox', I can write |
| # w.ok['text'] = 'Who Cares' |
| # or w.ok['bg'] = w['bg'] |
| # or even w.ok.invoke() |
| # etc. |
| # |
| # Compare the demo tixwidgets.py to the original Tcl program and you will |
| # appreciate the advantages. |
| # |
| |
| import string |
| from Tkinter import * |
| from Tkinter import _flatten, _cnfmerge, _default_root |
| |
| # WARNING - TkVersion is a limited precision floating point number |
| if TkVersion < 3.999: |
| raise ImportError, "This version of Tix.py requires Tk 4.0 or higher" |
| |
| import _tkinter # If this fails your Python may not be configured for Tk |
| # TixVersion = string.atof(tkinter.TIX_VERSION) # If this fails your Python may not be configured for Tix |
| # WARNING - TixVersion is a limited precision floating point number |
| |
| # Some more constants (for consistency with Tkinter) |
| WINDOW = 'window' |
| TEXT = 'text' |
| STATUS = 'status' |
| IMMEDIATE = 'immediate' |
| IMAGE = 'image' |
| IMAGETEXT = 'imagetext' |
| BALLOON = 'balloon' |
| AUTO = 'auto' |
| ACROSSTOP = 'acrosstop' |
| |
| # BEWARE - this is implemented by copying some code from the Widget class |
| # in Tkinter (to override Widget initialization) and is therefore |
| # liable to break. |
| import Tkinter, os |
| class Tk(Tkinter.Tk): |
| """Toplevel widget of Tix which represents mostly the main window |
| of an application. It has an associated Tcl interpreter.""" |
| def __init__(self, screenName=None, baseName=None, className='Tk'): |
| Tkinter.Tk.__init__(self, screenName, baseName, className) |
| tixlib = os.environ.get('TIX_LIBRARY') |
| if tixlib is not None: |
| self.tk.eval('global auto_path; lappend auto_path {%s}' % tixlib) |
| self.tk.eval('global tcl_pkgPath; lappend tcl_pkgPath {%s}' % tixlib) |
| # Load Tix - this should work dynamically or statically |
| # If it's static, lib/tix8.1/pkgIndex.tcl should have 'load {} Tix' |
| # If it's dynamic, it should have 'load libtix8.1.8.2.so Tix' |
| self.tk.eval('package require Tix') |
| |
| # The Tix 'tixForm' geometry manager |
| class Form: |
| """The Tix Form geometry manager |
| |
| Widgets can be arranged by specifying attachments to other widgets. |
| See Tix documentation for complete details""" |
| |
| def config(self, cnf={}, **kw): |
| apply(self.tk.call, ('tixForm', self._w) + self._options(cnf, kw)) |
| |
| form = config |
| |
| def __setitem__(self, key, value): |
| Form.form({key: value}) |
| |
| def check(self): |
| return self.tk.call('tixForm', 'check', self._w) |
| |
| def forget(self): |
| self.tk.call('tixForm', 'forget', self._w) |
| |
| def grid(self, xsize=0, ysize=0): |
| if (not xsize) and (not ysize): |
| x = self.tk.call('tixForm', 'grid', self._w) |
| y = self.tk.splitlist(x) |
| z = () |
| for x in y: |
| z = z + (self.tk.getint(x),) |
| return z |
| self.tk.call('tixForm', 'grid', self._w, xsize, ysize) |
| |
| def info(self, option=None): |
| if not option: |
| return self.tk.call('tixForm', 'info', self._w) |
| if option[0] != '-': |
| option = '-' + option |
| return self.tk.call('tixForm', 'info', self._w, option) |
| |
| def slaves(self): |
| return map(self._nametowidget, |
| self.tk.splitlist( |
| self.tk.call( |
| 'tixForm', 'slaves', self._w))) |
| |
| |
| Tkinter.Widget.__bases__ = Tkinter.Widget.__bases__ + (Form,) |
| |
| class TixWidget(Widget): |
| """A TixWidget class is used to package all (or most) Tix widgets. |
| |
| Widget initialization is extended in two ways: |
| 1) It is possible to give a list of options which must be part of |
| the creation command (so called Tix 'static' options). These cannot be |
| given as a 'config' command later. |
| 2) It is possible to give the name of an existing TK widget. These are |
| child widgets created automatically by a Tix mega-widget. The Tk call |
| to create these widgets is therefore bypassed in TixWidget.__init__ |
| |
| Both options are for use by subclasses only. |
| """ |
| def __init__ (self, master=None, widgetName=None, |
| static_options=None, cnf={}, kw={}): |
| # Merge keywords and dictionary arguments |
| if kw: |
| cnf = _cnfmerge((cnf, kw)) |
| else: |
| cnf = _cnfmerge(cnf) |
| |
| # Move static options into extra. static_options must be |
| # a list of keywords (or None). |
| extra=() |
| if static_options: |
| for k,v in cnf.items()[:]: |
| if k in static_options: |
| extra = extra + ('-' + k, v) |
| del cnf[k] |
| |
| self.widgetName = widgetName |
| Widget._setup(self, master, cnf) |
| |
| # If widgetName is None, this is a dummy creation call where the |
| # corresponding Tk widget has already been created by Tix |
| if widgetName: |
| apply(self.tk.call, (widgetName, self._w) + extra) |
| |
| # Non-static options - to be done via a 'config' command |
| if cnf: |
| Widget.config(self, cnf) |
| |
| # Dictionary to hold subwidget names for easier access. We can't |
| # use the children list because the public Tix names may not be the |
| # same as the pathname component |
| self.subwidget_list = {} |
| |
| # We set up an attribute access function so that it is possible to |
| # do w.ok['text'] = 'Hello' rather than w.subwidget('ok')['text'] = 'Hello' |
| # when w is a StdButtonBox. |
| # We can even do w.ok.invoke() because w.ok is subclassed from the |
| # Button class if you go through the proper constructors |
| def __getattr__(self, name): |
| if self.subwidget_list.has_key(name): |
| return self.subwidget_list[name] |
| raise AttributeError, name |
| |
| # Set a variable without calling its action routine |
| def set_silent(self, value): |
| self.tk.call('tixSetSilent', self._w, value) |
| |
| # Return the named subwidget (which must have been created by |
| # the sub-class). |
| def subwidget(self, name): |
| n = self._subwidget_name(name) |
| if not n: |
| raise TclError, "Subwidget " + name + " not child of " + self._name |
| # Remove header of name and leading dot |
| n = n[len(self._w)+1:] |
| return self._nametowidget(n) |
| |
| # Return all subwidgets |
| def subwidgets_all(self): |
| names = self._subwidget_names() |
| if not names: |
| return [] |
| retlist = [] |
| for name in names: |
| name = name[len(self._w)+1:] |
| try: |
| retlist.append(self._nametowidget(name)) |
| except: |
| # some of the widgets are unknown e.g. border in LabelFrame |
| pass |
| return retlist |
| |
| # Get a subwidget name (returns a String, not a Widget !) |
| def _subwidget_name(self,name): |
| try: |
| return self.tk.call(self._w, 'subwidget', name) |
| except TclError: |
| return None |
| |
| # Return the name of all subwidgets |
| def _subwidget_names(self): |
| try: |
| x = self.tk.call(self._w, 'subwidgets', '-all') |
| return self.tk.split(x) |
| except TclError: |
| return None |
| |
| # Set configuration options for all subwidgets (and self) |
| def config_all(self, option, value): |
| if option == '': |
| return |
| elif type(option) != type(''): |
| option = `option` |
| if type(value) != type(''): |
| value = `value` |
| names = self._subwidget_names() |
| for name in names: |
| self.tk.call(name, 'configure', '-' + option, value) |
| |
| # Subwidgets are child widgets created automatically by mega-widgets. |
| # In python, we have to create these subwidgets manually to mirror their |
| # existence in Tk/Tix. |
| class TixSubWidget(TixWidget): |
| """Subwidget class. |
| |
| This is used to mirror child widgets automatically created |
| by Tix/Tk as part of a mega-widget in Python (which is not informed |
| of this)""" |
| |
| def __init__(self, master, name, |
| destroy_physically=1, check_intermediate=1): |
| if check_intermediate: |
| path = master._subwidget_name(name) |
| try: |
| path = path[len(master._w)+1:] |
| plist = string.splitfields(path, '.') |
| except: |
| plist = [] |
| |
| if (not check_intermediate) or len(plist) < 2: |
| # immediate descendant |
| TixWidget.__init__(self, master, None, None, {'name' : name}) |
| else: |
| # Ensure that the intermediate widgets exist |
| parent = master |
| for i in range(len(plist) - 1): |
| n = string.joinfields(plist[:i+1], '.') |
| try: |
| w = master._nametowidget(n) |
| parent = w |
| except KeyError: |
| # Create the intermediate widget |
| parent = TixSubWidget(parent, plist[i], |
| destroy_physically=0, |
| check_intermediate=0) |
| TixWidget.__init__(self, parent, None, None, {'name' : name}) |
| self.destroy_physically = destroy_physically |
| |
| def destroy(self): |
| # For some widgets e.g., a NoteBook, when we call destructors, |
| # we must be careful not to destroy the frame widget since this |
| # also destroys the parent NoteBook thus leading to an exception |
| # in Tkinter when it finally calls Tcl to destroy the NoteBook |
| for c in self.children.values(): c.destroy() |
| if self.master.children.has_key(self._name): |
| del self.master.children[self._name] |
| if self.master.subwidget_list.has_key(self._name): |
| del self.master.subwidget_list[self._name] |
| if self.destroy_physically: |
| # This is bypassed only for a few widgets |
| self.tk.call('destroy', self._w) |
| |
| |
| # Useful func. to split Tcl lists and return as a dict. From Tkinter.py |
| def _lst2dict(lst): |
| dict = {} |
| for x in lst: |
| dict[x[0][1:]] = (x[0][1:],) + x[1:] |
| return dict |
| |
| # Useful class to create a display style - later shared by many items. |
| # Contributed by Steffen Kremser |
| class DisplayStyle: |
| """DisplayStyle - handle configuration options shared by |
| (multiple) Display Items""" |
| |
| def __init__(self, itemtype, cnf={}, **kw ): |
| master = _default_root # global from Tkinter |
| if not master and cnf.has_key('refwindow'): master=cnf['refwindow'] |
| elif not master and kw.has_key('refwindow'): master= kw['refwindow'] |
| elif not master: raise RuntimeError, "Too early to create display style: no root window" |
| self.tk = master.tk |
| self.stylename = apply(self.tk.call, ('tixDisplayStyle', itemtype) + |
| self._options(cnf,kw) ) |
| |
| def __str__(self): |
| return self.stylename |
| |
| def _options(self, cnf, kw ): |
| if kw and cnf: |
| cnf = _cnfmerge((cnf, kw)) |
| elif kw: |
| cnf = kw |
| opts = () |
| for k, v in cnf.items(): |
| opts = opts + ('-'+k, v) |
| return opts |
| |
| def delete(self): |
| self.tk.call(self.stylename, 'delete') |
| del(self) |
| |
| def __setitem__(self,key,value): |
| self.tk.call(self.stylename, 'configure', '-%s'%key, value) |
| |
| def config(self, cnf={}, **kw): |
| return _lst2dict( |
| self.tk.split( |
| apply(self.tk.call, |
| (self.stylename, 'configure') + self._options(cnf,kw)))) |
| |
| def __getitem__(self,key): |
| return self.tk.call(self.stylename, 'cget', '-%s'%key, value) |
| |
| |
| ###################################################### |
| ### The Tix Widget classes - in alphabetical order ### |
| ###################################################### |
| |
| class Balloon(TixWidget): |
| """Balloon help widget. |
| |
| Subwidget Class |
| --------- ----- |
| label Label |
| message Message""" |
| |
| def __init__(self, master=None, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixBalloon', ['options'], cnf, kw) |
| self.subwidget_list['label'] = _dummyLabel(self, 'label', |
| destroy_physically=0) |
| self.subwidget_list['message'] = _dummyLabel(self, 'message', |
| destroy_physically=0) |
| |
| def bind_widget(self, widget, cnf={}, **kw): |
| """Bind balloon widget to another. |
| One balloon widget may be bound to several widgets at the same time""" |
| apply(self.tk.call, |
| (self._w, 'bind', widget._w) + self._options(cnf, kw)) |
| |
| def unbind_widget(self, widget): |
| self.tk.call(self._w, 'unbind', widget._w) |
| |
| class ButtonBox(TixWidget): |
| """ButtonBox - A container for pushbuttons""" |
| def __init__(self, master=None, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixButtonBox', |
| ['orientation', 'options'], cnf, kw) |
| |
| def add(self, name, cnf={}, **kw): |
| """Add a button with given name to box.""" |
| |
| btn = apply(self.tk.call, |
| (self._w, 'add', name) + self._options(cnf, kw)) |
| self.subwidget_list[name] = _dummyButton(self, name) |
| return btn |
| |
| def invoke(self, name): |
| if self.subwidget_list.has_key(name): |
| self.tk.call(self._w, 'invoke', name) |
| |
| class ComboBox(TixWidget): |
| """ComboBox - an Entry field with a dropdown menu |
| |
| Subwidget Class |
| --------- ----- |
| entry Entry |
| arrow Button |
| slistbox ScrolledListBox |
| tick Button } |
| cross Button } present if created with the fancy option""" |
| |
| def __init__ (self, master=None, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixComboBox', |
| ['editable', 'dropdown', 'fancy', 'options'], |
| cnf, kw) |
| self.subwidget_list['label'] = _dummyLabel(self, 'label') |
| self.subwidget_list['entry'] = _dummyEntry(self, 'entry') |
| self.subwidget_list['arrow'] = _dummyButton(self, 'arrow') |
| self.subwidget_list['slistbox'] = _dummyScrolledListBox(self, |
| 'slistbox') |
| try: |
| self.subwidget_list['tick'] = _dummyButton(self, 'tick') |
| self.subwidget_list['cross'] = _dummyButton(self, 'cross') |
| except TypeError: |
| # unavailable when -fancy not specified |
| pass |
| |
| def add_history(self, str): |
| self.tk.call(self._w, 'addhistory', str) |
| |
| def append_history(self, str): |
| self.tk.call(self._w, 'appendhistory', str) |
| |
| def insert(self, index, str): |
| self.tk.call(self._w, 'insert', index, str) |
| |
| def pick(self, index): |
| self.tk.call(self._w, 'pick', index) |
| |
| class Control(TixWidget): |
| """Control - An entry field with value change arrows. |
| |
| Subwidget Class |
| --------- ----- |
| incr Button |
| decr Button |
| entry Entry |
| label Label""" |
| |
| def __init__ (self, master=None, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixControl', ['options'], cnf, kw) |
| self.subwidget_list['incr'] = _dummyButton(self, 'incr') |
| self.subwidget_list['decr'] = _dummyButton(self, 'decr') |
| self.subwidget_list['label'] = _dummyLabel(self, 'label') |
| self.subwidget_list['entry'] = _dummyEntry(self, 'entry') |
| |
| def decrement(self): |
| self.tk.call(self._w, 'decr') |
| |
| def increment(self): |
| self.tk.call(self._w, 'incr') |
| |
| def invoke(self): |
| self.tk.call(self._w, 'invoke') |
| |
| def update(self): |
| self.tk.call(self._w, 'update') |
| |
| class DirList(TixWidget): |
| """DirList - Directory Listing. |
| |
| Subwidget Class |
| --------- ----- |
| hlist HList |
| hsb Scrollbar |
| vsb Scrollbar""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixDirList', ['options'], cnf, kw) |
| self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') |
| self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') |
| self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') |
| |
| def chdir(self, dir): |
| self.tk.call(self._w, 'chdir', dir) |
| |
| class DirTree(TixWidget): |
| """DirList - Directory Listing in a hierarchical view. |
| |
| Subwidget Class |
| --------- ----- |
| hlist HList |
| hsb Scrollbar |
| vsb Scrollbar""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixDirTree', ['options'], cnf, kw) |
| self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') |
| self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') |
| self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') |
| |
| def chdir(self, dir): |
| self.tk.call(self._w, 'chdir', dir) |
| |
| class ExFileSelectBox(TixWidget): |
| """ExFileSelectBox - MS Windows style file select box. |
| |
| Subwidget Class |
| --------- ----- |
| cancel Button |
| ok Button |
| hidden Checkbutton |
| types ComboBox |
| dir ComboBox |
| file ComboBox |
| dirlist ScrolledListBox |
| filelist ScrolledListBox""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixExFileSelectBox', ['options'], cnf, kw) |
| self.subwidget_list['cancel'] = _dummyButton(self, 'cancel') |
| self.subwidget_list['ok'] = _dummyButton(self, 'ok') |
| self.subwidget_list['hidden'] = _dummyCheckbutton(self, 'hidden') |
| self.subwidget_list['types'] = _dummyComboBox(self, 'types') |
| self.subwidget_list['dir'] = _dummyComboBox(self, 'dir') |
| self.subwidget_list['dirlist'] = _dummyDirList(self, 'dirlist') |
| self.subwidget_list['file'] = _dummyComboBox(self, 'file') |
| self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist') |
| |
| def filter(self): |
| self.tk.call(self._w, 'filter') |
| |
| def invoke(self): |
| self.tk.call(self._w, 'invoke') |
| |
| class ExFileSelectDialog(TixWidget): |
| """ExFileSelectDialog - MS Windows style file select dialog. |
| |
| Subwidgets Class |
| ---------- ----- |
| fsbox ExFileSelectBox""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixExFileSelectDialog', |
| ['options'], cnf, kw) |
| self.subwidget_list['fsbox'] = _dummyExFileSelectBox(self, 'fsbox') |
| |
| def popup(self): |
| self.tk.call(self._w, 'popup') |
| |
| def popdown(self): |
| self.tk.call(self._w, 'popdown') |
| |
| class FileSelectBox(TixWidget): |
| """ExFileSelectBox - Motif style file select box. |
| |
| Subwidget Class |
| --------- ----- |
| selection ComboBox |
| filter ComboBox |
| dirlist ScrolledListBox |
| filelist ScrolledListBox""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixFileSelectBox', ['options'], cnf, kw) |
| self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist') |
| self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist') |
| self.subwidget_list['filter'] = _dummyComboBox(self, 'filter') |
| self.subwidget_list['selection'] = _dummyComboBox(self, 'selection') |
| |
| def apply_filter(self): # name of subwidget is same as command |
| self.tk.call(self._w, 'filter') |
| |
| def invoke(self): |
| self.tk.call(self._w, 'invoke') |
| |
| class FileSelectDialog(TixWidget): |
| """FileSelectDialog - Motif style file select dialog. |
| |
| Subwidgets Class |
| ---------- ----- |
| btns StdButtonBox |
| fsbox FileSelectBox""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixFileSelectDialog', |
| ['options'], cnf, kw) |
| self.subwidget_list['btns'] = _dummyStdButtonBox(self, 'btns') |
| self.subwidget_list['fsbox'] = _dummyFileSelectBox(self, 'fsbox') |
| |
| def popup(self): |
| self.tk.call(self._w, 'popup') |
| |
| def popdown(self): |
| self.tk.call(self._w, 'popdown') |
| |
| class FileEntry(TixWidget): |
| """FileEntry - Entry field with button that invokes a FileSelectDialog |
| |
| Subwidgets Class |
| ---------- ----- |
| button Button |
| entry Entry""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixFileEntry', |
| ['dialogtype', 'options'], cnf, kw) |
| self.subwidget_list['button'] = _dummyButton(self, 'button') |
| self.subwidget_list['entry'] = _dummyEntry(self, 'entry') |
| |
| def invoke(self): |
| self.tk.call(self._w, 'invoke') |
| |
| def file_dialog(self): |
| # XXX return python object |
| pass |
| |
| class HList(TixWidget): |
| """HList - Hierarchy display. |
| |
| Subwidgets - None""" |
| |
| def __init__ (self,master=None,cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixHList', |
| ['columns', 'options'], cnf, kw) |
| |
| def add(self, entry, cnf={}, **kw): |
| return apply(self.tk.call, |
| (self._w, 'add', entry) + self._options(cnf, kw)) |
| |
| def add_child(self, parent=None, cnf={}, **kw): |
| if not parent: |
| parent = '' |
| return apply(self.tk.call, |
| (self._w, 'addchild', parent) + self._options(cnf, kw)) |
| |
| def anchor_set(self, entry): |
| self.tk.call(self._w, 'anchor', 'set', entry) |
| |
| def anchor_clear(self): |
| self.tk.call(self._w, 'anchor', 'clear') |
| |
| def column_width(self, col=0, width=None, chars=None): |
| if not chars: |
| return self.tk.call(self._w, 'column', 'width', col, width) |
| else: |
| return self.tk.call(self._w, 'column', 'width', col, |
| '-char', chars) |
| |
| def delete_all(self): |
| self.tk.call(self._w, 'delete', 'all') |
| |
| def delete_entry(self, entry): |
| self.tk.call(self._w, 'delete', 'entry', entry) |
| |
| def delete_offsprings(self, entry): |
| self.tk.call(self._w, 'delete', 'offsprings', entry) |
| |
| def delete_siblings(self, entry): |
| self.tk.call(self._w, 'delete', 'siblings', entry) |
| |
| def dragsite_set(self, index): |
| self.tk.call(self._w, 'dragsite', 'set', index) |
| |
| def dragsite_clear(self): |
| self.tk.call(self._w, 'dragsite', 'clear') |
| |
| def dropsite_set(self, index): |
| self.tk.call(self._w, 'dropsite', 'set', index) |
| |
| def dropsite_clear(self): |
| self.tk.call(self._w, 'dropsite', 'clear') |
| |
| def header_create(self, col, cnf={}, **kw): |
| apply(self.tk.call, |
| (self._w, 'header', 'create', col) + self._options(cnf, kw)) |
| |
| def header_configure(self, col, cnf={}, **kw): |
| if cnf is None: |
| return _lst2dict( |
| self.tk.split( |
| self.tk.call(self._w, 'header', 'configure', col))) |
| apply(self.tk.call, (self._w, 'header', 'configure', col) |
| + self._options(cnf, kw)) |
| |
| def header_cget(self, col, opt): |
| return self.tk.call(self._w, 'header', 'cget', col, opt) |
| |
| def header_exists(self, col): |
| return self.tk.call(self._w, 'header', 'exists', col) |
| |
| def header_delete(self, col): |
| self.tk.call(self._w, 'header', 'delete', col) |
| |
| def header_size(self, col): |
| return self.tk.call(self._w, 'header', 'size', col) |
| |
| def hide_entry(self, entry): |
| self.tk.call(self._w, 'hide', 'entry', entry) |
| |
| def indicator_create(self, entry, cnf={}, **kw): |
| apply(self.tk.call, |
| (self._w, 'indicator', 'create', entry) + self._options(cnf, kw)) |
| |
| def indicator_configure(self, entry, cnf={}, **kw): |
| if cnf is None: |
| return _lst2dict( |
| self.tk.split( |
| self.tk.call(self._w, 'indicator', 'configure', entry))) |
| apply(self.tk.call, |
| (self._w, 'indicator', 'configure', entry) + self._options(cnf, kw)) |
| |
| def indicator_cget(self, entry, opt): |
| return self.tk.call(self._w, 'indicator', 'cget', entry, opt) |
| |
| def indicator_exists(self, entry): |
| return self.tk.call (self._w, 'indicator', 'exists', entry) |
| |
| def indicator_delete(self, entry): |
| self.tk.call(self._w, 'indicator', 'delete', entry) |
| |
| def indicator_size(self, entry): |
| return self.tk.call(self._w, 'indicator', 'size', entry) |
| |
| def info_anchor(self): |
| return self.tk.call(self._w, 'info', 'anchor') |
| |
| def info_children(self, entry=None): |
| c = self.tk.call(self._w, 'info', 'children', entry) |
| return self.tk.splitlist(c) |
| |
| def info_data(self, entry): |
| return self.tk.call(self._w, 'info', 'data', entry) |
| |
| def info_exists(self, entry): |
| return self.tk.call(self._w, 'info', 'exists', entry) |
| |
| def info_hidden(self, entry): |
| return self.tk.call(self._w, 'info', 'hidden', entry) |
| |
| def info_next(self, entry): |
| return self.tk.call(self._w, 'info', 'next', entry) |
| |
| def info_parent(self, entry): |
| return self.tk.call(self._w, 'info', 'parent', entry) |
| |
| def info_prev(self, entry): |
| return self.tk.call(self._w, 'info', 'prev', entry) |
| |
| def info_selection(self): |
| c = self.tk.call(self._w, 'info', 'selection') |
| return self.tk.splitlist(c) |
| |
| def item_cget(self, col, opt): |
| return self.tk.call(self._w, 'item', 'cget', col, opt) |
| |
| def item_configure(self, entry, col, cnf={}, **kw): |
| if cnf is None: |
| return _lst2dict( |
| self.tk.split( |
| self.tk.call(self._w, 'item', 'configure', entry, col))) |
| apply(self.tk.call, (self._w, 'item', 'configure', entry, col) + |
| self._options(cnf, kw)) |
| |
| def item_create(self, entry, col, cnf={}, **kw): |
| apply(self.tk.call, |
| (self._w, 'item', 'create', entry, col) + self._options(cnf, kw)) |
| |
| def item_exists(self, entry, col): |
| return self.tk.call(self._w, 'item', 'exists', entry, col) |
| |
| def item_delete(self, entry, col): |
| self.tk.call(self._w, 'item', 'delete', entry, col) |
| |
| def nearest(self, y): |
| return self.tk.call(self._w, 'nearest', y) |
| |
| def see(self, entry): |
| self.tk.call(self._w, 'see', entry) |
| |
| def selection_clear(self, cnf={}, **kw): |
| apply(self.tk.call, |
| (self._w, 'selection', 'clear') + self._options(cnf, kw)) |
| |
| def selection_includes(self, entry): |
| return self.tk.call(self._w, 'selection', 'includes', entry) |
| |
| def selection_set(self, first, last=None): |
| self.tk.call(self._w, 'selection', 'set', first, last) |
| |
| def show_entry(self, entry): |
| return self.tk.call(self._w, 'show', 'entry', entry) |
| |
| def xview(self, *args): |
| apply(self.tk.call, (self._w, 'xview') + args) |
| |
| def yview(self, *args): |
| apply(self.tk.call, (self._w, 'yview') + args) |
| |
| class InputOnly(TixWidget): |
| """InputOnly - Invisible widget. |
| |
| Subwidgets - None""" |
| |
| def __init__ (self,master=None,cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixInputOnly', None, cnf, kw) |
| |
| class LabelEntry(TixWidget): |
| """LabelEntry - Entry field with label. |
| |
| Subwidgets Class |
| ---------- ----- |
| label Label |
| entry Entry""" |
| |
| def __init__ (self,master=None,cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixLabelEntry', |
| ['labelside','options'], cnf, kw) |
| self.subwidget_list['label'] = _dummyLabel(self, 'label') |
| self.subwidget_list['entry'] = _dummyEntry(self, 'entry') |
| |
| class LabelFrame(TixWidget): |
| """LabelFrame - Labelled Frame container. |
| |
| Subwidgets Class |
| ---------- ----- |
| label Label |
| frame Frame""" |
| |
| def __init__ (self,master=None,cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixLabelFrame', |
| ['labelside','options'], cnf, kw) |
| self.subwidget_list['label'] = _dummyLabel(self, 'label') |
| self.subwidget_list['frame'] = _dummyFrame(self, 'frame') |
| |
| class NoteBook(TixWidget): |
| """NoteBook - Multi-page container widget (tabbed notebook metaphor). |
| |
| Subwidgets Class |
| ---------- ----- |
| nbframe NoteBookFrame |
| <pages> g/p widgets added dynamically""" |
| |
| def __init__ (self,master=None,cnf={}, **kw): |
| TixWidget.__init__(self,master,'tixNoteBook', ['options'], cnf, kw) |
| self.subwidget_list['nbframe'] = TixSubWidget(self, 'nbframe', |
| destroy_physically=0) |
| |
| def add(self, name, cnf={}, **kw): |
| apply(self.tk.call, |
| (self._w, 'add', name) + self._options(cnf, kw)) |
| self.subwidget_list[name] = TixSubWidget(self, name) |
| return self.subwidget_list[name] |
| |
| def delete(self, name): |
| self.tk.call(self._w, 'delete', name) |
| |
| def page(self, name): |
| return self.subwidget(name) |
| |
| def pages(self): |
| # Can't call subwidgets_all directly because we don't want .nbframe |
| names = self.tk.split(self.tk.call(self._w, 'pages')) |
| ret = [] |
| for x in names: |
| ret.append(self.subwidget(x)) |
| return ret |
| |
| def raise_page(self, name): # raise is a python keyword |
| self.tk.call(self._w, 'raise', name) |
| |
| def raised(self): |
| return self.tk.call(self._w, 'raised') |
| |
| class NoteBookFrame(TixWidget): |
| """Will be added when Tix documentation is available !!!""" |
| pass |
| |
| class OptionMenu(TixWidget): |
| """OptionMenu - Option menu widget. |
| |
| Subwidget Class |
| --------- ----- |
| menubutton Menubutton |
| menu Menu""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixOptionMenu', ['options'], cnf, kw) |
| self.subwidget_list['menubutton'] = _dummyMenubutton(self, 'menubutton') |
| self.subwidget_list['menu'] = _dummyMenu(self, 'menu') |
| |
| def add_command(self, name, cnf={}, **kw): |
| apply(self.tk.call, |
| (self._w, 'add', 'command', name) + self._options(cnf, kw)) |
| |
| def add_separator(self, name, cnf={}, **kw): |
| apply(self.tk.call, |
| (self._w, 'add', 'separator', name) + self._options(cnf, kw)) |
| |
| def delete(self, name): |
| self.tk.call(self._w, 'delete', name) |
| |
| def disable(self, name): |
| self.tk.call(self._w, 'disable', name) |
| |
| def enable(self, name): |
| self.tk.call(self._w, 'enable', name) |
| |
| class PanedWindow(TixWidget): |
| """PanedWindow - Multi-pane container widget. Panes are resizable. |
| |
| Subwidgets Class |
| ---------- ----- |
| <panes> g/p widgets added dynamically""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixPanedWindow', ['orientation', 'options'], cnf, kw) |
| |
| def add(self, name, cnf={}, **kw): |
| apply(self.tk.call, |
| (self._w, 'add', name) + self._options(cnf, kw)) |
| self.subwidget_list[name] = TixSubWidget(self, name, |
| check_intermediate=0) |
| return self.subwidget_list[name] |
| |
| def panes(self): |
| names = self.tk.call(self._w, 'panes') |
| ret = [] |
| for x in names: |
| ret.append(self.subwidget(x)) |
| return ret |
| |
| class PopupMenu(TixWidget): |
| """PopupMenu widget. |
| |
| Subwidgets Class |
| ---------- ----- |
| menubutton Menubutton |
| menu Menu""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixPopupMenu', ['options'], cnf, kw) |
| self.subwidget_list['menubutton'] = _dummyMenubutton(self, 'menubutton') |
| self.subwidget_list['menu'] = _dummyMenu(self, 'menu') |
| |
| def bind_widget(self, widget): |
| self.tk.call(self._w, 'bind', widget._w) |
| |
| def unbind_widget(self, widget): |
| self.tk.call(self._w, 'unbind', widget._w) |
| |
| def post_widget(self, widget, x, y): |
| self.tk.call(self._w, 'post', widget._w, x, y) |
| |
| class ResizeHandle(TixWidget): |
| """Incomplete - no documentation in Tix for this !!!""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixResizeHandle', |
| ['options'], cnf, kw) |
| |
| def attach_widget(self, widget): |
| self.tk.call(self._w, 'attachwidget', widget._w) |
| |
| class ScrolledHList(TixWidget): |
| """ScrolledHList - HList with scrollbars.""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixScrolledHList', ['options'], |
| cnf, kw) |
| self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') |
| self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') |
| self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') |
| |
| class ScrolledListBox(TixWidget): |
| """ScrolledListBox - Listbox with scrollbars.""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixScrolledListBox', ['options'], cnf, kw) |
| self.subwidget_list['listbox'] = _dummyListbox(self, 'listbox') |
| self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') |
| self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') |
| |
| class ScrolledText(TixWidget): |
| """ScrolledText - Text with scrollbars.""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixScrolledText', ['options'], cnf, kw) |
| self.subwidget_list['text'] = _dummyText(self, 'text') |
| self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') |
| self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') |
| |
| class ScrolledTList(TixWidget): |
| """ScrolledTList - TList with scrollbars.""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixScrolledTList', ['options'], |
| cnf, kw) |
| self.subwidget_list['tlist'] = _dummyTList(self, 'tlist') |
| self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') |
| self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') |
| |
| class ScrolledWindow(TixWidget): |
| """ScrolledWindow - Window with scrollbars.""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixScrolledWindow', ['options'], cnf, kw) |
| self.subwidget_list['window'] = _dummyFrame(self, 'window') |
| self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') |
| self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') |
| |
| class Select(TixWidget): |
| """Select - Container for buttons. Can enforce radio buttons etc. |
| |
| Subwidgets are buttons added dynamically""" |
| |
| def __init__(self, master, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixSelect', |
| ['allowzero', 'radio', 'orientation', 'labelside', |
| 'options'], |
| cnf, kw) |
| self.subwidget_list['label'] = _dummyLabel(self, 'label') |
| |
| def add(self, name, cnf={}, **kw): |
| apply(self.tk.call, |
| (self._w, 'add', name) + self._options(cnf, kw)) |
| self.subwidget_list[name] = _dummyButton(self, name) |
| return self.subwidget_list[name] |
| |
| def invoke(self, name): |
| self.tk.call(self._w, 'invoke', name) |
| |
| class StdButtonBox(TixWidget): |
| """StdButtonBox - Standard Button Box (OK, Apply, Cancel and Help) """ |
| |
| def __init__(self, master=None, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixStdButtonBox', |
| ['orientation', 'options'], cnf, kw) |
| self.subwidget_list['ok'] = _dummyButton(self, 'ok') |
| self.subwidget_list['apply'] = _dummyButton(self, 'apply') |
| self.subwidget_list['cancel'] = _dummyButton(self, 'cancel') |
| self.subwidget_list['help'] = _dummyButton(self, 'help') |
| |
| def invoke(self, name): |
| if self.subwidget_list.has_key(name): |
| self.tk.call(self._w, 'invoke', name) |
| |
| class TList(TixWidget): |
| """TList - Hierarchy display. |
| |
| Subwidgets - None""" |
| |
| def __init__ (self,master=None,cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixTList', ['options'], cnf, kw) |
| |
| def active_set(self, index): |
| self.tk.call(self._w, 'active', 'set', index) |
| |
| def active_clear(self): |
| self.tk.call(self._w, 'active', 'clear') |
| |
| def anchor_set(self, index): |
| self.tk.call(self._w, 'anchor', 'set', index) |
| |
| def anchor_clear(self): |
| self.tk.call(self._w, 'anchor', 'clear') |
| |
| def delete(self, from_, to=None): |
| self.tk.call(self._w, 'delete', from_, to) |
| |
| def dragsite_set(self, index): |
| self.tk.call(self._w, 'dragsite', 'set', index) |
| |
| def dragsite_clear(self): |
| self.tk.call(self._w, 'dragsite', 'clear') |
| |
| def dropsite_set(self, index): |
| self.tk.call(self._w, 'dropsite', 'set', index) |
| |
| def dropsite_clear(self): |
| self.tk.call(self._w, 'dropsite', 'clear') |
| |
| def insert(self, index, cnf={}, **kw): |
| apply(self.tk.call, |
| (self._w, 'insert', index) + self._options(cnf, kw)) |
| |
| def info_active(self): |
| return self.tk.call(self._w, 'info', 'active') |
| |
| def info_anchor(self): |
| return self.tk.call(self._w, 'info', 'anchor') |
| |
| def info_down(self, index): |
| return self.tk.call(self._w, 'info', 'down', index) |
| |
| def info_left(self, index): |
| return self.tk.call(self._w, 'info', 'left', index) |
| |
| def info_right(self, index): |
| return self.tk.call(self._w, 'info', 'right', index) |
| |
| def info_selection(self): |
| c = self.tk.call(self._w, 'info', 'selection') |
| return self.tk.splitlist(c) |
| |
| def info_size(self): |
| return self.tk.call(self._w, 'info', 'size') |
| |
| def info_up(self, index): |
| return self.tk.call(self._w, 'info', 'up', index) |
| |
| def nearest(self, x, y): |
| return self.tk.call(self._w, 'nearest', x, y) |
| |
| def see(self, index): |
| self.tk.call(self._w, 'see', index) |
| |
| def selection_clear(self, cnf={}, **kw): |
| apply(self.tk.call, |
| (self._w, 'selection', 'clear') + self._options(cnf, kw)) |
| |
| def selection_includes(self, index): |
| return self.tk.call(self._w, 'selection', 'includes', index) |
| |
| def selection_set(self, first, last=None): |
| self.tk.call(self._w, 'selection', 'set', first, last) |
| |
| def xview(self, *args): |
| apply(self.tk.call, (self._w, 'xview') + args) |
| |
| def yview(self, *args): |
| apply(self.tk.call, (self._w, 'yview') + args) |
| |
| class Tree(TixWidget): |
| """Tree - The tixTree widget (general purpose DirList like widget)""" |
| |
| def __init__(self, master=None, cnf={}, **kw): |
| TixWidget.__init__(self, master, 'tixTree', |
| ['options'], cnf, kw) |
| self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') |
| self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') |
| self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') |
| |
| def autosetmode(self): |
| self.tk.call(self._w, 'autosetmode') |
| |
| def close(self, entrypath): |
| self.tk.call(self._w, 'close', entrypath) |
| |
| def getmode(self, entrypath): |
| return self.tk.call(self._w, 'getmode', entrypath) |
| |
| def open(self, entrypath): |
| self.tk.call(self._w, 'open', entrypath) |
| |
| def setmode(self, entrypath, mode='none'): |
| self.tk.call(self._w, 'setmode', entrypath, mode) |
| |
| ########################################################################### |
| ### The subclassing below is used to instantiate the subwidgets in each ### |
| ### mega widget. This allows us to access their methods directly. ### |
| ########################################################################### |
| |
| class _dummyButton(Button, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| class _dummyCheckbutton(Checkbutton, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| class _dummyEntry(Entry, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| class _dummyFrame(Frame, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| class _dummyLabel(Label, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| class _dummyListbox(Listbox, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| class _dummyMenu(Menu, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| class _dummyMenubutton(Menubutton, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| class _dummyScrollbar(Scrollbar, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| class _dummyText(Text, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| class _dummyScrolledListBox(ScrolledListBox, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| self.subwidget_list['listbox'] = _dummyListbox(self, 'listbox') |
| self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') |
| self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') |
| |
| class _dummyHList(HList, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| class _dummyTList(TList, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| class _dummyComboBox(ComboBox, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| self.subwidget_list['entry'] = _dummyEntry(self, 'entry') |
| self.subwidget_list['arrow'] = _dummyButton(self, 'arrow') |
| self.subwidget_list['slistbox'] = _dummyScrolledListBox(self, |
| 'slistbox') |
| self.subwidget_list['listbox'] = _dummyListbox(self, 'listbox', |
| destroy_physically=0) |
| |
| class _dummyDirList(DirList, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') |
| self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') |
| self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') |
| |
| class _dummyExFileSelectBox(ExFileSelectBox, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| self.subwidget_list['cancel'] = _dummyButton(self, 'cancel') |
| self.subwidget_list['ok'] = _dummyButton(self, 'ok') |
| self.subwidget_list['hidden'] = _dummyCheckbutton(self, 'hidden') |
| self.subwidget_list['types'] = _dummyComboBox(self, 'types') |
| self.subwidget_list['dir'] = _dummyComboBox(self, 'dir') |
| self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist') |
| self.subwidget_list['file'] = _dummyComboBox(self, 'file') |
| self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist') |
| |
| class _dummyFileSelectBox(FileSelectBox, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist') |
| self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist') |
| self.subwidget_list['filter'] = _dummyComboBox(self, 'filter') |
| self.subwidget_list['selection'] = _dummyComboBox(self, 'selection') |
| |
| class _dummyStdButtonBox(StdButtonBox, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=1): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| self.subwidget_list['ok'] = _dummyButton(self, 'ok') |
| self.subwidget_list['apply'] = _dummyButton(self, 'apply') |
| self.subwidget_list['cancel'] = _dummyButton(self, 'cancel') |
| self.subwidget_list['help'] = _dummyButton(self, 'help') |
| |
| class _dummyNoteBookFrame(NoteBookFrame, TixSubWidget): |
| def __init__(self, master, name, destroy_physically=0): |
| TixSubWidget.__init__(self, master, name, destroy_physically) |
| |
| ######################## |
| ### Utility Routines ### |
| ######################## |
| |
| # Returns the qualified path name for the widget. Normally used to set |
| # default options for subwidgets. See tixwidgets.py |
| def OptionName(widget): |
| return widget.tk.call('tixOptionName', widget._w) |
| |
| # Called with a dictionary argument of the form |
| # {'*.c':'C source files', '*.txt':'Text Files', '*':'All files'} |
| # returns a string which can be used to configure the fsbox file types |
| # in an ExFileSelectBox. i.e., |
| # '{{*} {* - All files}} {{*.c} {*.c - C source files}} {{*.txt} {*.txt - Text Files}}' |
| def FileTypeList(dict): |
| s = '' |
| for type in dict.keys(): |
| s = s + '{{' + type + '} {' + type + ' - ' + dict[type] + '}} ' |
| return s |
| |