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