1 """Wrapper functions for Tcl/Tk.
3 Tkinter provides classes which allow the display, positioning and
4 control of widgets. Toplevel widgets are Tk and Toplevel. Other
5 widgets are Frame, Label, Entry, Text, Canvas, Button, Radiobutton,
6 Checkbutton, Scale, Listbox, Scrollbar, OptionMenu, Spinbox
7 LabelFrame and PanedWindow.
9 Properties of the widgets are specified with keyword arguments.
10 Keyword arguments have the same name as the corresponding resource
13 Widgets are positioned with one of the geometry managers Place, Pack
14 or Grid. These managers can be called with methods place, pack, grid
15 available in every Widget.
17 Actions are bound to events by resources (e.g. keyword argument
18 command) or with the method bind.
20 Example (Hello, World):
22 from Tkconstants import *
24 frame = Tkinter.Frame(tk, relief=RIDGE, borderwidth=2)
25 frame.pack(fill=BOTH,expand=1)
26 label = Tkinter.Label(frame, text="Hello, World")
27 label.pack(fill=X, expand=1)
28 button = Tkinter.Button(frame,text="Exit",command=tk.destroy)
29 button.pack(side=BOTTOM)
33 __version__
= "$Revision$"
36 if sys
.platform
== "win32":
37 # Attempt to configure Tcl/Tk without requiring PATH
39 import _tkinter
# If this fails your Python may not be configured for Tk
40 tkinter
= _tkinter
# b/w compat for export
41 TclError
= _tkinter
.TclError
43 from Tkconstants
import *
47 TkVersion
= float(_tkinter
.TK_VERSION
)
48 TclVersion
= float(_tkinter
.TCL_VERSION
)
50 READABLE
= _tkinter
.READABLE
51 WRITABLE
= _tkinter
.WRITABLE
52 EXCEPTION
= _tkinter
.EXCEPTION
54 # These are not always defined, e.g. not on Win32 with Tk 8.0 :-(
55 try: _tkinter
.createfilehandler
56 except AttributeError: _tkinter
.createfilehandler
= None
57 try: _tkinter
.deletefilehandler
58 except AttributeError: _tkinter
.deletefilehandler
= None
62 """Internal function."""
65 if type(item
) in (TupleType
, ListType
):
66 res
= res
+ _flatten(item
)
67 elif item
is not None:
71 try: _flatten
= _tkinter
._flatten
72 except AttributeError: pass
75 """Internal function."""
76 if type(cnfs
) is DictionaryType
:
78 elif type(cnfs
) in (NoneType
, StringType
):
82 for c
in _flatten(cnfs
):
85 except (AttributeError, TypeError), msg
:
86 print "_cnfmerge: fallback due to:", msg
87 for k
, v
in c
.items():
91 try: _cnfmerge
= _tkinter
._cnfmerge
92 except AttributeError: pass
95 """Container for the properties of an event.
97 Instances of this type are generated if one of the following events occurs:
99 KeyPress, KeyRelease - for keyboard events
100 ButtonPress, ButtonRelease, Motion, Enter, Leave, MouseWheel - for mouse events
101 Visibility, Unmap, Map, Expose, FocusIn, FocusOut, Circulate,
102 Colormap, Gravity, Reparent, Property, Destroy, Activate,
103 Deactivate - for window events.
105 If a callback function for one of these events is registered
106 using bind, bind_all, bind_class, or tag_bind, the callback is
107 called with an Event as first argument. It will have the
108 following attributes (in braces are the event types for which
109 the attribute is valid):
111 serial - serial number of event
112 num - mouse button pressed (ButtonPress, ButtonRelease)
113 focus - whether the window has the focus (Enter, Leave)
114 height - height of the exposed window (Configure, Expose)
115 width - width of the exposed window (Configure, Expose)
116 keycode - keycode of the pressed key (KeyPress, KeyRelease)
117 state - state of the event as a number (ButtonPress, ButtonRelease,
118 Enter, KeyPress, KeyRelease,
120 state - state as a string (Visibility)
121 time - when the event occurred
122 x - x-position of the mouse
123 y - y-position of the mouse
124 x_root - x-position of the mouse on the screen
125 (ButtonPress, ButtonRelease, KeyPress, KeyRelease, Motion)
126 y_root - y-position of the mouse on the screen
127 (ButtonPress, ButtonRelease, KeyPress, KeyRelease, Motion)
128 char - pressed character (KeyPress, KeyRelease)
129 send_event - see X/Windows documentation
130 keysym - keysym of the event as a string (KeyPress, KeyRelease)
131 keysym_num - keysym of the event as a number (KeyPress, KeyRelease)
132 type - type of the event as a number
133 widget - widget in which the event occurred
134 delta - delta of wheel movement (MouseWheel)
138 _support_default_root
= 1
142 """Inhibit setting of default root window.
144 Call this function to inhibit that the first instance of
145 Tk is used for windows without an explicit parent window.
147 global _support_default_root
148 _support_default_root
= 0
154 """Internal function."""
158 """Internal function. Calling it will throw the exception SystemExit."""
159 raise SystemExit, code
163 """Class to define value holders for e.g. buttons.
165 Subclasses StringVar, IntVar, DoubleVar, BooleanVar are specializations
166 that constrain the type of the value returned from get()."""
168 def __init__(self
, master
=None, value
=None, name
=None):
169 """Construct a variable
171 MASTER can be given as master widget.
172 VALUE is an optional value (defaults to "")
173 NAME is an optional Tcl name (defaults to PY_VARnum).
175 If NAME matches an existing variable and VALUE is omitted
176 then the existing value is retained.
180 master
= _default_root
181 self
._master
= master
186 self
._name
= 'PY_VAR' + repr(_varnum
)
188 if value
is not None:
190 elif not self
._tk
.call("info", "exists", self
._name
):
191 self
.set(self
._default
)
193 """Unset the variable in Tcl."""
194 self
._tk
.globalunsetvar(self
._name
)
196 """Return the name of the variable in Tcl."""
198 def set(self
, value
):
199 """Set the variable to VALUE."""
200 return self
._tk
.globalsetvar(self
._name
, value
)
202 """Return value of variable."""
203 return self
._tk
.globalgetvar(self
._name
)
204 def trace_variable(self
, mode
, callback
):
205 """Define a trace callback for the variable.
207 MODE is one of "r", "w", "u" for read, write, undefine.
208 CALLBACK must be a function which is called when
209 the variable is read, written or undefined.
211 Return the name of the callback.
213 cbname
= self
._master
._register
(callback
)
214 self
._tk
.call("trace", "variable", self
._name
, mode
, cbname
)
216 trace
= trace_variable
217 def trace_vdelete(self
, mode
, cbname
):
218 """Delete the trace callback for a variable.
220 MODE is one of "r", "w", "u" for read, write, undefine.
221 CBNAME is the name of the callback returned from trace_variable or trace.
223 self
._tk
.call("trace", "vdelete", self
._name
, mode
, cbname
)
224 self
._master
.deletecommand(cbname
)
225 def trace_vinfo(self
):
226 """Return all trace callback information."""
227 return map(self
._tk
.split
, self
._tk
.splitlist(
228 self
._tk
.call("trace", "vinfo", self
._name
)))
229 def __eq__(self
, other
):
230 """Comparison for equality (==).
232 Note: if the Variable's master matters to behavior
233 also compare self._master == other._master
235 return self
.__class
__.__name
__ == other
.__class
__.__name
__ \
236 and self
._name
== other
._name
238 class StringVar(Variable
):
239 """Value holder for strings variables."""
241 def __init__(self
, master
=None, value
=None, name
=None):
242 """Construct a string variable.
244 MASTER can be given as master widget.
245 VALUE is an optional value (defaults to "")
246 NAME is an optional Tcl name (defaults to PY_VARnum).
248 If NAME matches an existing variable and VALUE is omitted
249 then the existing value is retained.
251 Variable
.__init
__(self
, master
, value
, name
)
254 """Return value of variable as string."""
255 value
= self
._tk
.globalgetvar(self
._name
)
256 if isinstance(value
, basestring
):
260 class IntVar(Variable
):
261 """Value holder for integer variables."""
263 def __init__(self
, master
=None, value
=None, name
=None):
264 """Construct an integer variable.
266 MASTER can be given as master widget.
267 VALUE is an optional value (defaults to 0)
268 NAME is an optional Tcl name (defaults to PY_VARnum).
270 If NAME matches an existing variable and VALUE is omitted
271 then the existing value is retained.
273 Variable
.__init
__(self
, master
, value
, name
)
275 def set(self
, value
):
276 """Set the variable to value, converting booleans to integers."""
277 if isinstance(value
, bool):
279 return Variable
.set(self
, value
)
282 """Return the value of the variable as an integer."""
283 return getint(self
._tk
.globalgetvar(self
._name
))
285 class DoubleVar(Variable
):
286 """Value holder for float variables."""
288 def __init__(self
, master
=None, value
=None, name
=None):
289 """Construct a float variable.
291 MASTER can be given as master widget.
292 VALUE is an optional value (defaults to 0.0)
293 NAME is an optional Tcl name (defaults to PY_VARnum).
295 If NAME matches an existing variable and VALUE is omitted
296 then the existing value is retained.
298 Variable
.__init
__(self
, master
, value
, name
)
301 """Return the value of the variable as a float."""
302 return getdouble(self
._tk
.globalgetvar(self
._name
))
304 class BooleanVar(Variable
):
305 """Value holder for boolean variables."""
307 def __init__(self
, master
=None, value
=None, name
=None):
308 """Construct a boolean variable.
310 MASTER can be given as master widget.
311 VALUE is an optional value (defaults to False)
312 NAME is an optional Tcl name (defaults to PY_VARnum).
314 If NAME matches an existing variable and VALUE is omitted
315 then the existing value is retained.
317 Variable
.__init
__(self
, master
, value
, name
)
320 """Return the value of the variable as a bool."""
321 return self
._tk
.getboolean(self
._tk
.globalgetvar(self
._name
))
324 """Run the main loop of Tcl."""
325 _default_root
.tk
.mainloop(n
)
332 """Convert true and false to integer values 1 and 0."""
333 return _default_root
.tk
.getboolean(s
)
335 # Methods defined on both toplevel and interior widgets
339 Base class which defines methods common for interior widgets."""
344 """Internal function.
346 Delete all Tcl commands created for
347 this widget in the Tcl interpreter."""
348 if self
._tclCommands
is not None:
349 for name
in self
._tclCommands
:
350 #print '- Tkinter: deleted command', name
351 self
.tk
.deletecommand(name
)
352 self
._tclCommands
= None
353 def deletecommand(self
, name
):
354 """Internal function.
356 Delete the Tcl command provided in NAME."""
357 #print '- Tkinter: deleted command', name
358 self
.tk
.deletecommand(name
)
360 self
._tclCommands
.remove(name
)
363 def tk_strictMotif(self
, boolean
=None):
364 """Set Tcl internal variable, whether the look and feel
365 should adhere to Motif.
367 A parameter of 1 means adhere to Motif (e.g. no color
368 change if mouse passes over slider).
369 Returns the set value."""
370 return self
.tk
.getboolean(self
.tk
.call(
371 'set', 'tk_strictMotif', boolean
))
373 """Change the color scheme to light brown as used in Tk 3.6 and before."""
374 self
.tk
.call('tk_bisque')
375 def tk_setPalette(self
, *args
, **kw
):
376 """Set a new color scheme for all widget elements.
378 A single color as argument will cause that all colors of Tk
379 widget elements are derived from this.
380 Alternatively several keyword parameters and its associated
381 colors can be given. The following keywords are valid:
382 activeBackground, foreground, selectColor,
383 activeForeground, highlightBackground, selectBackground,
384 background, highlightColor, selectForeground,
385 disabledForeground, insertBackground, troughColor."""
386 self
.tk
.call(('tk_setPalette',)
387 + _flatten(args
) + _flatten(kw
.items()))
388 def tk_menuBar(self
, *args
):
389 """Do not use. Needed in Tk 3.6 and earlier."""
390 pass # obsolete since Tk 4.0
391 def wait_variable(self
, name
='PY_VAR'):
392 """Wait until the variable is modified.
394 A parameter of type IntVar, StringVar, DoubleVar or
395 BooleanVar must be given."""
396 self
.tk
.call('tkwait', 'variable', name
)
397 waitvar
= wait_variable
# XXX b/w compat
398 def wait_window(self
, window
=None):
399 """Wait until a WIDGET is destroyed.
401 If no parameter is given self is used."""
404 self
.tk
.call('tkwait', 'window', window
._w
)
405 def wait_visibility(self
, window
=None):
406 """Wait until the visibility of a WIDGET changes
409 If no parameter is given self is used."""
412 self
.tk
.call('tkwait', 'visibility', window
._w
)
413 def setvar(self
, name
='PY_VAR', value
='1'):
414 """Set Tcl variable NAME to VALUE."""
415 self
.tk
.setvar(name
, value
)
416 def getvar(self
, name
='PY_VAR'):
417 """Return value of Tcl variable NAME."""
418 return self
.tk
.getvar(name
)
421 def getboolean(self
, s
):
422 """Return a boolean value for Tcl boolean values true and false given as parameter."""
423 return self
.tk
.getboolean(s
)
425 """Direct input focus to this widget.
427 If the application currently does not have the focus
428 this widget will get the focus if the application gets
429 the focus through the window manager."""
430 self
.tk
.call('focus', self
._w
)
431 focus
= focus_set
# XXX b/w compat?
432 def focus_force(self
):
433 """Direct input focus to this widget even if the
434 application does not have the focus. Use with
436 self
.tk
.call('focus', '-force', self
._w
)
438 """Return the widget which has currently the focus in the
441 Use focus_displayof to allow working with several
442 displays. Return None if application does not have
444 name
= self
.tk
.call('focus')
445 if name
== 'none' or not name
: return None
446 return self
._nametowidget
(name
)
447 def focus_displayof(self
):
448 """Return the widget which has currently the focus on the
449 display where this widget is located.
451 Return None if the application does not have the focus."""
452 name
= self
.tk
.call('focus', '-displayof', self
._w
)
453 if name
== 'none' or not name
: return None
454 return self
._nametowidget
(name
)
455 def focus_lastfor(self
):
456 """Return the widget which would have the focus if top level
457 for this widget gets the focus from the window manager."""
458 name
= self
.tk
.call('focus', '-lastfor', self
._w
)
459 if name
== 'none' or not name
: return None
460 return self
._nametowidget
(name
)
461 def tk_focusFollowsMouse(self
):
462 """The widget under mouse will get automatically focus. Can not
463 be disabled easily."""
464 self
.tk
.call('tk_focusFollowsMouse')
465 def tk_focusNext(self
):
466 """Return the next widget in the focus order which follows
467 widget which has currently the focus.
469 The focus order first goes to the next child, then to
470 the children of the child recursively and then to the
471 next sibling which is higher in the stacking order. A
472 widget is omitted if it has the takefocus resource set
474 name
= self
.tk
.call('tk_focusNext', self
._w
)
475 if not name
: return None
476 return self
._nametowidget
(name
)
477 def tk_focusPrev(self
):
478 """Return previous widget in the focus order. See tk_focusNext for details."""
479 name
= self
.tk
.call('tk_focusPrev', self
._w
)
480 if not name
: return None
481 return self
._nametowidget
(name
)
482 def after(self
, ms
, func
=None, *args
):
483 """Call function once after given time.
485 MS specifies the time in milliseconds. FUNC gives the
486 function which shall be called. Additional parameters
487 are given as parameters to the function call. Return
488 identifier to cancel scheduling with after_cancel."""
490 # I'd rather use time.sleep(ms*0.001)
491 self
.tk
.call('after', ms
)
498 self
.deletecommand(name
)
501 name
= self
._register
(callit
)
502 return self
.tk
.call('after', ms
, name
)
503 def after_idle(self
, func
, *args
):
504 """Call FUNC once if the Tcl main loop has no event to
507 Return an identifier to cancel the scheduling with
509 return self
.after('idle', func
, *args
)
510 def after_cancel(self
, id):
511 """Cancel scheduling of function identified with ID.
513 Identifier returned by after or after_idle must be
514 given as first parameter."""
516 data
= self
.tk
.call('after', 'info', id)
517 # In Tk 8.3, splitlist returns: (script, type)
518 # In Tk 8.4, splitlist may return (script, type) or (script,)
519 script
= self
.tk
.splitlist(data
)[0]
520 self
.deletecommand(script
)
523 self
.tk
.call('after', 'cancel', id)
524 def bell(self
, displayof
=0):
525 """Ring a display's bell."""
526 self
.tk
.call(('bell',) + self
._displayof
(displayof
))
528 # Clipboard handling:
529 def clipboard_get(self
, **kw
):
530 """Retrieve data from the clipboard on window's display.
532 The window keyword defaults to the root window of the Tkinter
535 The type keyword specifies the form in which the data is
536 to be returned and should be an atom name such as STRING
537 or FILE_NAME. Type defaults to STRING.
539 This command is equivalent to:
541 selection_get(CLIPBOARD)
543 return self
.tk
.call(('clipboard', 'get') + self
._options
(kw
))
545 def clipboard_clear(self
, **kw
):
546 """Clear the data in the Tk clipboard.
548 A widget specified for the optional displayof keyword
549 argument specifies the target display."""
550 if not kw
.has_key('displayof'): kw
['displayof'] = self
._w
551 self
.tk
.call(('clipboard', 'clear') + self
._options
(kw
))
552 def clipboard_append(self
, string
, **kw
):
553 """Append STRING to the Tk clipboard.
555 A widget specified at the optional displayof keyword
556 argument specifies the target display. The clipboard
557 can be retrieved with selection_get."""
558 if not kw
.has_key('displayof'): kw
['displayof'] = self
._w
559 self
.tk
.call(('clipboard', 'append') + self
._options
(kw
)
561 # XXX grab current w/o window argument
562 def grab_current(self
):
563 """Return widget which has currently the grab in this application
565 name
= self
.tk
.call('grab', 'current', self
._w
)
566 if not name
: return None
567 return self
._nametowidget
(name
)
568 def grab_release(self
):
569 """Release grab for this widget if currently set."""
570 self
.tk
.call('grab', 'release', self
._w
)
572 """Set grab for this widget.
574 A grab directs all events to this and descendant
575 widgets in the application."""
576 self
.tk
.call('grab', 'set', self
._w
)
577 def grab_set_global(self
):
578 """Set global grab for this widget.
580 A global grab directs all events to this and
581 descendant widgets on the display. Use with caution -
582 other applications do not get events anymore."""
583 self
.tk
.call('grab', 'set', '-global', self
._w
)
584 def grab_status(self
):
585 """Return None, "local" or "global" if this widget has
586 no, a local or a global grab."""
587 status
= self
.tk
.call('grab', 'status', self
._w
)
588 if status
== 'none': status
= None
590 def option_add(self
, pattern
, value
, priority
= None):
591 """Set a VALUE (second parameter) for an option
592 PATTERN (first parameter).
594 An optional third parameter gives the numeric priority
596 self
.tk
.call('option', 'add', pattern
, value
, priority
)
597 def option_clear(self
):
598 """Clear the option database.
600 It will be reloaded if option_add is called."""
601 self
.tk
.call('option', 'clear')
602 def option_get(self
, name
, className
):
603 """Return the value for an option NAME for this widget
606 Values with higher priority override lower values."""
607 return self
.tk
.call('option', 'get', self
._w
, name
, className
)
608 def option_readfile(self
, fileName
, priority
= None):
609 """Read file FILENAME into the option database.
611 An optional second parameter gives the numeric
613 self
.tk
.call('option', 'readfile', fileName
, priority
)
614 def selection_clear(self
, **kw
):
615 """Clear the current X selection."""
616 if not kw
.has_key('displayof'): kw
['displayof'] = self
._w
617 self
.tk
.call(('selection', 'clear') + self
._options
(kw
))
618 def selection_get(self
, **kw
):
619 """Return the contents of the current X selection.
621 A keyword parameter selection specifies the name of
622 the selection and defaults to PRIMARY. A keyword
623 parameter displayof specifies a widget on the display
625 if not kw
.has_key('displayof'): kw
['displayof'] = self
._w
626 return self
.tk
.call(('selection', 'get') + self
._options
(kw
))
627 def selection_handle(self
, command
, **kw
):
628 """Specify a function COMMAND to call if the X
629 selection owned by this widget is queried by another
632 This function must return the contents of the
633 selection. The function will be called with the
634 arguments OFFSET and LENGTH which allows the chunking
635 of very long selections. The following keyword
636 parameters can be provided:
637 selection - name of the selection (default PRIMARY),
638 type - type of the selection (e.g. STRING, FILE_NAME)."""
639 name
= self
._register
(command
)
640 self
.tk
.call(('selection', 'handle') + self
._options
(kw
)
642 def selection_own(self
, **kw
):
643 """Become owner of X selection.
645 A keyword parameter selection specifies the name of
646 the selection (default PRIMARY)."""
647 self
.tk
.call(('selection', 'own') +
648 self
._options
(kw
) + (self
._w
,))
649 def selection_own_get(self
, **kw
):
650 """Return owner of X selection.
652 The following keyword parameter can
654 selection - name of the selection (default PRIMARY),
655 type - type of the selection (e.g. STRING, FILE_NAME)."""
656 if not kw
.has_key('displayof'): kw
['displayof'] = self
._w
657 name
= self
.tk
.call(('selection', 'own') + self
._options
(kw
))
658 if not name
: return None
659 return self
._nametowidget
(name
)
660 def send(self
, interp
, cmd
, *args
):
661 """Send Tcl command CMD to different interpreter INTERP to be executed."""
662 return self
.tk
.call(('send', interp
, cmd
) + args
)
663 def lower(self
, belowThis
=None):
664 """Lower this widget in the stacking order."""
665 self
.tk
.call('lower', self
._w
, belowThis
)
666 def tkraise(self
, aboveThis
=None):
667 """Raise this widget in the stacking order."""
668 self
.tk
.call('raise', self
._w
, aboveThis
)
670 def colormodel(self
, value
=None):
671 """Useless. Not implemented in Tk."""
672 return self
.tk
.call('tk', 'colormodel', self
._w
, value
)
673 def winfo_atom(self
, name
, displayof
=0):
674 """Return integer which represents atom NAME."""
675 args
= ('winfo', 'atom') + self
._displayof
(displayof
) + (name
,)
676 return getint(self
.tk
.call(args
))
677 def winfo_atomname(self
, id, displayof
=0):
678 """Return name of atom with identifier ID."""
679 args
= ('winfo', 'atomname') \
680 + self
._displayof
(displayof
) + (id,)
681 return self
.tk
.call(args
)
682 def winfo_cells(self
):
683 """Return number of cells in the colormap for this widget."""
685 self
.tk
.call('winfo', 'cells', self
._w
))
686 def winfo_children(self
):
687 """Return a list of all widgets which are children of this widget."""
689 for child
in self
.tk
.splitlist(
690 self
.tk
.call('winfo', 'children', self
._w
)):
692 # Tcl sometimes returns extra windows, e.g. for
693 # menus; those need to be skipped
694 result
.append(self
._nametowidget
(child
))
699 def winfo_class(self
):
700 """Return window class name of this widget."""
701 return self
.tk
.call('winfo', 'class', self
._w
)
702 def winfo_colormapfull(self
):
703 """Return true if at the last color request the colormap was full."""
704 return self
.tk
.getboolean(
705 self
.tk
.call('winfo', 'colormapfull', self
._w
))
706 def winfo_containing(self
, rootX
, rootY
, displayof
=0):
707 """Return the widget which is at the root coordinates ROOTX, ROOTY."""
708 args
= ('winfo', 'containing') \
709 + self
._displayof
(displayof
) + (rootX
, rootY
)
710 name
= self
.tk
.call(args
)
711 if not name
: return None
712 return self
._nametowidget
(name
)
713 def winfo_depth(self
):
714 """Return the number of bits per pixel."""
715 return getint(self
.tk
.call('winfo', 'depth', self
._w
))
716 def winfo_exists(self
):
717 """Return true if this widget exists."""
719 self
.tk
.call('winfo', 'exists', self
._w
))
720 def winfo_fpixels(self
, number
):
721 """Return the number of pixels for the given distance NUMBER
722 (e.g. "3c") as float."""
723 return getdouble(self
.tk
.call(
724 'winfo', 'fpixels', self
._w
, number
))
725 def winfo_geometry(self
):
726 """Return geometry string for this widget in the form "widthxheight+X+Y"."""
727 return self
.tk
.call('winfo', 'geometry', self
._w
)
728 def winfo_height(self
):
729 """Return height of this widget."""
731 self
.tk
.call('winfo', 'height', self
._w
))
733 """Return identifier ID for this widget."""
734 return self
.tk
.getint(
735 self
.tk
.call('winfo', 'id', self
._w
))
736 def winfo_interps(self
, displayof
=0):
737 """Return the name of all Tcl interpreters for this display."""
738 args
= ('winfo', 'interps') + self
._displayof
(displayof
)
739 return self
.tk
.splitlist(self
.tk
.call(args
))
740 def winfo_ismapped(self
):
741 """Return true if this widget is mapped."""
743 self
.tk
.call('winfo', 'ismapped', self
._w
))
744 def winfo_manager(self
):
745 """Return the window mananger name for this widget."""
746 return self
.tk
.call('winfo', 'manager', self
._w
)
747 def winfo_name(self
):
748 """Return the name of this widget."""
749 return self
.tk
.call('winfo', 'name', self
._w
)
750 def winfo_parent(self
):
751 """Return the name of the parent of this widget."""
752 return self
.tk
.call('winfo', 'parent', self
._w
)
753 def winfo_pathname(self
, id, displayof
=0):
754 """Return the pathname of the widget given by ID."""
755 args
= ('winfo', 'pathname') \
756 + self
._displayof
(displayof
) + (id,)
757 return self
.tk
.call(args
)
758 def winfo_pixels(self
, number
):
759 """Rounded integer value of winfo_fpixels."""
761 self
.tk
.call('winfo', 'pixels', self
._w
, number
))
762 def winfo_pointerx(self
):
763 """Return the x coordinate of the pointer on the root window."""
765 self
.tk
.call('winfo', 'pointerx', self
._w
))
766 def winfo_pointerxy(self
):
767 """Return a tuple of x and y coordinates of the pointer on the root window."""
768 return self
._getints
(
769 self
.tk
.call('winfo', 'pointerxy', self
._w
))
770 def winfo_pointery(self
):
771 """Return the y coordinate of the pointer on the root window."""
773 self
.tk
.call('winfo', 'pointery', self
._w
))
774 def winfo_reqheight(self
):
775 """Return requested height of this widget."""
777 self
.tk
.call('winfo', 'reqheight', self
._w
))
778 def winfo_reqwidth(self
):
779 """Return requested width of this widget."""
781 self
.tk
.call('winfo', 'reqwidth', self
._w
))
782 def winfo_rgb(self
, color
):
783 """Return tuple of decimal values for red, green, blue for
784 COLOR in this widget."""
785 return self
._getints
(
786 self
.tk
.call('winfo', 'rgb', self
._w
, color
))
787 def winfo_rootx(self
):
788 """Return x coordinate of upper left corner of this widget on the
791 self
.tk
.call('winfo', 'rootx', self
._w
))
792 def winfo_rooty(self
):
793 """Return y coordinate of upper left corner of this widget on the
796 self
.tk
.call('winfo', 'rooty', self
._w
))
797 def winfo_screen(self
):
798 """Return the screen name of this widget."""
799 return self
.tk
.call('winfo', 'screen', self
._w
)
800 def winfo_screencells(self
):
801 """Return the number of the cells in the colormap of the screen
804 self
.tk
.call('winfo', 'screencells', self
._w
))
805 def winfo_screendepth(self
):
806 """Return the number of bits per pixel of the root window of the
807 screen of this widget."""
809 self
.tk
.call('winfo', 'screendepth', self
._w
))
810 def winfo_screenheight(self
):
811 """Return the number of pixels of the height of the screen of this widget
814 self
.tk
.call('winfo', 'screenheight', self
._w
))
815 def winfo_screenmmheight(self
):
816 """Return the number of pixels of the height of the screen of
817 this widget in mm."""
819 self
.tk
.call('winfo', 'screenmmheight', self
._w
))
820 def winfo_screenmmwidth(self
):
821 """Return the number of pixels of the width of the screen of
822 this widget in mm."""
824 self
.tk
.call('winfo', 'screenmmwidth', self
._w
))
825 def winfo_screenvisual(self
):
826 """Return one of the strings directcolor, grayscale, pseudocolor,
827 staticcolor, staticgray, or truecolor for the default
828 colormodel of this screen."""
829 return self
.tk
.call('winfo', 'screenvisual', self
._w
)
830 def winfo_screenwidth(self
):
831 """Return the number of pixels of the width of the screen of
832 this widget in pixel."""
834 self
.tk
.call('winfo', 'screenwidth', self
._w
))
835 def winfo_server(self
):
836 """Return information of the X-Server of the screen of this widget in
837 the form "XmajorRminor vendor vendorVersion"."""
838 return self
.tk
.call('winfo', 'server', self
._w
)
839 def winfo_toplevel(self
):
840 """Return the toplevel widget of this widget."""
841 return self
._nametowidget
(self
.tk
.call(
842 'winfo', 'toplevel', self
._w
))
843 def winfo_viewable(self
):
844 """Return true if the widget and all its higher ancestors are mapped."""
846 self
.tk
.call('winfo', 'viewable', self
._w
))
847 def winfo_visual(self
):
848 """Return one of the strings directcolor, grayscale, pseudocolor,
849 staticcolor, staticgray, or truecolor for the
850 colormodel of this widget."""
851 return self
.tk
.call('winfo', 'visual', self
._w
)
852 def winfo_visualid(self
):
853 """Return the X identifier for the visual for this widget."""
854 return self
.tk
.call('winfo', 'visualid', self
._w
)
855 def winfo_visualsavailable(self
, includeids
=0):
856 """Return a list of all visuals available for the screen
859 Each item in the list consists of a visual name (see winfo_visual), a
860 depth and if INCLUDEIDS=1 is given also the X identifier."""
861 data
= self
.tk
.split(
862 self
.tk
.call('winfo', 'visualsavailable', self
._w
,
863 includeids
and 'includeids' or None))
864 if type(data
) is StringType
:
865 data
= [self
.tk
.split(data
)]
866 return map(self
.__winfo
_parseitem
, data
)
867 def __winfo_parseitem(self
, t
):
868 """Internal function."""
869 return t
[:1] + tuple(map(self
.__winfo
_getint
, t
[1:]))
870 def __winfo_getint(self
, x
):
871 """Internal function."""
873 def winfo_vrootheight(self
):
874 """Return the height of the virtual root window associated with this
875 widget in pixels. If there is no virtual root window return the
876 height of the screen."""
878 self
.tk
.call('winfo', 'vrootheight', self
._w
))
879 def winfo_vrootwidth(self
):
880 """Return the width of the virtual root window associated with this
881 widget in pixel. If there is no virtual root window return the
882 width of the screen."""
884 self
.tk
.call('winfo', 'vrootwidth', self
._w
))
885 def winfo_vrootx(self
):
886 """Return the x offset of the virtual root relative to the root
887 window of the screen of this widget."""
889 self
.tk
.call('winfo', 'vrootx', self
._w
))
890 def winfo_vrooty(self
):
891 """Return the y offset of the virtual root relative to the root
892 window of the screen of this widget."""
894 self
.tk
.call('winfo', 'vrooty', self
._w
))
895 def winfo_width(self
):
896 """Return the width of this widget."""
898 self
.tk
.call('winfo', 'width', self
._w
))
900 """Return the x coordinate of the upper left corner of this widget
903 self
.tk
.call('winfo', 'x', self
._w
))
905 """Return the y coordinate of the upper left corner of this widget
908 self
.tk
.call('winfo', 'y', self
._w
))
910 """Enter event loop until all pending events have been processed by Tcl."""
911 self
.tk
.call('update')
912 def update_idletasks(self
):
913 """Enter event loop until all idle callbacks have been called. This
914 will update the display of windows but not process events caused by
916 self
.tk
.call('update', 'idletasks')
917 def bindtags(self
, tagList
=None):
918 """Set or get the list of bindtags for this widget.
920 With no argument return the list of all bindtags associated with
921 this widget. With a list of strings as argument the bindtags are
922 set to this list. The bindtags determine in which order events are
923 processed (see bind)."""
925 return self
.tk
.splitlist(
926 self
.tk
.call('bindtags', self
._w
))
928 self
.tk
.call('bindtags', self
._w
, tagList
)
929 def _bind(self
, what
, sequence
, func
, add
, needcleanup
=1):
930 """Internal function."""
931 if type(func
) is StringType
:
932 self
.tk
.call(what
+ (sequence
, func
))
934 funcid
= self
._register
(func
, self
._substitute
,
936 cmd
= ('%sif {"[%s %s]" == "break"} break\n'
939 funcid
, self
._subst
_format
_str
))
940 self
.tk
.call(what
+ (sequence
, cmd
))
943 return self
.tk
.call(what
+ (sequence
,))
945 return self
.tk
.splitlist(self
.tk
.call(what
))
946 def bind(self
, sequence
=None, func
=None, add
=None):
947 """Bind to this widget at event SEQUENCE a call to function FUNC.
949 SEQUENCE is a string of concatenated event
950 patterns. An event pattern is of the form
951 <MODIFIER-MODIFIER-TYPE-DETAIL> where MODIFIER is one
952 of Control, Mod2, M2, Shift, Mod3, M3, Lock, Mod4, M4,
953 Button1, B1, Mod5, M5 Button2, B2, Meta, M, Button3,
954 B3, Alt, Button4, B4, Double, Button5, B5 Triple,
955 Mod1, M1. TYPE is one of Activate, Enter, Map,
956 ButtonPress, Button, Expose, Motion, ButtonRelease
957 FocusIn, MouseWheel, Circulate, FocusOut, Property,
958 Colormap, Gravity Reparent, Configure, KeyPress, Key,
959 Unmap, Deactivate, KeyRelease Visibility, Destroy,
960 Leave and DETAIL is the button number for ButtonPress,
961 ButtonRelease and DETAIL is the Keysym for KeyPress and
962 KeyRelease. Examples are
963 <Control-Button-1> for pressing Control and mouse button 1 or
964 <Alt-A> for pressing A and the Alt key (KeyPress can be omitted).
965 An event pattern can also be a virtual event of the form
966 <<AString>> where AString can be arbitrary. This
967 event can be generated by event_generate.
968 If events are concatenated they must appear shortly
971 FUNC will be called if the event sequence occurs with an
972 instance of Event as argument. If the return value of FUNC is
973 "break" no further bound function is invoked.
975 An additional boolean parameter ADD specifies whether FUNC will
976 be called additionally to the other bound function or whether
977 it will replace the previous function.
979 Bind will return an identifier to allow deletion of the bound function with
980 unbind without memory leak.
982 If FUNC or SEQUENCE is omitted the bound function or list
983 of bound events are returned."""
985 return self
._bind
(('bind', self
._w
), sequence
, func
, add
)
986 def unbind(self
, sequence
, funcid
=None):
987 """Unbind for this widget for event SEQUENCE the
988 function identified with FUNCID."""
989 self
.tk
.call('bind', self
._w
, sequence
, '')
991 self
.deletecommand(funcid
)
992 def bind_all(self
, sequence
=None, func
=None, add
=None):
993 """Bind to all widgets at an event SEQUENCE a call to function FUNC.
994 An additional boolean parameter ADD specifies whether FUNC will
995 be called additionally to the other bound function or whether
996 it will replace the previous function. See bind for the return value."""
997 return self
._bind
(('bind', 'all'), sequence
, func
, add
, 0)
998 def unbind_all(self
, sequence
):
999 """Unbind for all widgets for event SEQUENCE all functions."""
1000 self
.tk
.call('bind', 'all' , sequence
, '')
1001 def bind_class(self
, className
, sequence
=None, func
=None, add
=None):
1003 """Bind to widgets with bindtag CLASSNAME at event
1004 SEQUENCE a call of function FUNC. An additional
1005 boolean parameter ADD specifies whether FUNC will be
1006 called additionally to the other bound function or
1007 whether it will replace the previous function. See bind for
1008 the return value."""
1010 return self
._bind
(('bind', className
), sequence
, func
, add
, 0)
1011 def unbind_class(self
, className
, sequence
):
1012 """Unbind for a all widgets with bindtag CLASSNAME for event SEQUENCE
1014 self
.tk
.call('bind', className
, sequence
, '')
1015 def mainloop(self
, n
=0):
1016 """Call the mainloop of Tk."""
1019 """Quit the Tcl interpreter. All widgets will be destroyed."""
1021 def _getints(self
, string
):
1022 """Internal function."""
1024 return tuple(map(getint
, self
.tk
.splitlist(string
)))
1025 def _getdoubles(self
, string
):
1026 """Internal function."""
1028 return tuple(map(getdouble
, self
.tk
.splitlist(string
)))
1029 def _getboolean(self
, string
):
1030 """Internal function."""
1032 return self
.tk
.getboolean(string
)
1033 def _displayof(self
, displayof
):
1034 """Internal function."""
1036 return ('-displayof', displayof
)
1037 if displayof
is None:
1038 return ('-displayof', self
._w
)
1040 def _options(self
, cnf
, kw
= None):
1041 """Internal function."""
1043 cnf
= _cnfmerge((cnf
, kw
))
1045 cnf
= _cnfmerge(cnf
)
1047 for k
, v
in cnf
.items():
1049 if k
[-1] == '_': k
= k
[:-1]
1051 v
= self
._register
(v
)
1052 elif isinstance(v
, (tuple, list)):
1055 if not isinstance(item
, (basestring
, int)):
1057 elif isinstance(item
, int):
1058 nv
.append('%d' % item
)
1060 # format it to proper Tcl code if it contains space
1061 nv
.append(('{%s}' if ' ' in item
else '%s') % item
)
1064 res
= res
+ ('-'+k
, v
)
1066 def nametowidget(self
, name
):
1067 """Return the Tkinter instance of a widget identified by
1068 its Tcl name NAME."""
1069 name
= str(name
).split('.')
1082 _nametowidget
= nametowidget
1083 def _register(self
, func
, subst
=None, needcleanup
=1):
1084 """Return a newly created Tcl function. If this
1085 function is called, the Python function FUNC will
1086 be executed. An optional function SUBST can
1087 be given which will be executed before FUNC."""
1088 f
= CallWrapper(func
, subst
, self
).__call
__
1092 except AttributeError:
1095 name
= name
+ func
.__name
__
1096 except AttributeError:
1098 self
.tk
.createcommand(name
, f
)
1100 if self
._tclCommands
is None:
1101 self
._tclCommands
= []
1102 self
._tclCommands
.append(name
)
1104 register
= _register
1106 """Internal function."""
1108 while w
.master
: w
= w
.master
1110 _subst_format
= ('%#', '%b', '%f', '%h', '%k',
1111 '%s', '%t', '%w', '%x', '%y',
1112 '%A', '%E', '%K', '%N', '%W', '%T', '%X', '%Y', '%D')
1113 _subst_format_str
= " ".join(_subst_format
)
1114 def _substitute(self
, *args
):
1115 """Internal function."""
1116 if len(args
) != len(self
._subst
_format
): return args
1117 getboolean
= self
.tk
.getboolean
1120 def getint_event(s
):
1121 """Tk changed behavior in 8.4.2, returning "??" rather more often."""
1127 nsign
, b
, f
, h
, k
, s
, t
, w
, x
, y
, A
, E
, K
, N
, W
, T
, X
, Y
, D
= args
1128 # Missing: (a, c, d, m, o, v, B, R)
1130 # serial field: valid vor all events
1131 # number of button: ButtonPress and ButtonRelease events only
1132 # height field: Configure, ConfigureRequest, Create,
1133 # ResizeRequest, and Expose events only
1134 # keycode field: KeyPress and KeyRelease events only
1135 # time field: "valid for events that contain a time field"
1136 # width field: Configure, ConfigureRequest, Create, ResizeRequest,
1137 # and Expose events only
1138 # x field: "valid for events that contain a x field"
1139 # y field: "valid for events that contain a y field"
1140 # keysym as decimal: KeyPress and KeyRelease events only
1141 # x_root, y_root fields: ButtonPress, ButtonRelease, KeyPress,
1142 # KeyRelease,and Motion events
1143 e
.serial
= getint(nsign
)
1144 e
.num
= getint_event(b
)
1145 try: e
.focus
= getboolean(f
)
1146 except TclError
: pass
1147 e
.height
= getint_event(h
)
1148 e
.keycode
= getint_event(k
)
1149 e
.state
= getint_event(s
)
1150 e
.time
= getint_event(t
)
1151 e
.width
= getint_event(w
)
1152 e
.x
= getint_event(x
)
1153 e
.y
= getint_event(y
)
1155 try: e
.send_event
= getboolean(E
)
1156 except TclError
: pass
1158 e
.keysym_num
= getint_event(N
)
1161 e
.widget
= self
._nametowidget
(W
)
1164 e
.x_root
= getint_event(X
)
1165 e
.y_root
= getint_event(Y
)
1171 def _report_exception(self
):
1172 """Internal function."""
1174 exc
, val
, tb
= sys
.exc_type
, sys
.exc_value
, sys
.exc_traceback
1176 root
.report_callback_exception(exc
, val
, tb
)
1177 def _configure(self
, cmd
, cnf
, kw
):
1178 """Internal function."""
1180 cnf
= _cnfmerge((cnf
, kw
))
1182 cnf
= _cnfmerge(cnf
)
1185 for x
in self
.tk
.split(
1186 self
.tk
.call(_flatten((self
._w
, cmd
)))):
1187 cnf
[x
[0][1:]] = (x
[0][1:],) + x
[1:]
1189 if type(cnf
) is StringType
:
1191 self
.tk
.call(_flatten((self
._w
, cmd
, '-'+cnf
))))
1192 return (x
[0][1:],) + x
[1:]
1193 self
.tk
.call(_flatten((self
._w
, cmd
)) + self
._options
(cnf
))
1194 # These used to be defined in Widget:
1195 def configure(self
, cnf
=None, **kw
):
1196 """Configure resources of a widget.
1198 The values for resources are specified as keyword
1199 arguments. To get an overview about
1200 the allowed keyword arguments call the method keys.
1202 return self
._configure
('configure', cnf
, kw
)
1204 def cget(self
, key
):
1205 """Return the resource value for a KEY given as string."""
1206 return self
.tk
.call(self
._w
, 'cget', '-' + key
)
1208 def __setitem__(self
, key
, value
):
1209 self
.configure({key
: value
})
1210 def __contains__(self
, key
):
1211 raise TypeError("Tkinter objects don't support 'in' tests.")
1213 """Return a list of all resource names of this widget."""
1214 return map(lambda x
: x
[0][1:],
1215 self
.tk
.split(self
.tk
.call(self
._w
, 'configure')))
1217 """Return the window path name of this widget."""
1219 # Pack methods that apply to the master
1220 _noarg_
= ['_noarg_']
1221 def pack_propagate(self
, flag
=_noarg_
):
1222 """Set or get the status for propagation of geometry information.
1224 A boolean argument specifies whether the geometry information
1225 of the slaves will determine the size of this widget. If no argument
1226 is given the current setting will be returned.
1228 if flag
is Misc
._noarg
_:
1229 return self
._getboolean
(self
.tk
.call(
1230 'pack', 'propagate', self
._w
))
1232 self
.tk
.call('pack', 'propagate', self
._w
, flag
)
1233 propagate
= pack_propagate
1234 def pack_slaves(self
):
1235 """Return a list of all slaves of this widget
1236 in its packing order."""
1237 return map(self
._nametowidget
,
1239 self
.tk
.call('pack', 'slaves', self
._w
)))
1240 slaves
= pack_slaves
1241 # Place method that applies to the master
1242 def place_slaves(self
):
1243 """Return a list of all slaves of this widget
1244 in its packing order."""
1245 return map(self
._nametowidget
,
1248 'place', 'slaves', self
._w
)))
1249 # Grid methods that apply to the master
1250 def grid_bbox(self
, column
=None, row
=None, col2
=None, row2
=None):
1251 """Return a tuple of integer coordinates for the bounding
1252 box of this widget controlled by the geometry manager grid.
1254 If COLUMN, ROW is given the bounding box applies from
1255 the cell with row and column 0 to the specified
1256 cell. If COL2 and ROW2 are given the bounding box
1257 starts at that cell.
1259 The returned integers specify the offset of the upper left
1260 corner in the master widget and the width and height.
1262 args
= ('grid', 'bbox', self
._w
)
1263 if column
is not None and row
is not None:
1264 args
= args
+ (column
, row
)
1265 if col2
is not None and row2
is not None:
1266 args
= args
+ (col2
, row2
)
1267 return self
._getints
(self
.tk
.call(*args
)) or None
1270 def _grid_configure(self
, command
, index
, cnf
, kw
):
1271 """Internal function."""
1272 if type(cnf
) is StringType
and not kw
:
1279 options
= self
._options
(cnf
, kw
)
1281 res
= self
.tk
.call('grid',
1282 command
, self
._w
, index
)
1283 words
= self
.tk
.splitlist(res
)
1285 for i
in range(0, len(words
), 2):
1291 value
= getdouble(value
)
1293 value
= getint(value
)
1297 ('grid', command
, self
._w
, index
)
1299 if len(options
) == 1:
1300 if not res
: return None
1301 # In Tk 7.5, -width can be a float
1302 if '.' in res
: return getdouble(res
)
1304 def grid_columnconfigure(self
, index
, cnf
={}, **kw
):
1305 """Configure column INDEX of a grid.
1307 Valid resources are minsize (minimum size of the column),
1308 weight (how much does additional space propagate to this column)
1309 and pad (how much space to let additionally)."""
1310 return self
._grid
_configure
('columnconfigure', index
, cnf
, kw
)
1311 columnconfigure
= grid_columnconfigure
1312 def grid_location(self
, x
, y
):
1313 """Return a tuple of column and row which identify the cell
1314 at which the pixel at position X and Y inside the master
1315 widget is located."""
1316 return self
._getints
(
1318 'grid', 'location', self
._w
, x
, y
)) or None
1319 def grid_propagate(self
, flag
=_noarg_
):
1320 """Set or get the status for propagation of geometry information.
1322 A boolean argument specifies whether the geometry information
1323 of the slaves will determine the size of this widget. If no argument
1324 is given, the current setting will be returned.
1326 if flag
is Misc
._noarg
_:
1327 return self
._getboolean
(self
.tk
.call(
1328 'grid', 'propagate', self
._w
))
1330 self
.tk
.call('grid', 'propagate', self
._w
, flag
)
1331 def grid_rowconfigure(self
, index
, cnf
={}, **kw
):
1332 """Configure row INDEX of a grid.
1334 Valid resources are minsize (minimum size of the row),
1335 weight (how much does additional space propagate to this row)
1336 and pad (how much space to let additionally)."""
1337 return self
._grid
_configure
('rowconfigure', index
, cnf
, kw
)
1338 rowconfigure
= grid_rowconfigure
1339 def grid_size(self
):
1340 """Return a tuple of the number of column and rows in the grid."""
1341 return self
._getints
(
1342 self
.tk
.call('grid', 'size', self
._w
)) or None
1344 def grid_slaves(self
, row
=None, column
=None):
1345 """Return a list of all slaves of this widget
1346 in its packing order."""
1349 args
= args
+ ('-row', row
)
1350 if column
is not None:
1351 args
= args
+ ('-column', column
)
1352 return map(self
._nametowidget
,
1353 self
.tk
.splitlist(self
.tk
.call(
1354 ('grid', 'slaves', self
._w
) + args
)))
1356 # Support for the "event" command, new in Tk 4.2.
1359 def event_add(self
, virtual
, *sequences
):
1360 """Bind a virtual event VIRTUAL (of the form <<Name>>)
1361 to an event SEQUENCE such that the virtual event is triggered
1362 whenever SEQUENCE occurs."""
1363 args
= ('event', 'add', virtual
) + sequences
1366 def event_delete(self
, virtual
, *sequences
):
1367 """Unbind a virtual event VIRTUAL from SEQUENCE."""
1368 args
= ('event', 'delete', virtual
) + sequences
1371 def event_generate(self
, sequence
, **kw
):
1372 """Generate an event SEQUENCE. Additional
1373 keyword arguments specify parameter of the event
1374 (e.g. x, y, rootx, rooty)."""
1375 args
= ('event', 'generate', self
._w
, sequence
)
1376 for k
, v
in kw
.items():
1377 args
= args
+ ('-%s' % k
, str(v
))
1380 def event_info(self
, virtual
=None):
1381 """Return a list of all virtual events or the information
1382 about the SEQUENCE bound to the virtual event VIRTUAL."""
1383 return self
.tk
.splitlist(
1384 self
.tk
.call('event', 'info', virtual
))
1386 # Image related commands
1388 def image_names(self
):
1389 """Return a list of all existing image names."""
1390 return self
.tk
.call('image', 'names')
1392 def image_types(self
):
1393 """Return a list of all available image types (e.g. phote bitmap)."""
1394 return self
.tk
.call('image', 'types')
1398 """Internal class. Stores function to call when some user
1399 defined Tcl function is called e.g. after an event occurred."""
1400 def __init__(self
, func
, subst
, widget
):
1401 """Store FUNC, SUBST and WIDGET as members."""
1404 self
.widget
= widget
1405 def __call__(self
, *args
):
1406 """Apply first function SUBST to arguments, than FUNC."""
1409 args
= self
.subst(*args
)
1410 return self
.func(*args
)
1411 except SystemExit, msg
:
1412 raise SystemExit, msg
1414 self
.widget
._report
_exception
()
1418 """Provides functions for the communication with the window manager."""
1421 minNumer
=None, minDenom
=None,
1422 maxNumer
=None, maxDenom
=None):
1423 """Instruct the window manager to set the aspect ratio (width/height)
1424 of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple
1425 of the actual values if no argument is given."""
1426 return self
._getints
(
1427 self
.tk
.call('wm', 'aspect', self
._w
,
1429 maxNumer
, maxDenom
))
1432 def wm_attributes(self
, *args
):
1433 """This subcommand returns or sets platform specific attributes
1435 The first form returns a list of the platform specific flags and
1436 their values. The second form returns the value for the specific
1437 option. The third form sets one or more of the values. The values
1440 On Windows, -disabled gets or sets whether the window is in a
1441 disabled state. -toolwindow gets or sets the style of the window
1442 to toolwindow (as defined in the MSDN). -topmost gets or sets
1443 whether this is a topmost window (displays above all other
1448 On Unix, there are currently no special attribute values.
1450 args
= ('wm', 'attributes', self
._w
) + args
1451 return self
.tk
.call(args
)
1452 attributes
=wm_attributes
1454 def wm_client(self
, name
=None):
1455 """Store NAME in WM_CLIENT_MACHINE property of this widget. Return
1457 return self
.tk
.call('wm', 'client', self
._w
, name
)
1459 def wm_colormapwindows(self
, *wlist
):
1460 """Store list of window names (WLIST) into WM_COLORMAPWINDOWS property
1461 of this widget. This list contains windows whose colormaps differ from their
1462 parents. Return current list of widgets if WLIST is empty."""
1464 wlist
= (wlist
,) # Tk needs a list of windows here
1465 args
= ('wm', 'colormapwindows', self
._w
) + wlist
1466 return map(self
._nametowidget
, self
.tk
.call(args
))
1467 colormapwindows
= wm_colormapwindows
1468 def wm_command(self
, value
=None):
1469 """Store VALUE in WM_COMMAND property. It is the command
1470 which shall be used to invoke the application. Return current
1471 command if VALUE is None."""
1472 return self
.tk
.call('wm', 'command', self
._w
, value
)
1473 command
= wm_command
1474 def wm_deiconify(self
):
1475 """Deiconify this widget. If it was never mapped it will not be mapped.
1476 On Windows it will raise this widget and give it the focus."""
1477 return self
.tk
.call('wm', 'deiconify', self
._w
)
1478 deiconify
= wm_deiconify
1479 def wm_focusmodel(self
, model
=None):
1480 """Set focus model to MODEL. "active" means that this widget will claim
1481 the focus itself, "passive" means that the window manager shall give
1482 the focus. Return current focus model if MODEL is None."""
1483 return self
.tk
.call('wm', 'focusmodel', self
._w
, model
)
1484 focusmodel
= wm_focusmodel
1486 """Return identifier for decorative frame of this widget if present."""
1487 return self
.tk
.call('wm', 'frame', self
._w
)
1489 def wm_geometry(self
, newGeometry
=None):
1490 """Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return
1491 current value if None is given."""
1492 return self
.tk
.call('wm', 'geometry', self
._w
, newGeometry
)
1493 geometry
= wm_geometry
1495 baseWidth
=None, baseHeight
=None,
1496 widthInc
=None, heightInc
=None):
1497 """Instruct the window manager that this widget shall only be
1498 resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and
1499 height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the
1500 number of grid units requested in Tk_GeometryRequest."""
1501 return self
._getints
(self
.tk
.call(
1502 'wm', 'grid', self
._w
,
1503 baseWidth
, baseHeight
, widthInc
, heightInc
))
1505 def wm_group(self
, pathName
=None):
1506 """Set the group leader widgets for related widgets to PATHNAME. Return
1507 the group leader of this widget if None is given."""
1508 return self
.tk
.call('wm', 'group', self
._w
, pathName
)
1510 def wm_iconbitmap(self
, bitmap
=None, default
=None):
1511 """Set bitmap for the iconified widget to BITMAP. Return
1512 the bitmap if None is given.
1514 Under Windows, the DEFAULT parameter can be used to set the icon
1515 for the widget and any descendents that don't have an icon set
1516 explicitly. DEFAULT can be the relative path to a .ico file
1517 (example: root.iconbitmap(default='myicon.ico') ). See Tk
1518 documentation for more information."""
1520 return self
.tk
.call('wm', 'iconbitmap', self
._w
, '-default', default
)
1522 return self
.tk
.call('wm', 'iconbitmap', self
._w
, bitmap
)
1523 iconbitmap
= wm_iconbitmap
1524 def wm_iconify(self
):
1525 """Display widget as icon."""
1526 return self
.tk
.call('wm', 'iconify', self
._w
)
1527 iconify
= wm_iconify
1528 def wm_iconmask(self
, bitmap
=None):
1529 """Set mask for the icon bitmap of this widget. Return the
1530 mask if None is given."""
1531 return self
.tk
.call('wm', 'iconmask', self
._w
, bitmap
)
1532 iconmask
= wm_iconmask
1533 def wm_iconname(self
, newName
=None):
1534 """Set the name of the icon for this widget. Return the name if
1536 return self
.tk
.call('wm', 'iconname', self
._w
, newName
)
1537 iconname
= wm_iconname
1538 def wm_iconposition(self
, x
=None, y
=None):
1539 """Set the position of the icon of this widget to X and Y. Return
1540 a tuple of the current values of X and X if None is given."""
1541 return self
._getints
(self
.tk
.call(
1542 'wm', 'iconposition', self
._w
, x
, y
))
1543 iconposition
= wm_iconposition
1544 def wm_iconwindow(self
, pathName
=None):
1545 """Set widget PATHNAME to be displayed instead of icon. Return the current
1546 value if None is given."""
1547 return self
.tk
.call('wm', 'iconwindow', self
._w
, pathName
)
1548 iconwindow
= wm_iconwindow
1549 def wm_maxsize(self
, width
=None, height
=None):
1550 """Set max WIDTH and HEIGHT for this widget. If the window is gridded
1551 the values are given in grid units. Return the current values if None
1553 return self
._getints
(self
.tk
.call(
1554 'wm', 'maxsize', self
._w
, width
, height
))
1555 maxsize
= wm_maxsize
1556 def wm_minsize(self
, width
=None, height
=None):
1557 """Set min WIDTH and HEIGHT for this widget. If the window is gridded
1558 the values are given in grid units. Return the current values if None
1560 return self
._getints
(self
.tk
.call(
1561 'wm', 'minsize', self
._w
, width
, height
))
1562 minsize
= wm_minsize
1563 def wm_overrideredirect(self
, boolean
=None):
1564 """Instruct the window manager to ignore this widget
1565 if BOOLEAN is given with 1. Return the current value if None
1567 return self
._getboolean
(self
.tk
.call(
1568 'wm', 'overrideredirect', self
._w
, boolean
))
1569 overrideredirect
= wm_overrideredirect
1570 def wm_positionfrom(self
, who
=None):
1571 """Instruct the window manager that the position of this widget shall
1572 be defined by the user if WHO is "user", and by its own policy if WHO is
1574 return self
.tk
.call('wm', 'positionfrom', self
._w
, who
)
1575 positionfrom
= wm_positionfrom
1576 def wm_protocol(self
, name
=None, func
=None):
1577 """Bind function FUNC to command NAME for this widget.
1578 Return the function bound to NAME if None is given. NAME could be
1579 e.g. "WM_SAVE_YOURSELF" or "WM_DELETE_WINDOW"."""
1580 if hasattr(func
, '__call__'):
1581 command
= self
._register
(func
)
1584 return self
.tk
.call(
1585 'wm', 'protocol', self
._w
, name
, command
)
1586 protocol
= wm_protocol
1587 def wm_resizable(self
, width
=None, height
=None):
1588 """Instruct the window manager whether this width can be resized
1589 in WIDTH or HEIGHT. Both values are boolean values."""
1590 return self
.tk
.call('wm', 'resizable', self
._w
, width
, height
)
1591 resizable
= wm_resizable
1592 def wm_sizefrom(self
, who
=None):
1593 """Instruct the window manager that the size of this widget shall
1594 be defined by the user if WHO is "user", and by its own policy if WHO is
1596 return self
.tk
.call('wm', 'sizefrom', self
._w
, who
)
1597 sizefrom
= wm_sizefrom
1598 def wm_state(self
, newstate
=None):
1599 """Query or set the state of this widget as one of normal, icon,
1600 iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only)."""
1601 return self
.tk
.call('wm', 'state', self
._w
, newstate
)
1603 def wm_title(self
, string
=None):
1604 """Set the title of this widget."""
1605 return self
.tk
.call('wm', 'title', self
._w
, string
)
1607 def wm_transient(self
, master
=None):
1608 """Instruct the window manager that this widget is transient
1609 with regard to widget MASTER."""
1610 return self
.tk
.call('wm', 'transient', self
._w
, master
)
1611 transient
= wm_transient
1612 def wm_withdraw(self
):
1613 """Withdraw this widget from the screen such that it is unmapped
1614 and forgotten by the window manager. Re-draw it with wm_deiconify."""
1615 return self
.tk
.call('wm', 'withdraw', self
._w
)
1616 withdraw
= wm_withdraw
1620 """Toplevel widget of Tk which represents mostly the main window
1621 of an appliation. It has an associated Tcl interpreter."""
1623 def __init__(self
, screenName
=None, baseName
=None, className
='Tk',
1624 useTk
=1, sync
=0, use
=None):
1625 """Return a new Toplevel widget on screen SCREENNAME. A new Tcl interpreter will
1626 be created. BASENAME will be used for the identification of the profile file (see
1628 It is constructed from sys.argv[0] without extensions if None is given. CLASSNAME
1629 is the name of the widget class."""
1633 # to avoid recursions in the getattr code in case of failure, we
1634 # ensure that self.tk is always _something_.
1636 if baseName
is None:
1638 baseName
= os
.path
.basename(sys
.argv
[0])
1639 baseName
, ext
= os
.path
.splitext(baseName
)
1640 if ext
not in ('.py', '.pyc', '.pyo'):
1641 baseName
= baseName
+ ext
1643 self
.tk
= _tkinter
.create(screenName
, baseName
, className
, interactive
, wantobjects
, useTk
, sync
, use
)
1646 self
.readprofile(baseName
, className
)
1648 if not self
._tkloaded
:
1653 global _default_root
1654 # Version sanity checks
1655 tk_version
= self
.tk
.getvar('tk_version')
1656 if tk_version
!= _tkinter
.TK_VERSION
:
1657 raise RuntimeError, \
1658 "tk.h version (%s) doesn't match libtk.a version (%s)" \
1659 % (_tkinter
.TK_VERSION
, tk_version
)
1660 # Under unknown circumstances, tcl_version gets coerced to float
1661 tcl_version
= str(self
.tk
.getvar('tcl_version'))
1662 if tcl_version
!= _tkinter
.TCL_VERSION
:
1663 raise RuntimeError, \
1664 "tcl.h version (%s) doesn't match libtcl.a version (%s)" \
1665 % (_tkinter
.TCL_VERSION
, tcl_version
)
1667 raise RuntimeError, \
1668 "Tk 4.0 or higher is required; found Tk %s" \
1670 # Create and register the tkerror and exit commands
1671 # We need to inline parts of _register here, _ register
1672 # would register differently-named commands.
1673 if self
._tclCommands
is None:
1674 self
._tclCommands
= []
1675 self
.tk
.createcommand('tkerror', _tkerror
)
1676 self
.tk
.createcommand('exit', _exit
)
1677 self
._tclCommands
.append('tkerror')
1678 self
._tclCommands
.append('exit')
1679 if _support_default_root
and not _default_root
:
1680 _default_root
= self
1681 self
.protocol("WM_DELETE_WINDOW", self
.destroy
)
1683 """Destroy this and all descendants widgets. This will
1684 end the application of this Tcl interpreter."""
1685 for c
in self
.children
.values(): c
.destroy()
1686 self
.tk
.call('destroy', self
._w
)
1688 global _default_root
1689 if _support_default_root
and _default_root
is self
:
1690 _default_root
= None
1691 def readprofile(self
, baseName
, className
):
1692 """Internal function. It reads BASENAME.tcl and CLASSNAME.tcl into
1693 the Tcl Interpreter and calls execfile on BASENAME.py and CLASSNAME.py if
1694 such a file exists in the home directory."""
1696 if os
.environ
.has_key('HOME'): home
= os
.environ
['HOME']
1697 else: home
= os
.curdir
1698 class_tcl
= os
.path
.join(home
, '.%s.tcl' % className
)
1699 class_py
= os
.path
.join(home
, '.%s.py' % className
)
1700 base_tcl
= os
.path
.join(home
, '.%s.tcl' % baseName
)
1701 base_py
= os
.path
.join(home
, '.%s.py' % baseName
)
1702 dir = {'self': self
}
1703 exec 'from Tkinter import *' in dir
1704 if os
.path
.isfile(class_tcl
):
1705 self
.tk
.call('source', class_tcl
)
1706 if os
.path
.isfile(class_py
):
1707 execfile(class_py
, dir)
1708 if os
.path
.isfile(base_tcl
):
1709 self
.tk
.call('source', base_tcl
)
1710 if os
.path
.isfile(base_py
):
1711 execfile(base_py
, dir)
1712 def report_callback_exception(self
, exc
, val
, tb
):
1713 """Internal function. It reports exception on sys.stderr."""
1714 import traceback
, sys
1715 sys
.stderr
.write("Exception in Tkinter callback\n")
1717 sys
.last_value
= val
1718 sys
.last_traceback
= tb
1719 traceback
.print_exception(exc
, val
, tb
)
1720 def __getattr__(self
, attr
):
1721 "Delegate attribute access to the interpreter object"
1722 return getattr(self
.tk
, attr
)
1724 # Ideally, the classes Pack, Place and Grid disappear, the
1725 # pack/place/grid methods are defined on the Widget class, and
1726 # everybody uses w.pack_whatever(...) instead of Pack.whatever(w,
1727 # ...), with pack(), place() and grid() being short for
1728 # pack_configure(), place_configure() and grid_columnconfigure(), and
1729 # forget() being short for pack_forget(). As a practical matter, I'm
1730 # afraid that there is too much code out there that may be using the
1731 # Pack, Place or Grid class, so I leave them intact -- but only as
1732 # backwards compatibility features. Also note that those methods that
1733 # take a master as argument (e.g. pack_propagate) have been moved to
1734 # the Misc class (which now incorporates all methods common between
1735 # toplevel and interior widgets). Again, for compatibility, these are
1736 # copied into the Pack, Place or Grid class.
1739 def Tcl(screenName
=None, baseName
=None, className
='Tk', useTk
=0):
1740 return Tk(screenName
, baseName
, className
, useTk
)
1743 """Geometry manager Pack.
1745 Base class to use the methods pack_* in every widget."""
1746 def pack_configure(self
, cnf
={}, **kw
):
1747 """Pack a widget in the parent widget. Use as options:
1748 after=widget - pack it after you have packed widget
1749 anchor=NSEW (or subset) - position widget according to
1751 before=widget - pack it before you will pack widget
1752 expand=bool - expand widget if parent size grows
1753 fill=NONE or X or Y or BOTH - fill widget if widget grows
1754 in=master - use master to contain this widget
1755 in_=master - see 'in' option description
1756 ipadx=amount - add internal padding in x direction
1757 ipady=amount - add internal padding in y direction
1758 padx=amount - add padding in x direction
1759 pady=amount - add padding in y direction
1760 side=TOP or BOTTOM or LEFT or RIGHT - where to add this widget.
1763 ('pack', 'configure', self
._w
)
1764 + self
._options
(cnf
, kw
))
1765 pack
= configure
= config
= pack_configure
1766 def pack_forget(self
):
1767 """Unmap this widget and do not use it for the packing order."""
1768 self
.tk
.call('pack', 'forget', self
._w
)
1769 forget
= pack_forget
1770 def pack_info(self
):
1771 """Return information about the packing options
1773 words
= self
.tk
.splitlist(
1774 self
.tk
.call('pack', 'info', self
._w
))
1776 for i
in range(0, len(words
), 2):
1779 if value
[:1] == '.':
1780 value
= self
._nametowidget
(value
)
1784 propagate
= pack_propagate
= Misc
.pack_propagate
1785 slaves
= pack_slaves
= Misc
.pack_slaves
1788 """Geometry manager Place.
1790 Base class to use the methods place_* in every widget."""
1791 def place_configure(self
, cnf
={}, **kw
):
1792 """Place a widget in the parent widget. Use as options:
1793 in=master - master relative to which the widget is placed
1794 in_=master - see 'in' option description
1795 x=amount - locate anchor of this widget at position x of master
1796 y=amount - locate anchor of this widget at position y of master
1797 relx=amount - locate anchor of this widget between 0.0 and 1.0
1798 relative to width of master (1.0 is right edge)
1799 rely=amount - locate anchor of this widget between 0.0 and 1.0
1800 relative to height of master (1.0 is bottom edge)
1801 anchor=NSEW (or subset) - position anchor according to given direction
1802 width=amount - width of this widget in pixel
1803 height=amount - height of this widget in pixel
1804 relwidth=amount - width of this widget between 0.0 and 1.0
1805 relative to width of master (1.0 is the same width
1807 relheight=amount - height of this widget between 0.0 and 1.0
1808 relative to height of master (1.0 is the same
1809 height as the master)
1810 bordermode="inside" or "outside" - whether to take border width of
1811 master widget into account
1814 ('place', 'configure', self
._w
)
1815 + self
._options
(cnf
, kw
))
1816 place
= configure
= config
= place_configure
1817 def place_forget(self
):
1818 """Unmap this widget."""
1819 self
.tk
.call('place', 'forget', self
._w
)
1820 forget
= place_forget
1821 def place_info(self
):
1822 """Return information about the placing options
1824 words
= self
.tk
.splitlist(
1825 self
.tk
.call('place', 'info', self
._w
))
1827 for i
in range(0, len(words
), 2):
1830 if value
[:1] == '.':
1831 value
= self
._nametowidget
(value
)
1835 slaves
= place_slaves
= Misc
.place_slaves
1838 """Geometry manager Grid.
1840 Base class to use the methods grid_* in every widget."""
1841 # Thanks to Masazumi Yoshikawa (yosikawa@isi.edu)
1842 def grid_configure(self
, cnf
={}, **kw
):
1843 """Position a widget in the parent widget in a grid. Use as options:
1844 column=number - use cell identified with given column (starting with 0)
1845 columnspan=number - this widget will span several columns
1846 in=master - use master to contain this widget
1847 in_=master - see 'in' option description
1848 ipadx=amount - add internal padding in x direction
1849 ipady=amount - add internal padding in y direction
1850 padx=amount - add padding in x direction
1851 pady=amount - add padding in y direction
1852 row=number - use cell identified with given row (starting with 0)
1853 rowspan=number - this widget will span several rows
1854 sticky=NSEW - if cell is larger on which sides will this
1855 widget stick to the cell boundary
1858 ('grid', 'configure', self
._w
)
1859 + self
._options
(cnf
, kw
))
1860 grid
= configure
= config
= grid_configure
1861 bbox
= grid_bbox
= Misc
.grid_bbox
1862 columnconfigure
= grid_columnconfigure
= Misc
.grid_columnconfigure
1863 def grid_forget(self
):
1864 """Unmap this widget."""
1865 self
.tk
.call('grid', 'forget', self
._w
)
1866 forget
= grid_forget
1867 def grid_remove(self
):
1868 """Unmap this widget but remember the grid options."""
1869 self
.tk
.call('grid', 'remove', self
._w
)
1870 def grid_info(self
):
1871 """Return information about the options
1872 for positioning this widget in a grid."""
1873 words
= self
.tk
.splitlist(
1874 self
.tk
.call('grid', 'info', self
._w
))
1876 for i
in range(0, len(words
), 2):
1879 if value
[:1] == '.':
1880 value
= self
._nametowidget
(value
)
1884 location
= grid_location
= Misc
.grid_location
1885 propagate
= grid_propagate
= Misc
.grid_propagate
1886 rowconfigure
= grid_rowconfigure
= Misc
.grid_rowconfigure
1887 size
= grid_size
= Misc
.grid_size
1888 slaves
= grid_slaves
= Misc
.grid_slaves
1890 class BaseWidget(Misc
):
1891 """Internal class."""
1892 def _setup(self
, master
, cnf
):
1893 """Internal function. Sets up information about children."""
1894 if _support_default_root
:
1895 global _default_root
1897 if not _default_root
:
1898 _default_root
= Tk()
1899 master
= _default_root
1900 self
.master
= master
1903 if cnf
.has_key('name'):
1907 name
= repr(id(self
))
1910 self
._w
= '.' + name
1912 self
._w
= master
._w
+ '.' + name
1914 if self
.master
.children
.has_key(self
._name
):
1915 self
.master
.children
[self
._name
].destroy()
1916 self
.master
.children
[self
._name
] = self
1917 def __init__(self
, master
, widgetName
, cnf
={}, kw
={}, extra
=()):
1918 """Construct a widget with the parent widget MASTER, a name WIDGETNAME
1919 and appropriate options."""
1921 cnf
= _cnfmerge((cnf
, kw
))
1922 self
.widgetName
= widgetName
1923 BaseWidget
._setup
(self
, master
, cnf
)
1925 for k
in cnf
.keys():
1926 if type(k
) is ClassType
:
1927 classes
.append((k
, cnf
[k
]))
1930 (widgetName
, self
._w
) + extra
+ self
._options
(cnf
))
1931 for k
, v
in classes
:
1932 k
.configure(self
, v
)
1934 """Destroy this and all descendants widgets."""
1935 for c
in self
.children
.values(): c
.destroy()
1936 self
.tk
.call('destroy', self
._w
)
1937 if self
.master
.children
.has_key(self
._name
):
1938 del self
.master
.children
[self
._name
]
1940 def _do(self
, name
, args
=()):
1941 # XXX Obsolete -- better use self.tk.call directly!
1942 return self
.tk
.call((self
._w
, name
) + args
)
1944 class Widget(BaseWidget
, Pack
, Place
, Grid
):
1947 Base class for a widget which can be positioned with the geometry managers
1948 Pack, Place or Grid."""
1951 class Toplevel(BaseWidget
, Wm
):
1952 """Toplevel widget, e.g. for dialogs."""
1953 def __init__(self
, master
=None, cnf
={}, **kw
):
1954 """Construct a toplevel widget with the parent MASTER.
1956 Valid resource names: background, bd, bg, borderwidth, class,
1957 colormap, container, cursor, height, highlightbackground,
1958 highlightcolor, highlightthickness, menu, relief, screen, takefocus,
1959 use, visual, width."""
1961 cnf
= _cnfmerge((cnf
, kw
))
1963 for wmkey
in ['screen', 'class_', 'class', 'visual',
1965 if cnf
.has_key(wmkey
):
1967 # TBD: a hack needed because some keys
1968 # are not valid as keyword arguments
1969 if wmkey
[-1] == '_': opt
= '-'+wmkey
[:-1]
1970 else: opt
= '-'+wmkey
1971 extra
= extra
+ (opt
, val
)
1973 BaseWidget
.__init
__(self
, master
, 'toplevel', cnf
, {}, extra
)
1975 self
.iconname(root
.iconname())
1976 self
.title(root
.title())
1977 self
.protocol("WM_DELETE_WINDOW", self
.destroy
)
1979 class Button(Widget
):
1980 """Button widget."""
1981 def __init__(self
, master
=None, cnf
={}, **kw
):
1982 """Construct a button widget with the parent MASTER.
1986 activebackground, activeforeground, anchor,
1987 background, bitmap, borderwidth, cursor,
1988 disabledforeground, font, foreground
1989 highlightbackground, highlightcolor,
1990 highlightthickness, image, justify,
1991 padx, pady, relief, repeatdelay,
1992 repeatinterval, takefocus, text,
1993 textvariable, underline, wraplength
1995 WIDGET-SPECIFIC OPTIONS
1997 command, compound, default, height,
1998 overrelief, state, width
2000 Widget
.__init
__(self
, master
, 'button', cnf
, kw
)
2002 def tkButtonEnter(self
, *dummy
):
2003 self
.tk
.call('tkButtonEnter', self
._w
)
2005 def tkButtonLeave(self
, *dummy
):
2006 self
.tk
.call('tkButtonLeave', self
._w
)
2008 def tkButtonDown(self
, *dummy
):
2009 self
.tk
.call('tkButtonDown', self
._w
)
2011 def tkButtonUp(self
, *dummy
):
2012 self
.tk
.call('tkButtonUp', self
._w
)
2014 def tkButtonInvoke(self
, *dummy
):
2015 self
.tk
.call('tkButtonInvoke', self
._w
)
2018 """Flash the button.
2020 This is accomplished by redisplaying
2021 the button several times, alternating between active and
2022 normal colors. At the end of the flash the button is left
2023 in the same normal/active state as when the command was
2024 invoked. This command is ignored if the button's state is
2027 self
.tk
.call(self
._w
, 'flash')
2030 """Invoke the command associated with the button.
2032 The return value is the return value from the command,
2033 or an empty string if there is no command associated with
2034 the button. This command is ignored if the button's state
2037 return self
.tk
.call(self
._w
, 'invoke')
2040 # XXX I don't like these -- take them away
2043 def AtInsert(*args
):
2046 if a
: s
= s
+ (' ' + a
)
2056 return '@%r,%r' % (x
, y
)
2058 class Canvas(Widget
):
2059 """Canvas widget to display graphical elements like lines or text."""
2060 def __init__(self
, master
=None, cnf
={}, **kw
):
2061 """Construct a canvas widget with the parent MASTER.
2063 Valid resource names: background, bd, bg, borderwidth, closeenough,
2064 confine, cursor, height, highlightbackground, highlightcolor,
2065 highlightthickness, insertbackground, insertborderwidth,
2066 insertofftime, insertontime, insertwidth, offset, relief,
2067 scrollregion, selectbackground, selectborderwidth, selectforeground,
2068 state, takefocus, width, xscrollcommand, xscrollincrement,
2069 yscrollcommand, yscrollincrement."""
2070 Widget
.__init
__(self
, master
, 'canvas', cnf
, kw
)
2071 def addtag(self
, *args
):
2072 """Internal function."""
2073 self
.tk
.call((self
._w
, 'addtag') + args
)
2074 def addtag_above(self
, newtag
, tagOrId
):
2075 """Add tag NEWTAG to all items above TAGORID."""
2076 self
.addtag(newtag
, 'above', tagOrId
)
2077 def addtag_all(self
, newtag
):
2078 """Add tag NEWTAG to all items."""
2079 self
.addtag(newtag
, 'all')
2080 def addtag_below(self
, newtag
, tagOrId
):
2081 """Add tag NEWTAG to all items below TAGORID."""
2082 self
.addtag(newtag
, 'below', tagOrId
)
2083 def addtag_closest(self
, newtag
, x
, y
, halo
=None, start
=None):
2084 """Add tag NEWTAG to item which is closest to pixel at X, Y.
2085 If several match take the top-most.
2086 All items closer than HALO are considered overlapping (all are
2087 closests). If START is specified the next below this tag is taken."""
2088 self
.addtag(newtag
, 'closest', x
, y
, halo
, start
)
2089 def addtag_enclosed(self
, newtag
, x1
, y1
, x2
, y2
):
2090 """Add tag NEWTAG to all items in the rectangle defined
2092 self
.addtag(newtag
, 'enclosed', x1
, y1
, x2
, y2
)
2093 def addtag_overlapping(self
, newtag
, x1
, y1
, x2
, y2
):
2094 """Add tag NEWTAG to all items which overlap the rectangle
2095 defined by X1,Y1,X2,Y2."""
2096 self
.addtag(newtag
, 'overlapping', x1
, y1
, x2
, y2
)
2097 def addtag_withtag(self
, newtag
, tagOrId
):
2098 """Add tag NEWTAG to all items with TAGORID."""
2099 self
.addtag(newtag
, 'withtag', tagOrId
)
2100 def bbox(self
, *args
):
2101 """Return a tuple of X1,Y1,X2,Y2 coordinates for a rectangle
2102 which encloses all items with tags specified as arguments."""
2103 return self
._getints
(
2104 self
.tk
.call((self
._w
, 'bbox') + args
)) or None
2105 def tag_unbind(self
, tagOrId
, sequence
, funcid
=None):
2106 """Unbind for all items with TAGORID for event SEQUENCE the
2107 function identified with FUNCID."""
2108 self
.tk
.call(self
._w
, 'bind', tagOrId
, sequence
, '')
2110 self
.deletecommand(funcid
)
2111 def tag_bind(self
, tagOrId
, sequence
=None, func
=None, add
=None):
2112 """Bind to all items with TAGORID at event SEQUENCE a call to function FUNC.
2114 An additional boolean parameter ADD specifies whether FUNC will be
2115 called additionally to the other bound function or whether it will
2116 replace the previous function. See bind for the return value."""
2117 return self
._bind
((self
._w
, 'bind', tagOrId
),
2118 sequence
, func
, add
)
2119 def canvasx(self
, screenx
, gridspacing
=None):
2120 """Return the canvas x coordinate of pixel position SCREENX rounded
2121 to nearest multiple of GRIDSPACING units."""
2122 return getdouble(self
.tk
.call(
2123 self
._w
, 'canvasx', screenx
, gridspacing
))
2124 def canvasy(self
, screeny
, gridspacing
=None):
2125 """Return the canvas y coordinate of pixel position SCREENY rounded
2126 to nearest multiple of GRIDSPACING units."""
2127 return getdouble(self
.tk
.call(
2128 self
._w
, 'canvasy', screeny
, gridspacing
))
2129 def coords(self
, *args
):
2130 """Return a list of coordinates for the item given in ARGS."""
2131 # XXX Should use _flatten on args
2132 return map(getdouble
,
2134 self
.tk
.call((self
._w
, 'coords') + args
)))
2135 def _create(self
, itemType
, args
, kw
): # Args: (val, val, ..., cnf={})
2136 """Internal function."""
2137 args
= _flatten(args
)
2139 if type(cnf
) in (DictionaryType
, TupleType
):
2143 return getint(self
.tk
.call(
2144 self
._w
, 'create', itemType
,
2145 *(args
+ self
._options
(cnf
, kw
))))
2146 def create_arc(self
, *args
, **kw
):
2147 """Create arc shaped region with coordinates x1,y1,x2,y2."""
2148 return self
._create
('arc', args
, kw
)
2149 def create_bitmap(self
, *args
, **kw
):
2150 """Create bitmap with coordinates x1,y1."""
2151 return self
._create
('bitmap', args
, kw
)
2152 def create_image(self
, *args
, **kw
):
2153 """Create image item with coordinates x1,y1."""
2154 return self
._create
('image', args
, kw
)
2155 def create_line(self
, *args
, **kw
):
2156 """Create line with coordinates x1,y1,...,xn,yn."""
2157 return self
._create
('line', args
, kw
)
2158 def create_oval(self
, *args
, **kw
):
2159 """Create oval with coordinates x1,y1,x2,y2."""
2160 return self
._create
('oval', args
, kw
)
2161 def create_polygon(self
, *args
, **kw
):
2162 """Create polygon with coordinates x1,y1,...,xn,yn."""
2163 return self
._create
('polygon', args
, kw
)
2164 def create_rectangle(self
, *args
, **kw
):
2165 """Create rectangle with coordinates x1,y1,x2,y2."""
2166 return self
._create
('rectangle', args
, kw
)
2167 def create_text(self
, *args
, **kw
):
2168 """Create text with coordinates x1,y1."""
2169 return self
._create
('text', args
, kw
)
2170 def create_window(self
, *args
, **kw
):
2171 """Create window with coordinates x1,y1,x2,y2."""
2172 return self
._create
('window', args
, kw
)
2173 def dchars(self
, *args
):
2174 """Delete characters of text items identified by tag or id in ARGS (possibly
2175 several times) from FIRST to LAST character (including)."""
2176 self
.tk
.call((self
._w
, 'dchars') + args
)
2177 def delete(self
, *args
):
2178 """Delete items identified by all tag or ids contained in ARGS."""
2179 self
.tk
.call((self
._w
, 'delete') + args
)
2180 def dtag(self
, *args
):
2181 """Delete tag or id given as last arguments in ARGS from items
2182 identified by first argument in ARGS."""
2183 self
.tk
.call((self
._w
, 'dtag') + args
)
2184 def find(self
, *args
):
2185 """Internal function."""
2186 return self
._getints
(
2187 self
.tk
.call((self
._w
, 'find') + args
)) or ()
2188 def find_above(self
, tagOrId
):
2189 """Return items above TAGORID."""
2190 return self
.find('above', tagOrId
)
2192 """Return all items."""
2193 return self
.find('all')
2194 def find_below(self
, tagOrId
):
2195 """Return all items below TAGORID."""
2196 return self
.find('below', tagOrId
)
2197 def find_closest(self
, x
, y
, halo
=None, start
=None):
2198 """Return item which is closest to pixel at X, Y.
2199 If several match take the top-most.
2200 All items closer than HALO are considered overlapping (all are
2201 closests). If START is specified the next below this tag is taken."""
2202 return self
.find('closest', x
, y
, halo
, start
)
2203 def find_enclosed(self
, x1
, y1
, x2
, y2
):
2204 """Return all items in rectangle defined
2206 return self
.find('enclosed', x1
, y1
, x2
, y2
)
2207 def find_overlapping(self
, x1
, y1
, x2
, y2
):
2208 """Return all items which overlap the rectangle
2209 defined by X1,Y1,X2,Y2."""
2210 return self
.find('overlapping', x1
, y1
, x2
, y2
)
2211 def find_withtag(self
, tagOrId
):
2212 """Return all items with TAGORID."""
2213 return self
.find('withtag', tagOrId
)
2214 def focus(self
, *args
):
2215 """Set focus to the first item specified in ARGS."""
2216 return self
.tk
.call((self
._w
, 'focus') + args
)
2217 def gettags(self
, *args
):
2218 """Return tags associated with the first item specified in ARGS."""
2219 return self
.tk
.splitlist(
2220 self
.tk
.call((self
._w
, 'gettags') + args
))
2221 def icursor(self
, *args
):
2222 """Set cursor at position POS in the item identified by TAGORID.
2223 In ARGS TAGORID must be first."""
2224 self
.tk
.call((self
._w
, 'icursor') + args
)
2225 def index(self
, *args
):
2226 """Return position of cursor as integer in item specified in ARGS."""
2227 return getint(self
.tk
.call((self
._w
, 'index') + args
))
2228 def insert(self
, *args
):
2229 """Insert TEXT in item TAGORID at position POS. ARGS must
2230 be TAGORID POS TEXT."""
2231 self
.tk
.call((self
._w
, 'insert') + args
)
2232 def itemcget(self
, tagOrId
, option
):
2233 """Return the resource value for an OPTION for item TAGORID."""
2234 return self
.tk
.call(
2235 (self
._w
, 'itemcget') + (tagOrId
, '-'+option
))
2236 def itemconfigure(self
, tagOrId
, cnf
=None, **kw
):
2237 """Configure resources of an item TAGORID.
2239 The values for resources are specified as keyword
2240 arguments. To get an overview about
2241 the allowed keyword arguments call the method without arguments.
2243 return self
._configure
(('itemconfigure', tagOrId
), cnf
, kw
)
2244 itemconfig
= itemconfigure
2245 # lower, tkraise/lift hide Misc.lower, Misc.tkraise/lift,
2246 # so the preferred name for them is tag_lower, tag_raise
2247 # (similar to tag_bind, and similar to the Text widget);
2248 # unfortunately can't delete the old ones yet (maybe in 1.6)
2249 def tag_lower(self
, *args
):
2250 """Lower an item TAGORID given in ARGS
2251 (optional below another item)."""
2252 self
.tk
.call((self
._w
, 'lower') + args
)
2254 def move(self
, *args
):
2255 """Move an item TAGORID given in ARGS."""
2256 self
.tk
.call((self
._w
, 'move') + args
)
2257 def postscript(self
, cnf
={}, **kw
):
2258 """Print the contents of the canvas to a postscript
2259 file. Valid options: colormap, colormode, file, fontmap,
2260 height, pageanchor, pageheight, pagewidth, pagex, pagey,
2261 rotate, witdh, x, y."""
2262 return self
.tk
.call((self
._w
, 'postscript') +
2263 self
._options
(cnf
, kw
))
2264 def tag_raise(self
, *args
):
2265 """Raise an item TAGORID given in ARGS
2266 (optional above another item)."""
2267 self
.tk
.call((self
._w
, 'raise') + args
)
2268 lift
= tkraise
= tag_raise
2269 def scale(self
, *args
):
2270 """Scale item TAGORID with XORIGIN, YORIGIN, XSCALE, YSCALE."""
2271 self
.tk
.call((self
._w
, 'scale') + args
)
2272 def scan_mark(self
, x
, y
):
2273 """Remember the current X, Y coordinates."""
2274 self
.tk
.call(self
._w
, 'scan', 'mark', x
, y
)
2275 def scan_dragto(self
, x
, y
, gain
=10):
2276 """Adjust the view of the canvas to GAIN times the
2277 difference between X and Y and the coordinates given in
2279 self
.tk
.call(self
._w
, 'scan', 'dragto', x
, y
, gain
)
2280 def select_adjust(self
, tagOrId
, index
):
2281 """Adjust the end of the selection near the cursor of an item TAGORID to index."""
2282 self
.tk
.call(self
._w
, 'select', 'adjust', tagOrId
, index
)
2283 def select_clear(self
):
2284 """Clear the selection if it is in this widget."""
2285 self
.tk
.call(self
._w
, 'select', 'clear')
2286 def select_from(self
, tagOrId
, index
):
2287 """Set the fixed end of a selection in item TAGORID to INDEX."""
2288 self
.tk
.call(self
._w
, 'select', 'from', tagOrId
, index
)
2289 def select_item(self
):
2290 """Return the item which has the selection."""
2291 return self
.tk
.call(self
._w
, 'select', 'item') or None
2292 def select_to(self
, tagOrId
, index
):
2293 """Set the variable end of a selection in item TAGORID to INDEX."""
2294 self
.tk
.call(self
._w
, 'select', 'to', tagOrId
, index
)
2295 def type(self
, tagOrId
):
2296 """Return the type of the item TAGORID."""
2297 return self
.tk
.call(self
._w
, 'type', tagOrId
) or None
2298 def xview(self
, *args
):
2299 """Query and change horizontal position of the view."""
2301 return self
._getdoubles
(self
.tk
.call(self
._w
, 'xview'))
2302 self
.tk
.call((self
._w
, 'xview') + args
)
2303 def xview_moveto(self
, fraction
):
2304 """Adjusts the view in the window so that FRACTION of the
2305 total width of the canvas is off-screen to the left."""
2306 self
.tk
.call(self
._w
, 'xview', 'moveto', fraction
)
2307 def xview_scroll(self
, number
, what
):
2308 """Shift the x-view according to NUMBER which is measured in "units" or "pages" (WHAT)."""
2309 self
.tk
.call(self
._w
, 'xview', 'scroll', number
, what
)
2310 def yview(self
, *args
):
2311 """Query and change vertical position of the view."""
2313 return self
._getdoubles
(self
.tk
.call(self
._w
, 'yview'))
2314 self
.tk
.call((self
._w
, 'yview') + args
)
2315 def yview_moveto(self
, fraction
):
2316 """Adjusts the view in the window so that FRACTION of the
2317 total height of the canvas is off-screen to the top."""
2318 self
.tk
.call(self
._w
, 'yview', 'moveto', fraction
)
2319 def yview_scroll(self
, number
, what
):
2320 """Shift the y-view according to NUMBER which is measured in "units" or "pages" (WHAT)."""
2321 self
.tk
.call(self
._w
, 'yview', 'scroll', number
, what
)
2323 class Checkbutton(Widget
):
2324 """Checkbutton widget which is either in on- or off-state."""
2325 def __init__(self
, master
=None, cnf
={}, **kw
):
2326 """Construct a checkbutton widget with the parent MASTER.
2328 Valid resource names: activebackground, activeforeground, anchor,
2329 background, bd, bg, bitmap, borderwidth, command, cursor,
2330 disabledforeground, fg, font, foreground, height,
2331 highlightbackground, highlightcolor, highlightthickness, image,
2332 indicatoron, justify, offvalue, onvalue, padx, pady, relief,
2333 selectcolor, selectimage, state, takefocus, text, textvariable,
2334 underline, variable, width, wraplength."""
2335 Widget
.__init
__(self
, master
, 'checkbutton', cnf
, kw
)
2337 """Put the button in off-state."""
2338 self
.tk
.call(self
._w
, 'deselect')
2340 """Flash the button."""
2341 self
.tk
.call(self
._w
, 'flash')
2343 """Toggle the button and invoke a command if given as resource."""
2344 return self
.tk
.call(self
._w
, 'invoke')
2346 """Put the button in on-state."""
2347 self
.tk
.call(self
._w
, 'select')
2349 """Toggle the button."""
2350 self
.tk
.call(self
._w
, 'toggle')
2352 class Entry(Widget
):
2353 """Entry widget which allows to display simple text."""
2354 def __init__(self
, master
=None, cnf
={}, **kw
):
2355 """Construct an entry widget with the parent MASTER.
2357 Valid resource names: background, bd, bg, borderwidth, cursor,
2358 exportselection, fg, font, foreground, highlightbackground,
2359 highlightcolor, highlightthickness, insertbackground,
2360 insertborderwidth, insertofftime, insertontime, insertwidth,
2361 invalidcommand, invcmd, justify, relief, selectbackground,
2362 selectborderwidth, selectforeground, show, state, takefocus,
2363 textvariable, validate, validatecommand, vcmd, width,
2365 Widget
.__init
__(self
, master
, 'entry', cnf
, kw
)
2366 def delete(self
, first
, last
=None):
2367 """Delete text from FIRST to LAST (not included)."""
2368 self
.tk
.call(self
._w
, 'delete', first
, last
)
2370 """Return the text."""
2371 return self
.tk
.call(self
._w
, 'get')
2372 def icursor(self
, index
):
2373 """Insert cursor at INDEX."""
2374 self
.tk
.call(self
._w
, 'icursor', index
)
2375 def index(self
, index
):
2376 """Return position of cursor."""
2377 return getint(self
.tk
.call(
2378 self
._w
, 'index', index
))
2379 def insert(self
, index
, string
):
2380 """Insert STRING at INDEX."""
2381 self
.tk
.call(self
._w
, 'insert', index
, string
)
2382 def scan_mark(self
, x
):
2383 """Remember the current X, Y coordinates."""
2384 self
.tk
.call(self
._w
, 'scan', 'mark', x
)
2385 def scan_dragto(self
, x
):
2386 """Adjust the view of the canvas to 10 times the
2387 difference between X and Y and the coordinates given in
2389 self
.tk
.call(self
._w
, 'scan', 'dragto', x
)
2390 def selection_adjust(self
, index
):
2391 """Adjust the end of the selection near the cursor to INDEX."""
2392 self
.tk
.call(self
._w
, 'selection', 'adjust', index
)
2393 select_adjust
= selection_adjust
2394 def selection_clear(self
):
2395 """Clear the selection if it is in this widget."""
2396 self
.tk
.call(self
._w
, 'selection', 'clear')
2397 select_clear
= selection_clear
2398 def selection_from(self
, index
):
2399 """Set the fixed end of a selection to INDEX."""
2400 self
.tk
.call(self
._w
, 'selection', 'from', index
)
2401 select_from
= selection_from
2402 def selection_present(self
):
2403 """Return whether the widget has the selection."""
2404 return self
.tk
.getboolean(
2405 self
.tk
.call(self
._w
, 'selection', 'present'))
2406 select_present
= selection_present
2407 def selection_range(self
, start
, end
):
2408 """Set the selection from START to END (not included)."""
2409 self
.tk
.call(self
._w
, 'selection', 'range', start
, end
)
2410 select_range
= selection_range
2411 def selection_to(self
, index
):
2412 """Set the variable end of a selection to INDEX."""
2413 self
.tk
.call(self
._w
, 'selection', 'to', index
)
2414 select_to
= selection_to
2415 def xview(self
, index
):
2416 """Query and change horizontal position of the view."""
2417 self
.tk
.call(self
._w
, 'xview', index
)
2418 def xview_moveto(self
, fraction
):
2419 """Adjust the view in the window so that FRACTION of the
2420 total width of the entry is off-screen to the left."""
2421 self
.tk
.call(self
._w
, 'xview', 'moveto', fraction
)
2422 def xview_scroll(self
, number
, what
):
2423 """Shift the x-view according to NUMBER which is measured in "units" or "pages" (WHAT)."""
2424 self
.tk
.call(self
._w
, 'xview', 'scroll', number
, what
)
2426 class Frame(Widget
):
2427 """Frame widget which may contain other widgets and can have a 3D border."""
2428 def __init__(self
, master
=None, cnf
={}, **kw
):
2429 """Construct a frame widget with the parent MASTER.
2431 Valid resource names: background, bd, bg, borderwidth, class,
2432 colormap, container, cursor, height, highlightbackground,
2433 highlightcolor, highlightthickness, relief, takefocus, visual, width."""
2434 cnf
= _cnfmerge((cnf
, kw
))
2436 if cnf
.has_key('class_'):
2437 extra
= ('-class', cnf
['class_'])
2439 elif cnf
.has_key('class'):
2440 extra
= ('-class', cnf
['class'])
2442 Widget
.__init
__(self
, master
, 'frame', cnf
, {}, extra
)
2444 class Label(Widget
):
2445 """Label widget which can display text and bitmaps."""
2446 def __init__(self
, master
=None, cnf
={}, **kw
):
2447 """Construct a label widget with the parent MASTER.
2451 activebackground, activeforeground, anchor,
2452 background, bitmap, borderwidth, cursor,
2453 disabledforeground, font, foreground,
2454 highlightbackground, highlightcolor,
2455 highlightthickness, image, justify,
2456 padx, pady, relief, takefocus, text,
2457 textvariable, underline, wraplength
2459 WIDGET-SPECIFIC OPTIONS
2461 height, state, width
2464 Widget
.__init
__(self
, master
, 'label', cnf
, kw
)
2466 class Listbox(Widget
):
2467 """Listbox widget which can display a list of strings."""
2468 def __init__(self
, master
=None, cnf
={}, **kw
):
2469 """Construct a listbox widget with the parent MASTER.
2471 Valid resource names: background, bd, bg, borderwidth, cursor,
2472 exportselection, fg, font, foreground, height, highlightbackground,
2473 highlightcolor, highlightthickness, relief, selectbackground,
2474 selectborderwidth, selectforeground, selectmode, setgrid, takefocus,
2475 width, xscrollcommand, yscrollcommand, listvariable."""
2476 Widget
.__init
__(self
, master
, 'listbox', cnf
, kw
)
2477 def activate(self
, index
):
2478 """Activate item identified by INDEX."""
2479 self
.tk
.call(self
._w
, 'activate', index
)
2480 def bbox(self
, *args
):
2481 """Return a tuple of X1,Y1,X2,Y2 coordinates for a rectangle
2482 which encloses the item identified by index in ARGS."""
2483 return self
._getints
(
2484 self
.tk
.call((self
._w
, 'bbox') + args
)) or None
2485 def curselection(self
):
2486 """Return list of indices of currently selected item."""
2487 # XXX Ought to apply self._getints()...
2488 return self
.tk
.splitlist(self
.tk
.call(
2489 self
._w
, 'curselection'))
2490 def delete(self
, first
, last
=None):
2491 """Delete items from FIRST to LAST (not included)."""
2492 self
.tk
.call(self
._w
, 'delete', first
, last
)
2493 def get(self
, first
, last
=None):
2494 """Get list of items from FIRST to LAST (not included)."""
2496 return self
.tk
.splitlist(self
.tk
.call(
2497 self
._w
, 'get', first
, last
))
2499 return self
.tk
.call(self
._w
, 'get', first
)
2500 def index(self
, index
):
2501 """Return index of item identified with INDEX."""
2502 i
= self
.tk
.call(self
._w
, 'index', index
)
2503 if i
== 'none': return None
2505 def insert(self
, index
, *elements
):
2506 """Insert ELEMENTS at INDEX."""
2507 self
.tk
.call((self
._w
, 'insert', index
) + elements
)
2508 def nearest(self
, y
):
2509 """Get index of item which is nearest to y coordinate Y."""
2510 return getint(self
.tk
.call(
2511 self
._w
, 'nearest', y
))
2512 def scan_mark(self
, x
, y
):
2513 """Remember the current X, Y coordinates."""
2514 self
.tk
.call(self
._w
, 'scan', 'mark', x
, y
)
2515 def scan_dragto(self
, x
, y
):
2516 """Adjust the view of the listbox to 10 times the
2517 difference between X and Y and the coordinates given in
2519 self
.tk
.call(self
._w
, 'scan', 'dragto', x
, y
)
2520 def see(self
, index
):
2521 """Scroll such that INDEX is visible."""
2522 self
.tk
.call(self
._w
, 'see', index
)
2523 def selection_anchor(self
, index
):
2524 """Set the fixed end oft the selection to INDEX."""
2525 self
.tk
.call(self
._w
, 'selection', 'anchor', index
)
2526 select_anchor
= selection_anchor
2527 def selection_clear(self
, first
, last
=None):
2528 """Clear the selection from FIRST to LAST (not included)."""
2529 self
.tk
.call(self
._w
,
2530 'selection', 'clear', first
, last
)
2531 select_clear
= selection_clear
2532 def selection_includes(self
, index
):
2533 """Return 1 if INDEX is part of the selection."""
2534 return self
.tk
.getboolean(self
.tk
.call(
2535 self
._w
, 'selection', 'includes', index
))
2536 select_includes
= selection_includes
2537 def selection_set(self
, first
, last
=None):
2538 """Set the selection from FIRST to LAST (not included) without
2539 changing the currently selected elements."""
2540 self
.tk
.call(self
._w
, 'selection', 'set', first
, last
)
2541 select_set
= selection_set
2543 """Return the number of elements in the listbox."""
2544 return getint(self
.tk
.call(self
._w
, 'size'))
2545 def xview(self
, *what
):
2546 """Query and change horizontal position of the view."""
2548 return self
._getdoubles
(self
.tk
.call(self
._w
, 'xview'))
2549 self
.tk
.call((self
._w
, 'xview') + what
)
2550 def xview_moveto(self
, fraction
):
2551 """Adjust the view in the window so that FRACTION of the
2552 total width of the entry is off-screen to the left."""
2553 self
.tk
.call(self
._w
, 'xview', 'moveto', fraction
)
2554 def xview_scroll(self
, number
, what
):
2555 """Shift the x-view according to NUMBER which is measured in "units" or "pages" (WHAT)."""
2556 self
.tk
.call(self
._w
, 'xview', 'scroll', number
, what
)
2557 def yview(self
, *what
):
2558 """Query and change vertical position of the view."""
2560 return self
._getdoubles
(self
.tk
.call(self
._w
, 'yview'))
2561 self
.tk
.call((self
._w
, 'yview') + what
)
2562 def yview_moveto(self
, fraction
):
2563 """Adjust the view in the window so that FRACTION of the
2564 total width of the entry is off-screen to the top."""
2565 self
.tk
.call(self
._w
, 'yview', 'moveto', fraction
)
2566 def yview_scroll(self
, number
, what
):
2567 """Shift the y-view according to NUMBER which is measured in "units" or "pages" (WHAT)."""
2568 self
.tk
.call(self
._w
, 'yview', 'scroll', number
, what
)
2569 def itemcget(self
, index
, option
):
2570 """Return the resource value for an ITEM and an OPTION."""
2571 return self
.tk
.call(
2572 (self
._w
, 'itemcget') + (index
, '-'+option
))
2573 def itemconfigure(self
, index
, cnf
=None, **kw
):
2574 """Configure resources of an ITEM.
2576 The values for resources are specified as keyword arguments.
2577 To get an overview about the allowed keyword arguments
2578 call the method without arguments.
2579 Valid resource names: background, bg, foreground, fg,
2580 selectbackground, selectforeground."""
2581 return self
._configure
(('itemconfigure', index
), cnf
, kw
)
2582 itemconfig
= itemconfigure
2585 """Menu widget which allows to display menu bars, pull-down menus and pop-up menus."""
2586 def __init__(self
, master
=None, cnf
={}, **kw
):
2587 """Construct menu widget with the parent MASTER.
2589 Valid resource names: activebackground, activeborderwidth,
2590 activeforeground, background, bd, bg, borderwidth, cursor,
2591 disabledforeground, fg, font, foreground, postcommand, relief,
2592 selectcolor, takefocus, tearoff, tearoffcommand, title, type."""
2593 Widget
.__init
__(self
, master
, 'menu', cnf
, kw
)
2594 def tk_bindForTraversal(self
):
2595 pass # obsolete since Tk 4.0
2596 def tk_mbPost(self
):
2597 self
.tk
.call('tk_mbPost', self
._w
)
2598 def tk_mbUnpost(self
):
2599 self
.tk
.call('tk_mbUnpost')
2600 def tk_traverseToMenu(self
, char
):
2601 self
.tk
.call('tk_traverseToMenu', self
._w
, char
)
2602 def tk_traverseWithinMenu(self
, char
):
2603 self
.tk
.call('tk_traverseWithinMenu', self
._w
, char
)
2604 def tk_getMenuButtons(self
):
2605 return self
.tk
.call('tk_getMenuButtons', self
._w
)
2606 def tk_nextMenu(self
, count
):
2607 self
.tk
.call('tk_nextMenu', count
)
2608 def tk_nextMenuEntry(self
, count
):
2609 self
.tk
.call('tk_nextMenuEntry', count
)
2610 def tk_invokeMenu(self
):
2611 self
.tk
.call('tk_invokeMenu', self
._w
)
2612 def tk_firstMenu(self
):
2613 self
.tk
.call('tk_firstMenu', self
._w
)
2614 def tk_mbButtonDown(self
):
2615 self
.tk
.call('tk_mbButtonDown', self
._w
)
2616 def tk_popup(self
, x
, y
, entry
=""):
2617 """Post the menu at position X,Y with entry ENTRY."""
2618 self
.tk
.call('tk_popup', self
._w
, x
, y
, entry
)
2619 def activate(self
, index
):
2620 """Activate entry at INDEX."""
2621 self
.tk
.call(self
._w
, 'activate', index
)
2622 def add(self
, itemType
, cnf
={}, **kw
):
2623 """Internal function."""
2624 self
.tk
.call((self
._w
, 'add', itemType
) +
2625 self
._options
(cnf
, kw
))
2626 def add_cascade(self
, cnf
={}, **kw
):
2627 """Add hierarchical menu item."""
2628 self
.add('cascade', cnf
or kw
)
2629 def add_checkbutton(self
, cnf
={}, **kw
):
2630 """Add checkbutton menu item."""
2631 self
.add('checkbutton', cnf
or kw
)
2632 def add_command(self
, cnf
={}, **kw
):
2633 """Add command menu item."""
2634 self
.add('command', cnf
or kw
)
2635 def add_radiobutton(self
, cnf
={}, **kw
):
2636 """Addd radio menu item."""
2637 self
.add('radiobutton', cnf
or kw
)
2638 def add_separator(self
, cnf
={}, **kw
):
2639 """Add separator."""
2640 self
.add('separator', cnf
or kw
)
2641 def insert(self
, index
, itemType
, cnf
={}, **kw
):
2642 """Internal function."""
2643 self
.tk
.call((self
._w
, 'insert', index
, itemType
) +
2644 self
._options
(cnf
, kw
))
2645 def insert_cascade(self
, index
, cnf
={}, **kw
):
2646 """Add hierarchical menu item at INDEX."""
2647 self
.insert(index
, 'cascade', cnf
or kw
)
2648 def insert_checkbutton(self
, index
, cnf
={}, **kw
):
2649 """Add checkbutton menu item at INDEX."""
2650 self
.insert(index
, 'checkbutton', cnf
or kw
)
2651 def insert_command(self
, index
, cnf
={}, **kw
):
2652 """Add command menu item at INDEX."""
2653 self
.insert(index
, 'command', cnf
or kw
)
2654 def insert_radiobutton(self
, index
, cnf
={}, **kw
):
2655 """Addd radio menu item at INDEX."""
2656 self
.insert(index
, 'radiobutton', cnf
or kw
)
2657 def insert_separator(self
, index
, cnf
={}, **kw
):
2658 """Add separator at INDEX."""
2659 self
.insert(index
, 'separator', cnf
or kw
)
2660 def delete(self
, index1
, index2
=None):
2661 """Delete menu items between INDEX1 and INDEX2 (not included)."""
2665 (num_index1
, num_index2
) = (self
.index(index1
), self
.index(index2
))
2666 if (num_index1
is not None) and (num_index2
is not None):
2667 for i
in range(num_index1
, num_index2
+ 1):
2668 if 'command' in self
.entryconfig(i
):
2669 c
= str(self
.entrycget(i
, 'command'))
2670 if c
in self
._tclCommands
:
2672 self
.tk
.call(self
._w
, 'delete', index1
, index2
)
2674 self
.deletecommand(c
)
2675 def entrycget(self
, index
, option
):
2676 """Return the resource value of an menu item for OPTION at INDEX."""
2677 return self
.tk
.call(self
._w
, 'entrycget', index
, '-' + option
)
2678 def entryconfigure(self
, index
, cnf
=None, **kw
):
2679 """Configure a menu item at INDEX."""
2680 return self
._configure
(('entryconfigure', index
), cnf
, kw
)
2681 entryconfig
= entryconfigure
2682 def index(self
, index
):
2683 """Return the index of a menu item identified by INDEX."""
2684 i
= self
.tk
.call(self
._w
, 'index', index
)
2685 if i
== 'none': return None
2687 def invoke(self
, index
):
2688 """Invoke a menu item identified by INDEX and execute
2689 the associated command."""
2690 return self
.tk
.call(self
._w
, 'invoke', index
)
2691 def post(self
, x
, y
):
2692 """Display a menu at position X,Y."""
2693 self
.tk
.call(self
._w
, 'post', x
, y
)
2694 def type(self
, index
):
2695 """Return the type of the menu item at INDEX."""
2696 return self
.tk
.call(self
._w
, 'type', index
)
2699 self
.tk
.call(self
._w
, 'unpost')
2700 def yposition(self
, index
):
2701 """Return the y-position of the topmost pixel of the menu item at INDEX."""
2702 return getint(self
.tk
.call(
2703 self
._w
, 'yposition', index
))
2705 class Menubutton(Widget
):
2706 """Menubutton widget, obsolete since Tk8.0."""
2707 def __init__(self
, master
=None, cnf
={}, **kw
):
2708 Widget
.__init
__(self
, master
, 'menubutton', cnf
, kw
)
2710 class Message(Widget
):
2711 """Message widget to display multiline text. Obsolete since Label does it too."""
2712 def __init__(self
, master
=None, cnf
={}, **kw
):
2713 Widget
.__init
__(self
, master
, 'message', cnf
, kw
)
2715 class Radiobutton(Widget
):
2716 """Radiobutton widget which shows only one of several buttons in on-state."""
2717 def __init__(self
, master
=None, cnf
={}, **kw
):
2718 """Construct a radiobutton widget with the parent MASTER.
2720 Valid resource names: activebackground, activeforeground, anchor,
2721 background, bd, bg, bitmap, borderwidth, command, cursor,
2722 disabledforeground, fg, font, foreground, height,
2723 highlightbackground, highlightcolor, highlightthickness, image,
2724 indicatoron, justify, padx, pady, relief, selectcolor, selectimage,
2725 state, takefocus, text, textvariable, underline, value, variable,
2726 width, wraplength."""
2727 Widget
.__init
__(self
, master
, 'radiobutton', cnf
, kw
)
2729 """Put the button in off-state."""
2731 self
.tk
.call(self
._w
, 'deselect')
2733 """Flash the button."""
2734 self
.tk
.call(self
._w
, 'flash')
2736 """Toggle the button and invoke a command if given as resource."""
2737 return self
.tk
.call(self
._w
, 'invoke')
2739 """Put the button in on-state."""
2740 self
.tk
.call(self
._w
, 'select')
2742 class Scale(Widget
):
2743 """Scale widget which can display a numerical scale."""
2744 def __init__(self
, master
=None, cnf
={}, **kw
):
2745 """Construct a scale widget with the parent MASTER.
2747 Valid resource names: activebackground, background, bigincrement, bd,
2748 bg, borderwidth, command, cursor, digits, fg, font, foreground, from,
2749 highlightbackground, highlightcolor, highlightthickness, label,
2750 length, orient, relief, repeatdelay, repeatinterval, resolution,
2751 showvalue, sliderlength, sliderrelief, state, takefocus,
2752 tickinterval, to, troughcolor, variable, width."""
2753 Widget
.__init
__(self
, master
, 'scale', cnf
, kw
)
2755 """Get the current value as integer or float."""
2756 value
= self
.tk
.call(self
._w
, 'get')
2758 return getint(value
)
2760 return getdouble(value
)
2761 def set(self
, value
):
2762 """Set the value to VALUE."""
2763 self
.tk
.call(self
._w
, 'set', value
)
2764 def coords(self
, value
=None):
2765 """Return a tuple (X,Y) of the point along the centerline of the
2766 trough that corresponds to VALUE or the current value if None is
2769 return self
._getints
(self
.tk
.call(self
._w
, 'coords', value
))
2770 def identify(self
, x
, y
):
2771 """Return where the point X,Y lies. Valid return values are "slider",
2772 "though1" and "though2"."""
2773 return self
.tk
.call(self
._w
, 'identify', x
, y
)
2775 class Scrollbar(Widget
):
2776 """Scrollbar widget which displays a slider at a certain position."""
2777 def __init__(self
, master
=None, cnf
={}, **kw
):
2778 """Construct a scrollbar widget with the parent MASTER.
2780 Valid resource names: activebackground, activerelief,
2781 background, bd, bg, borderwidth, command, cursor,
2782 elementborderwidth, highlightbackground,
2783 highlightcolor, highlightthickness, jump, orient,
2784 relief, repeatdelay, repeatinterval, takefocus,
2785 troughcolor, width."""
2786 Widget
.__init
__(self
, master
, 'scrollbar', cnf
, kw
)
2787 def activate(self
, index
):
2788 """Display the element at INDEX with activebackground and activerelief.
2789 INDEX can be "arrow1","slider" or "arrow2"."""
2790 self
.tk
.call(self
._w
, 'activate', index
)
2791 def delta(self
, deltax
, deltay
):
2792 """Return the fractional change of the scrollbar setting if it
2793 would be moved by DELTAX or DELTAY pixels."""
2795 self
.tk
.call(self
._w
, 'delta', deltax
, deltay
))
2796 def fraction(self
, x
, y
):
2797 """Return the fractional value which corresponds to a slider
2799 return getdouble(self
.tk
.call(self
._w
, 'fraction', x
, y
))
2800 def identify(self
, x
, y
):
2801 """Return the element under position X,Y as one of
2802 "arrow1","slider","arrow2" or ""."""
2803 return self
.tk
.call(self
._w
, 'identify', x
, y
)
2805 """Return the current fractional values (upper and lower end)
2806 of the slider position."""
2807 return self
._getdoubles
(self
.tk
.call(self
._w
, 'get'))
2808 def set(self
, *args
):
2809 """Set the fractional values of the slider position (upper and
2810 lower ends as value between 0 and 1)."""
2811 self
.tk
.call((self
._w
, 'set') + args
)
2816 """Text widget which can display text in various forms."""
2817 def __init__(self
, master
=None, cnf
={}, **kw
):
2818 """Construct a text widget with the parent MASTER.
2822 background, borderwidth, cursor,
2823 exportselection, font, foreground,
2824 highlightbackground, highlightcolor,
2825 highlightthickness, insertbackground,
2826 insertborderwidth, insertofftime,
2827 insertontime, insertwidth, padx, pady,
2828 relief, selectbackground,
2829 selectborderwidth, selectforeground,
2831 xscrollcommand, yscrollcommand,
2833 WIDGET-SPECIFIC OPTIONS
2835 autoseparators, height, maxundo,
2836 spacing1, spacing2, spacing3,
2837 state, tabs, undo, width, wrap,
2840 Widget
.__init
__(self
, master
, 'text', cnf
, kw
)
2841 def bbox(self
, *args
):
2842 """Return a tuple of (x,y,width,height) which gives the bounding
2843 box of the visible part of the character at the index in ARGS."""
2844 return self
._getints
(
2845 self
.tk
.call((self
._w
, 'bbox') + args
)) or None
2846 def tk_textSelectTo(self
, index
):
2847 self
.tk
.call('tk_textSelectTo', self
._w
, index
)
2848 def tk_textBackspace(self
):
2849 self
.tk
.call('tk_textBackspace', self
._w
)
2850 def tk_textIndexCloser(self
, a
, b
, c
):
2851 self
.tk
.call('tk_textIndexCloser', self
._w
, a
, b
, c
)
2852 def tk_textResetAnchor(self
, index
):
2853 self
.tk
.call('tk_textResetAnchor', self
._w
, index
)
2854 def compare(self
, index1
, op
, index2
):
2855 """Return whether between index INDEX1 and index INDEX2 the
2856 relation OP is satisfied. OP is one of <, <=, ==, >=, >, or !=."""
2857 return self
.tk
.getboolean(self
.tk
.call(
2858 self
._w
, 'compare', index1
, op
, index2
))
2859 def debug(self
, boolean
=None):
2860 """Turn on the internal consistency checks of the B-Tree inside the text
2861 widget according to BOOLEAN."""
2862 return self
.tk
.getboolean(self
.tk
.call(
2863 self
._w
, 'debug', boolean
))
2864 def delete(self
, index1
, index2
=None):
2865 """Delete the characters between INDEX1 and INDEX2 (not included)."""
2866 self
.tk
.call(self
._w
, 'delete', index1
, index2
)
2867 def dlineinfo(self
, index
):
2868 """Return tuple (x,y,width,height,baseline) giving the bounding box
2869 and baseline position of the visible part of the line containing
2870 the character at INDEX."""
2871 return self
._getints
(self
.tk
.call(self
._w
, 'dlineinfo', index
))
2872 def dump(self
, index1
, index2
=None, command
=None, **kw
):
2873 """Return the contents of the widget between index1 and index2.
2875 The type of contents returned in filtered based on the keyword
2876 parameters; if 'all', 'image', 'mark', 'tag', 'text', or 'window' are
2877 given and true, then the corresponding items are returned. The result
2878 is a list of triples of the form (key, value, index). If none of the
2879 keywords are true then 'all' is used by default.
2881 If the 'command' argument is given, it is called once for each element
2882 of the list of triples, with the values of each triple serving as the
2883 arguments to the function. In this case the list is not returned."""
2888 # Never call the dump command without the -command flag, since the
2889 # output could involve Tcl quoting and would be a pain to parse
2890 # right. Instead just set the command to build a list of triples
2891 # as if we had done the parsing.
2893 def append_triple(key
, value
, index
, result
=result
):
2894 result
.append((key
, value
, index
))
2895 command
= append_triple
2897 if not isinstance(command
, str):
2898 func_name
= command
= self
._register
(command
)
2899 args
+= ["-command", command
]
2901 if kw
[key
]: args
.append("-" + key
)
2905 self
.tk
.call(self
._w
, "dump", *args
)
2909 self
.deletecommand(func_name
)
2912 def edit(self
, *args
):
2915 This method controls the undo mechanism and
2916 the modified flag. The exact behavior of the
2917 command depends on the option argument that
2918 follows the edit argument. The following forms
2919 of the command are currently supported:
2921 edit_modified, edit_redo, edit_reset, edit_separator
2925 return self
.tk
.call(self
._w
, 'edit', *args
)
2927 def edit_modified(self
, arg
=None):
2928 """Get or Set the modified flag
2930 If arg is not specified, returns the modified
2931 flag of the widget. The insert, delete, edit undo and
2932 edit redo commands or the user can set or clear the
2933 modified flag. If boolean is specified, sets the
2934 modified flag of the widget to arg.
2936 return self
.edit("modified", arg
)
2938 def edit_redo(self
):
2939 """Redo the last undone edit
2941 When the undo option is true, reapplies the last
2942 undone edits provided no other edits were done since
2943 then. Generates an error when the redo stack is empty.
2944 Does nothing when the undo option is false.
2946 return self
.edit("redo")
2948 def edit_reset(self
):
2949 """Clears the undo and redo stacks
2951 return self
.edit("reset")
2953 def edit_separator(self
):
2954 """Inserts a separator (boundary) on the undo stack.
2956 Does nothing when the undo option is false
2958 return self
.edit("separator")
2960 def edit_undo(self
):
2961 """Undoes the last edit action
2963 If the undo option is true. An edit action is defined
2964 as all the insert and delete commands that are recorded
2965 on the undo stack in between two separators. Generates
2966 an error when the undo stack is empty. Does nothing
2967 when the undo option is false
2969 return self
.edit("undo")
2971 def get(self
, index1
, index2
=None):
2972 """Return the text from INDEX1 to INDEX2 (not included)."""
2973 return self
.tk
.call(self
._w
, 'get', index1
, index2
)
2974 # (Image commands are new in 8.0)
2975 def image_cget(self
, index
, option
):
2976 """Return the value of OPTION of an embedded image at INDEX."""
2977 if option
[:1] != "-":
2978 option
= "-" + option
2979 if option
[-1:] == "_":
2980 option
= option
[:-1]
2981 return self
.tk
.call(self
._w
, "image", "cget", index
, option
)
2982 def image_configure(self
, index
, cnf
=None, **kw
):
2983 """Configure an embedded image at INDEX."""
2984 return self
._configure
(('image', 'configure', index
), cnf
, kw
)
2985 def image_create(self
, index
, cnf
={}, **kw
):
2986 """Create an embedded image at INDEX."""
2987 return self
.tk
.call(
2988 self
._w
, "image", "create", index
,
2989 *self
._options
(cnf
, kw
))
2990 def image_names(self
):
2991 """Return all names of embedded images in this widget."""
2992 return self
.tk
.call(self
._w
, "image", "names")
2993 def index(self
, index
):
2994 """Return the index in the form line.char for INDEX."""
2995 return str(self
.tk
.call(self
._w
, 'index', index
))
2996 def insert(self
, index
, chars
, *args
):
2997 """Insert CHARS before the characters at INDEX. An additional
2998 tag can be given in ARGS. Additional CHARS and tags can follow in ARGS."""
2999 self
.tk
.call((self
._w
, 'insert', index
, chars
) + args
)
3000 def mark_gravity(self
, markName
, direction
=None):
3001 """Change the gravity of a mark MARKNAME to DIRECTION (LEFT or RIGHT).
3002 Return the current value if None is given for DIRECTION."""
3003 return self
.tk
.call(
3004 (self
._w
, 'mark', 'gravity', markName
, direction
))
3005 def mark_names(self
):
3006 """Return all mark names."""
3007 return self
.tk
.splitlist(self
.tk
.call(
3008 self
._w
, 'mark', 'names'))
3009 def mark_set(self
, markName
, index
):
3010 """Set mark MARKNAME before the character at INDEX."""
3011 self
.tk
.call(self
._w
, 'mark', 'set', markName
, index
)
3012 def mark_unset(self
, *markNames
):
3013 """Delete all marks in MARKNAMES."""
3014 self
.tk
.call((self
._w
, 'mark', 'unset') + markNames
)
3015 def mark_next(self
, index
):
3016 """Return the name of the next mark after INDEX."""
3017 return self
.tk
.call(self
._w
, 'mark', 'next', index
) or None
3018 def mark_previous(self
, index
):
3019 """Return the name of the previous mark before INDEX."""
3020 return self
.tk
.call(self
._w
, 'mark', 'previous', index
) or None
3021 def scan_mark(self
, x
, y
):
3022 """Remember the current X, Y coordinates."""
3023 self
.tk
.call(self
._w
, 'scan', 'mark', x
, y
)
3024 def scan_dragto(self
, x
, y
):
3025 """Adjust the view of the text to 10 times the
3026 difference between X and Y and the coordinates given in
3028 self
.tk
.call(self
._w
, 'scan', 'dragto', x
, y
)
3029 def search(self
, pattern
, index
, stopindex
=None,
3030 forwards
=None, backwards
=None, exact
=None,
3031 regexp
=None, nocase
=None, count
=None, elide
=None):
3032 """Search PATTERN beginning from INDEX until STOPINDEX.
3033 Return the index of the first character of a match or an empty string."""
3034 args
= [self
._w
, 'search']
3035 if forwards
: args
.append('-forwards')
3036 if backwards
: args
.append('-backwards')
3037 if exact
: args
.append('-exact')
3038 if regexp
: args
.append('-regexp')
3039 if nocase
: args
.append('-nocase')
3040 if elide
: args
.append('-elide')
3041 if count
: args
.append('-count'); args
.append(count
)
3042 if pattern
[0] == '-': args
.append('--')
3043 args
.append(pattern
)
3045 if stopindex
: args
.append(stopindex
)
3046 return self
.tk
.call(tuple(args
))
3047 def see(self
, index
):
3048 """Scroll such that the character at INDEX is visible."""
3049 self
.tk
.call(self
._w
, 'see', index
)
3050 def tag_add(self
, tagName
, index1
, *args
):
3051 """Add tag TAGNAME to all characters between INDEX1 and index2 in ARGS.
3052 Additional pairs of indices may follow in ARGS."""
3054 (self
._w
, 'tag', 'add', tagName
, index1
) + args
)
3055 def tag_unbind(self
, tagName
, sequence
, funcid
=None):
3056 """Unbind for all characters with TAGNAME for event SEQUENCE the
3057 function identified with FUNCID."""
3058 self
.tk
.call(self
._w
, 'tag', 'bind', tagName
, sequence
, '')
3060 self
.deletecommand(funcid
)
3061 def tag_bind(self
, tagName
, sequence
, func
, add
=None):
3062 """Bind to all characters with TAGNAME at event SEQUENCE a call to function FUNC.
3064 An additional boolean parameter ADD specifies whether FUNC will be
3065 called additionally to the other bound function or whether it will
3066 replace the previous function. See bind for the return value."""
3067 return self
._bind
((self
._w
, 'tag', 'bind', tagName
),
3068 sequence
, func
, add
)
3069 def tag_cget(self
, tagName
, option
):
3070 """Return the value of OPTION for tag TAGNAME."""
3071 if option
[:1] != '-':
3072 option
= '-' + option
3073 if option
[-1:] == '_':
3074 option
= option
[:-1]
3075 return self
.tk
.call(self
._w
, 'tag', 'cget', tagName
, option
)
3076 def tag_configure(self
, tagName
, cnf
=None, **kw
):
3077 """Configure a tag TAGNAME."""
3078 return self
._configure
(('tag', 'configure', tagName
), cnf
, kw
)
3079 tag_config
= tag_configure
3080 def tag_delete(self
, *tagNames
):
3081 """Delete all tags in TAGNAMES."""
3082 self
.tk
.call((self
._w
, 'tag', 'delete') + tagNames
)
3083 def tag_lower(self
, tagName
, belowThis
=None):
3084 """Change the priority of tag TAGNAME such that it is lower
3085 than the priority of BELOWTHIS."""
3086 self
.tk
.call(self
._w
, 'tag', 'lower', tagName
, belowThis
)
3087 def tag_names(self
, index
=None):
3088 """Return a list of all tag names."""
3089 return self
.tk
.splitlist(
3090 self
.tk
.call(self
._w
, 'tag', 'names', index
))
3091 def tag_nextrange(self
, tagName
, index1
, index2
=None):
3092 """Return a list of start and end index for the first sequence of
3093 characters between INDEX1 and INDEX2 which all have tag TAGNAME.
3094 The text is searched forward from INDEX1."""
3095 return self
.tk
.splitlist(self
.tk
.call(
3096 self
._w
, 'tag', 'nextrange', tagName
, index1
, index2
))
3097 def tag_prevrange(self
, tagName
, index1
, index2
=None):
3098 """Return a list of start and end index for the first sequence of
3099 characters between INDEX1 and INDEX2 which all have tag TAGNAME.
3100 The text is searched backwards from INDEX1."""
3101 return self
.tk
.splitlist(self
.tk
.call(
3102 self
._w
, 'tag', 'prevrange', tagName
, index1
, index2
))
3103 def tag_raise(self
, tagName
, aboveThis
=None):
3104 """Change the priority of tag TAGNAME such that it is higher
3105 than the priority of ABOVETHIS."""
3107 self
._w
, 'tag', 'raise', tagName
, aboveThis
)
3108 def tag_ranges(self
, tagName
):
3109 """Return a list of ranges of text which have tag TAGNAME."""
3110 return self
.tk
.splitlist(self
.tk
.call(
3111 self
._w
, 'tag', 'ranges', tagName
))
3112 def tag_remove(self
, tagName
, index1
, index2
=None):
3113 """Remove tag TAGNAME from all characters between INDEX1 and INDEX2."""
3115 self
._w
, 'tag', 'remove', tagName
, index1
, index2
)
3116 def window_cget(self
, index
, option
):
3117 """Return the value of OPTION of an embedded window at INDEX."""
3118 if option
[:1] != '-':
3119 option
= '-' + option
3120 if option
[-1:] == '_':
3121 option
= option
[:-1]
3122 return self
.tk
.call(self
._w
, 'window', 'cget', index
, option
)
3123 def window_configure(self
, index
, cnf
=None, **kw
):
3124 """Configure an embedded window at INDEX."""
3125 return self
._configure
(('window', 'configure', index
), cnf
, kw
)
3126 window_config
= window_configure
3127 def window_create(self
, index
, cnf
={}, **kw
):
3128 """Create a window at INDEX."""
3130 (self
._w
, 'window', 'create', index
)
3131 + self
._options
(cnf
, kw
))
3132 def window_names(self
):
3133 """Return all names of embedded windows in this widget."""
3134 return self
.tk
.splitlist(
3135 self
.tk
.call(self
._w
, 'window', 'names'))
3136 def xview(self
, *what
):
3137 """Query and change horizontal position of the view."""
3139 return self
._getdoubles
(self
.tk
.call(self
._w
, 'xview'))
3140 self
.tk
.call((self
._w
, 'xview') + what
)
3141 def xview_moveto(self
, fraction
):
3142 """Adjusts the view in the window so that FRACTION of the
3143 total width of the canvas is off-screen to the left."""
3144 self
.tk
.call(self
._w
, 'xview', 'moveto', fraction
)
3145 def xview_scroll(self
, number
, what
):
3146 """Shift the x-view according to NUMBER which is measured
3147 in "units" or "pages" (WHAT)."""
3148 self
.tk
.call(self
._w
, 'xview', 'scroll', number
, what
)
3149 def yview(self
, *what
):
3150 """Query and change vertical position of the view."""
3152 return self
._getdoubles
(self
.tk
.call(self
._w
, 'yview'))
3153 self
.tk
.call((self
._w
, 'yview') + what
)
3154 def yview_moveto(self
, fraction
):
3155 """Adjusts the view in the window so that FRACTION of the
3156 total height of the canvas is off-screen to the top."""
3157 self
.tk
.call(self
._w
, 'yview', 'moveto', fraction
)
3158 def yview_scroll(self
, number
, what
):
3159 """Shift the y-view according to NUMBER which is measured
3160 in "units" or "pages" (WHAT)."""
3161 self
.tk
.call(self
._w
, 'yview', 'scroll', number
, what
)
3162 def yview_pickplace(self
, *what
):
3163 """Obsolete function, use see."""
3164 self
.tk
.call((self
._w
, 'yview', '-pickplace') + what
)
3168 """Internal class. It wraps the command in the widget OptionMenu."""
3169 def __init__(self
, var
, value
, callback
=None):
3170 self
.__value
= value
3172 self
.__callback
= callback
3173 def __call__(self
, *args
):
3174 self
.__var
.set(self
.__value
)
3176 self
.__callback
(self
.__value
, *args
)
3178 class OptionMenu(Menubutton
):
3179 """OptionMenu which allows the user to select a value from a menu."""
3180 def __init__(self
, master
, variable
, value
, *values
, **kwargs
):
3181 """Construct an optionmenu widget with the parent MASTER, with
3182 the resource textvariable set to VARIABLE, the initially selected
3183 value VALUE, the other menu values VALUES and an additional
3184 keyword argument command."""
3185 kw
= {"borderwidth": 2, "textvariable": variable
,
3186 "indicatoron": 1, "relief": RAISED
, "anchor": "c",
3187 "highlightthickness": 2}
3188 Widget
.__init
__(self
, master
, "menubutton", kw
)
3189 self
.widgetName
= 'tk_optionMenu'
3190 menu
= self
.__menu
= Menu(self
, name
="menu", tearoff
=0)
3191 self
.menuname
= menu
._w
3192 # 'command' is the only supported keyword
3193 callback
= kwargs
.get('command')
3194 if kwargs
.has_key('command'):
3195 del kwargs
['command']
3197 raise TclError
, 'unknown option -'+kwargs
.keys()[0]
3198 menu
.add_command(label
=value
,
3199 command
=_setit(variable
, value
, callback
))
3201 menu
.add_command(label
=v
,
3202 command
=_setit(variable
, v
, callback
))
3205 def __getitem__(self
, name
):
3208 return Widget
.__getitem
__(self
, name
)
3211 """Destroy this widget and the associated menu."""
3212 Menubutton
.destroy(self
)
3216 """Base class for images."""
3218 def __init__(self
, imgtype
, name
=None, cnf
={}, master
=None, **kw
):
3221 master
= _default_root
3223 raise RuntimeError, 'Too early to create image'
3227 name
= "pyimage%r" % (Image
._last
_id
,) # tk itself would use image<x>
3228 # The following is needed for systems where id(x)
3229 # can return a negative number, such as Linux/m68k:
3230 if name
[0] == '-': name
= '_' + name
[1:]
3231 if kw
and cnf
: cnf
= _cnfmerge((cnf
, kw
))
3234 for k
, v
in cnf
.items():
3236 v
= self
._register
(v
)
3237 options
= options
+ ('-'+k
, v
)
3238 self
.tk
.call(('image', 'create', imgtype
, name
,) + options
)
3240 def __str__(self
): return self
.name
3244 self
.tk
.call('image', 'delete', self
.name
)
3246 # May happen if the root was destroyed
3248 def __setitem__(self
, key
, value
):
3249 self
.tk
.call(self
.name
, 'configure', '-'+key
, value
)
3250 def __getitem__(self
, key
):
3251 return self
.tk
.call(self
.name
, 'configure', '-'+key
)
3252 def configure(self
, **kw
):
3253 """Configure the image."""
3255 for k
, v
in _cnfmerge(kw
).items():
3257 if k
[-1] == '_': k
= k
[:-1]
3259 v
= self
._register
(v
)
3260 res
= res
+ ('-'+k
, v
)
3261 self
.tk
.call((self
.name
, 'config') + res
)
3264 """Return the height of the image."""
3266 self
.tk
.call('image', 'height', self
.name
))
3268 """Return the type of the imgage, e.g. "photo" or "bitmap"."""
3269 return self
.tk
.call('image', 'type', self
.name
)
3271 """Return the width of the image."""
3273 self
.tk
.call('image', 'width', self
.name
))
3275 class PhotoImage(Image
):
3276 """Widget which can display colored images in GIF, PPM/PGM format."""
3277 def __init__(self
, name
=None, cnf
={}, master
=None, **kw
):
3278 """Create an image with NAME.
3280 Valid resource names: data, format, file, gamma, height, palette,
3282 Image
.__init
__(self
, 'photo', name
, cnf
, master
, **kw
)
3284 """Display a transparent image."""
3285 self
.tk
.call(self
.name
, 'blank')
3286 def cget(self
, option
):
3287 """Return the value of OPTION."""
3288 return self
.tk
.call(self
.name
, 'cget', '-' + option
)
3290 def __getitem__(self
, key
):
3291 return self
.tk
.call(self
.name
, 'cget', '-' + key
)
3292 # XXX copy -from, -to, ...?
3294 """Return a new PhotoImage with the same image as this widget."""
3295 destImage
= PhotoImage()
3296 self
.tk
.call(destImage
, 'copy', self
.name
)
3298 def zoom(self
,x
,y
=''):
3299 """Return a new PhotoImage with the same image as this widget
3300 but zoom it with X and Y."""
3301 destImage
= PhotoImage()
3303 self
.tk
.call(destImage
, 'copy', self
.name
, '-zoom',x
,y
)
3305 def subsample(self
,x
,y
=''):
3306 """Return a new PhotoImage based on the same image as this widget
3307 but use only every Xth or Yth pixel."""
3308 destImage
= PhotoImage()
3310 self
.tk
.call(destImage
, 'copy', self
.name
, '-subsample',x
,y
)
3312 def get(self
, x
, y
):
3313 """Return the color (red, green, blue) of the pixel at X,Y."""
3314 return self
.tk
.call(self
.name
, 'get', x
, y
)
3315 def put(self
, data
, to
=None):
3316 """Put row formated colors to image starting from
3317 position TO, e.g. image.put("{red green} {blue yellow}", to=(4,6))"""
3318 args
= (self
.name
, 'put', data
)
3322 args
= args
+ ('-to',) + tuple(to
)
3325 def write(self
, filename
, format
=None, from_coords
=None):
3326 """Write image to file FILENAME in FORMAT starting from
3327 position FROM_COORDS."""
3328 args
= (self
.name
, 'write', filename
)
3330 args
= args
+ ('-format', format
)
3332 args
= args
+ ('-from',) + tuple(from_coords
)
3335 class BitmapImage(Image
):
3336 """Widget which can display a bitmap."""
3337 def __init__(self
, name
=None, cnf
={}, master
=None, **kw
):
3338 """Create a bitmap with NAME.
3340 Valid resource names: background, data, file, foreground, maskdata, maskfile."""
3341 Image
.__init
__(self
, 'bitmap', name
, cnf
, master
, **kw
)
3343 def image_names(): return _default_root
.tk
.call('image', 'names')
3344 def image_types(): return _default_root
.tk
.call('image', 'types')
3347 class Spinbox(Widget
):
3348 """spinbox widget."""
3349 def __init__(self
, master
=None, cnf
={}, **kw
):
3350 """Construct a spinbox widget with the parent MASTER.
3354 activebackground, background, borderwidth,
3355 cursor, exportselection, font, foreground,
3356 highlightbackground, highlightcolor,
3357 highlightthickness, insertbackground,
3358 insertborderwidth, insertofftime,
3359 insertontime, insertwidth, justify, relief,
3360 repeatdelay, repeatinterval,
3361 selectbackground, selectborderwidth
3362 selectforeground, takefocus, textvariable
3365 WIDGET-SPECIFIC OPTIONS
3367 buttonbackground, buttoncursor,
3368 buttondownrelief, buttonuprelief,
3369 command, disabledbackground,
3370 disabledforeground, format, from,
3371 invalidcommand, increment,
3372 readonlybackground, state, to,
3373 validate, validatecommand values,
3376 Widget
.__init
__(self
, master
, 'spinbox', cnf
, kw
)
3378 def bbox(self
, index
):
3379 """Return a tuple of X1,Y1,X2,Y2 coordinates for a
3380 rectangle which encloses the character given by index.
3382 The first two elements of the list give the x and y
3383 coordinates of the upper-left corner of the screen
3384 area covered by the character (in pixels relative
3385 to the widget) and the last two elements give the
3386 width and height of the character, in pixels. The
3387 bounding box may refer to a region outside the
3388 visible area of the window.
3390 return self
.tk
.call(self
._w
, 'bbox', index
)
3392 def delete(self
, first
, last
=None):
3393 """Delete one or more elements of the spinbox.
3395 First is the index of the first character to delete,
3396 and last is the index of the character just after
3397 the last one to delete. If last isn't specified it
3398 defaults to first+1, i.e. a single character is
3399 deleted. This command returns an empty string.
3401 return self
.tk
.call(self
._w
, 'delete', first
, last
)
3404 """Returns the spinbox's string"""
3405 return self
.tk
.call(self
._w
, 'get')
3407 def icursor(self
, index
):
3408 """Alter the position of the insertion cursor.
3410 The insertion cursor will be displayed just before
3411 the character given by index. Returns an empty string
3413 return self
.tk
.call(self
._w
, 'icursor', index
)
3415 def identify(self
, x
, y
):
3416 """Returns the name of the widget at position x, y
3418 Return value is one of: none, buttondown, buttonup, entry
3420 return self
.tk
.call(self
._w
, 'identify', x
, y
)
3422 def index(self
, index
):
3423 """Returns the numerical index corresponding to index
3425 return self
.tk
.call(self
._w
, 'index', index
)
3427 def insert(self
, index
, s
):
3428 """Insert string s at index
3430 Returns an empty string.
3432 return self
.tk
.call(self
._w
, 'insert', index
, s
)
3434 def invoke(self
, element
):
3435 """Causes the specified element to be invoked
3437 The element could be buttondown or buttonup
3438 triggering the action associated with it.
3440 return self
.tk
.call(self
._w
, 'invoke', element
)
3442 def scan(self
, *args
):
3443 """Internal function."""
3444 return self
._getints
(
3445 self
.tk
.call((self
._w
, 'scan') + args
)) or ()
3447 def scan_mark(self
, x
):
3448 """Records x and the current view in the spinbox window;
3450 used in conjunction with later scan dragto commands.
3451 Typically this command is associated with a mouse button
3452 press in the widget. It returns an empty string.
3454 return self
.scan("mark", x
)
3456 def scan_dragto(self
, x
):
3457 """Compute the difference between the given x argument
3458 and the x argument to the last scan mark command
3460 It then adjusts the view left or right by 10 times the
3461 difference in x-coordinates. This command is typically
3462 associated with mouse motion events in the widget, to
3463 produce the effect of dragging the spinbox at high speed
3464 through the window. The return value is an empty string.
3466 return self
.scan("dragto", x
)
3468 def selection(self
, *args
):
3469 """Internal function."""
3470 return self
._getints
(
3471 self
.tk
.call((self
._w
, 'selection') + args
)) or ()
3473 def selection_adjust(self
, index
):
3474 """Locate the end of the selection nearest to the character
3477 Then adjust that end of the selection to be at index
3478 (i.e including but not going beyond index). The other
3479 end of the selection is made the anchor point for future
3480 select to commands. If the selection isn't currently in
3481 the spinbox, then a new selection is created to include
3482 the characters between index and the most recent selection
3483 anchor point, inclusive. Returns an empty string.
3485 return self
.selection("adjust", index
)
3487 def selection_clear(self
):
3488 """Clear the selection
3490 If the selection isn't in this widget then the
3491 command has no effect. Returns an empty string.
3493 return self
.selection("clear")
3495 def selection_element(self
, element
=None):
3496 """Sets or gets the currently selected element.
3498 If a spinbutton element is specified, it will be
3501 return self
.selection("element", element
)
3503 ###########################################################################
3505 class LabelFrame(Widget
):
3506 """labelframe widget."""
3507 def __init__(self
, master
=None, cnf
={}, **kw
):
3508 """Construct a labelframe widget with the parent MASTER.
3512 borderwidth, cursor, font, foreground,
3513 highlightbackground, highlightcolor,
3514 highlightthickness, padx, pady, relief,
3517 WIDGET-SPECIFIC OPTIONS
3519 background, class, colormap, container,
3520 height, labelanchor, labelwidget,
3523 Widget
.__init
__(self
, master
, 'labelframe', cnf
, kw
)
3525 ########################################################################
3527 class PanedWindow(Widget
):
3528 """panedwindow widget."""
3529 def __init__(self
, master
=None, cnf
={}, **kw
):
3530 """Construct a panedwindow widget with the parent MASTER.
3534 background, borderwidth, cursor, height,
3535 orient, relief, width
3537 WIDGET-SPECIFIC OPTIONS
3539 handlepad, handlesize, opaqueresize,
3540 sashcursor, sashpad, sashrelief,
3541 sashwidth, showhandle,
3543 Widget
.__init
__(self
, master
, 'panedwindow', cnf
, kw
)
3545 def add(self
, child
, **kw
):
3546 """Add a child widget to the panedwindow in a new pane.
3548 The child argument is the name of the child widget
3549 followed by pairs of arguments that specify how to
3550 manage the windows. Options may have any of the values
3551 accepted by the configure subcommand.
3553 self
.tk
.call((self
._w
, 'add', child
) + self
._options
(kw
))
3555 def remove(self
, child
):
3556 """Remove the pane containing child from the panedwindow
3558 All geometry management options for child will be forgotten.
3560 self
.tk
.call(self
._w
, 'forget', child
)
3563 def identify(self
, x
, y
):
3564 """Identify the panedwindow component at point x, y
3566 If the point is over a sash or a sash handle, the result
3567 is a two element list containing the index of the sash or
3568 handle, and a word indicating whether it is over a sash
3569 or a handle, such as {0 sash} or {2 handle}. If the point
3570 is over any other part of the panedwindow, the result is
3573 return self
.tk
.call(self
._w
, 'identify', x
, y
)
3575 def proxy(self
, *args
):
3576 """Internal function."""
3577 return self
._getints
(
3578 self
.tk
.call((self
._w
, 'proxy') + args
)) or ()
3580 def proxy_coord(self
):
3581 """Return the x and y pair of the most recent proxy location
3583 return self
.proxy("coord")
3585 def proxy_forget(self
):
3586 """Remove the proxy from the display.
3588 return self
.proxy("forget")
3590 def proxy_place(self
, x
, y
):
3591 """Place the proxy at the given x and y coordinates.
3593 return self
.proxy("place", x
, y
)
3595 def sash(self
, *args
):
3596 """Internal function."""
3597 return self
._getints
(
3598 self
.tk
.call((self
._w
, 'sash') + args
)) or ()
3600 def sash_coord(self
, index
):
3601 """Return the current x and y pair for the sash given by index.
3603 Index must be an integer between 0 and 1 less than the
3604 number of panes in the panedwindow. The coordinates given are
3605 those of the top left corner of the region containing the sash.
3606 pathName sash dragto index x y This command computes the
3607 difference between the given coordinates and the coordinates
3608 given to the last sash coord command for the given sash. It then
3609 moves that sash the computed difference. The return value is the
3612 return self
.sash("coord", index
)
3614 def sash_mark(self
, index
):
3615 """Records x and y for the sash given by index;
3617 Used in conjunction with later dragto commands to move the sash.
3619 return self
.sash("mark", index
)
3621 def sash_place(self
, index
, x
, y
):
3622 """Place the sash given by index at the given coordinates
3624 return self
.sash("place", index
, x
, y
)
3626 def panecget(self
, child
, option
):
3627 """Query a management option for window.
3629 Option may be any value allowed by the paneconfigure subcommand
3631 return self
.tk
.call(
3632 (self
._w
, 'panecget') + (child
, '-'+option
))
3634 def paneconfigure(self
, tagOrId
, cnf
=None, **kw
):
3635 """Query or modify the management options for window.
3637 If no option is specified, returns a list describing all
3638 of the available options for pathName. If option is
3639 specified with no value, then the command returns a list
3640 describing the one named option (this list will be identical
3641 to the corresponding sublist of the value returned if no
3642 option is specified). If one or more option-value pairs are
3643 specified, then the command modifies the given widget
3644 option(s) to have the given value(s); in this case the
3645 command returns an empty string. The following options
3649 Insert the window after the window specified. window
3650 should be the name of a window already managed by pathName.
3652 Insert the window before the window specified. window
3653 should be the name of a window already managed by pathName.
3655 Specify a height for the window. The height will be the
3656 outer dimension of the window including its border, if
3657 any. If size is an empty string, or if -height is not
3658 specified, then the height requested internally by the
3659 window will be used initially; the height may later be
3660 adjusted by the movement of sashes in the panedwindow.
3661 Size may be any value accepted by Tk_GetPixels.
3663 Specifies that the size of the window cannot be made
3664 less than n. This constraint only affects the size of
3665 the widget in the paned dimension -- the x dimension
3666 for horizontal panedwindows, the y dimension for
3667 vertical panedwindows. May be any value accepted by
3670 Specifies a non-negative value indicating how much
3671 extra space to leave on each side of the window in
3672 the X-direction. The value may have any of the forms
3673 accepted by Tk_GetPixels.
3675 Specifies a non-negative value indicating how much
3676 extra space to leave on each side of the window in
3677 the Y-direction. The value may have any of the forms
3678 accepted by Tk_GetPixels.
3680 If a window's pane is larger than the requested
3681 dimensions of the window, this option may be used
3682 to position (or stretch) the window within its pane.
3683 Style is a string that contains zero or more of the
3684 characters n, s, e or w. The string can optionally
3685 contains spaces or commas, but they are ignored. Each
3686 letter refers to a side (north, south, east, or west)
3687 that the window will "stick" to. If both n and s
3688 (or e and w) are specified, the window will be
3689 stretched to fill the entire height (or width) of
3692 Specify a width for the window. The width will be
3693 the outer dimension of the window including its
3694 border, if any. If size is an empty string, or
3695 if -width is not specified, then the width requested
3696 internally by the window will be used initially; the
3697 width may later be adjusted by the movement of sashes
3698 in the panedwindow. Size may be any value accepted by
3702 if cnf
is None and not kw
:
3704 for x
in self
.tk
.split(
3705 self
.tk
.call(self
._w
,
3706 'paneconfigure', tagOrId
)):
3707 cnf
[x
[0][1:]] = (x
[0][1:],) + x
[1:]
3709 if type(cnf
) == StringType
and not kw
:
3710 x
= self
.tk
.split(self
.tk
.call(
3711 self
._w
, 'paneconfigure', tagOrId
, '-'+cnf
))
3712 return (x
[0][1:],) + x
[1:]
3713 self
.tk
.call((self
._w
, 'paneconfigure', tagOrId
) +
3714 self
._options
(cnf
, kw
))
3715 paneconfig
= paneconfigure
3718 """Returns an ordered list of the child panes."""
3719 return self
.tk
.call(self
._w
, 'panes')
3721 ######################################################################
3724 class Studbutton(Button
):
3725 def __init__(self
, master
=None, cnf
={}, **kw
):
3726 Widget
.__init
__(self
, master
, 'studbutton', cnf
, kw
)
3727 self
.bind('<Any-Enter>', self
.tkButtonEnter
)
3728 self
.bind('<Any-Leave>', self
.tkButtonLeave
)
3729 self
.bind('<1>', self
.tkButtonDown
)
3730 self
.bind('<ButtonRelease-1>', self
.tkButtonUp
)
3732 class Tributton(Button
):
3733 def __init__(self
, master
=None, cnf
={}, **kw
):
3734 Widget
.__init
__(self
, master
, 'tributton', cnf
, kw
)
3735 self
.bind('<Any-Enter>', self
.tkButtonEnter
)
3736 self
.bind('<Any-Leave>', self
.tkButtonLeave
)
3737 self
.bind('<1>', self
.tkButtonDown
)
3738 self
.bind('<ButtonRelease-1>', self
.tkButtonUp
)
3739 self
['fg'] = self
['bg']
3740 self
['activebackground'] = self
['bg']
3742 ######################################################################
3747 text
= "This is Tcl/Tk version %s" % TclVersion
3748 if TclVersion
>= 8.1:
3750 text
= text
+ unicode("\nThis should be a cedilla: \347",
3753 pass # no unicode support
3754 label
= Label(root
, text
=text
)
3756 test
= Button(root
, text
="Click me!",
3757 command
=lambda root
=root
: root
.test
.configure(
3758 text
="[%s]" % root
.test
['text']))
3761 quit
= Button(root
, text
="QUIT", command
=root
.destroy
)
3763 # The following three commands are needed so the window pops
3764 # up on top on Windows...
3770 if __name__
== '__main__':