Added the ttk module. See issue #2983: Ttk support for Tkinter.
diff --git a/Lib/lib-tk/ttk.py b/Lib/lib-tk/ttk.py
new file mode 100644
index 0000000..43da726
--- /dev/null
+++ b/Lib/lib-tk/ttk.py
@@ -0,0 +1,1636 @@
+"""Ttk wrapper.
+
+This module provides classes to allow using Tk themed widget set.
+
+Ttk is based on a revised and enhanced version of
+TIP #48 (http://tip.tcl.tk/48) specified style engine.
+
+Its basic idea is to separate, to the extent possible, the code
+implementing a widget's behavior from the code implementing its
+appearance. Widget class bindings are primarily responsible for
+maintaining the widget state and invoking callbacks, all aspects
+of the widgets appearance lies at Themes.
+"""
+
+__version__ = "0.3.1"
+
+__author__ = "Guilherme Polo <ggpolo@gmail.com>"
+
+__all__ = ["Button", "Checkbutton", "Combobox", "Entry", "Frame", "Label",
+ "Labelframe", "LabelFrame", "Menubutton", "Notebook", "Panedwindow",
+ "PanedWindow", "Progressbar", "Radiobutton", "Scale", "Scrollbar",
+ "Separator", "Sizegrip", "Style", "Treeview",
+ # Extensions
+ "LabeledScale", "OptionMenu",
+ # functions
+ "tclobjs_to_py"]
+
+import Tkinter
+
+_flatten = Tkinter._flatten
+
+# Verify if Tk is new enough to not need Tile checking
+_REQUIRE_TILE = True if Tkinter.TkVersion < 8.5 else False
+
+def _loadttk(loadtk):
+ # This extends the default Tkinter.Tk._loadtk method so we can be
+ # sure that ttk is available for use, or not.
+ def _wrapper(self):
+ loadtk(self)
+
+ if _REQUIRE_TILE:
+ import os
+ tilelib = os.environ.get('TILE_LIBRARY')
+ if tilelib:
+ # append custom tile path to the the list of directories that
+ # Tcl uses when attempting to resolve packages with the package
+ # command
+ self.tk.eval('global auto_path; '
+ 'lappend auto_path {%s}' % tilelib)
+ self.tk.eval('package require tile') # TclError may be raised here
+
+ return _wrapper
+
+# Store the original Tkinter.Tk._loadtk before replacing it just in case
+# someone wants to restore it.
+__loadtk__ = Tkinter.Tk._loadtk
+Tkinter.Tk._loadtk = _loadttk(Tkinter.Tk._loadtk)
+
+
+def _format_optdict(optdict, script=False, ignore=None):
+ """Formats optdict to a tuple to pass it to tk.call.
+
+ E.g. (script=False):
+ {'foreground': 'blue', 'padding': [1, 2, 3, 4]} returns:
+ ('-foreground', 'blue', '-padding', '1 2 3 4')"""
+ format = "%s" if not script else "{%s}"
+
+ opts = []
+ for opt, value in optdict.iteritems():
+ if ignore and opt in ignore:
+ continue
+
+ if isinstance(value, (list, tuple)):
+ v = []
+ for val in value:
+ if isinstance(val, basestring):
+ v.append(unicode(val) if val else '{}')
+ else:
+ v.append(str(val))
+
+ # format v according to the script option, but also check for
+ # space in any value in v in order to group them correctly
+ value = format % ' '.join(
+ ('{%s}' if ' ' in val else '%s') % val for val in v)
+
+ if script and value == '':
+ value = '{}' # empty string in Python is equivalent to {} in Tcl
+
+ opts.append(("-%s" % opt, value))
+
+ # Remember: _flatten skips over None
+ return _flatten(opts)
+
+def _format_mapdict(mapdict, script=False):
+ """Formats mapdict to pass it to tk.call.
+
+ E.g. (script=False):
+ {'expand': [('active', 'selected', 'grey'), ('focus', [1, 2, 3, 4])]}
+
+ returns:
+
+ ('-expand', '{active selected} grey focus {1, 2, 3, 4}')"""
+ # if caller passes a Tcl script to tk.call, all the values need to
+ # be grouped into words (arguments to a command in Tcl dialect)
+ format = "%s" if not script else "{%s}"
+
+ opts = []
+ for opt, value in mapdict.iteritems():
+
+ opt_val = []
+ # each value in mapdict is expected to be a sequence, where each item
+ # is another sequence containing a state (or several) and a value
+ for statespec in value:
+ state, val = statespec[:-1], statespec[-1]
+
+ if len(state) > 1: # group multiple states
+ state = "{%s}" % ' '.join(state)
+ else: # single state
+ # if it is empty (something that evaluates to False), then
+ # format it to Tcl code to denote the "normal" state
+ state = state[0] or '{}'
+
+ if isinstance(val, (list, tuple)): # val needs to be grouped
+ val = "{%s}" % ' '.join(map(str, val))
+
+ opt_val.append("%s %s" % (state, val))
+
+ opts.append(("-%s" % opt, format % ' '.join(opt_val)))
+
+ return _flatten(opts)
+
+def _format_elemcreate(etype, script=False, *args, **kw):
+ """Formats args and kw according to the given element factory etype."""
+ spec = None
+ opts = ()
+ if etype in ("image", "vsapi"):
+ if etype == "image": # define an element based on an image
+ # first arg should be the default image name
+ iname = args[0]
+ # next args, if any, are statespec/value pairs which is almost
+ # a mapdict, but we just need the value
+ imagespec = _format_mapdict({None: args[1:]})[1]
+ spec = "%s %s" % (iname, imagespec)
+
+ else:
+ # define an element whose visual appearance is drawn using the
+ # Microsoft Visual Styles API which is responsible for the
+ # themed styles on Windows XP and Vista.
+ # Availability: Tk 8.6, Windows XP and Vista.
+ class_name, part_id = args[:2]
+ statemap = _format_mapdict({None: args[2:]})[1]
+ spec = "%s %s %s" % (class_name, part_id, statemap)
+
+ opts = _format_optdict(kw, script)
+
+ elif etype == "from": # clone an element
+ # it expects a themename and optionally an element to clone from,
+ # otherwise it will clone {} (empty element)
+ spec = args[0] # theme name
+ if len(args) > 1: # elementfrom specified
+ opts = (args[1], )
+
+ if script:
+ spec = '{%s}' % spec
+ opts = ' '.join(map(str, opts))
+
+ return spec, opts
+
+def _format_layoutlist(layout, indent=0, indent_size=2):
+ """Formats a layout list so we can pass the result to ttk::style
+ layout and ttk::style settings. Note that the layout doesn't has to
+ be a list necessarily.
+
+ E.g.:
+ [("Menubutton.background", None),
+ ("Menubutton.button", {"children":
+ [("Menubutton.focus", {"children":
+ [("Menubutton.padding", {"children":
+ [("Menubutton.label", {"side": "left", "expand": 1})]
+ })]
+ })]
+ }),
+ ("Menubutton.indicator", {"side": "right"})
+ ]
+
+ returns:
+
+ Menubutton.background
+ Menubutton.button -children {
+ Menubutton.focus -children {
+ Menubutton.padding -children {
+ Menubutton.label -side left -expand 1
+ }
+ }
+ }
+ Menubutton.indicator -side right"""
+ script = []
+
+ for layout_elem in layout:
+ elem, opts = layout_elem
+ opts = opts or {}
+ fopts = ' '.join(map(str, _format_optdict(opts, True, "children")))
+ head = "%s%s%s" % (' ' * indent, elem, (" %s" % fopts) if fopts else '')
+
+ if "children" in opts:
+ script.append(head + " -children {")
+ indent += indent_size
+ newscript, indent = _format_layoutlist(opts['children'], indent,
+ indent_size)
+ script.append(newscript)
+ indent -= indent_size
+ script.append('%s}' % (' ' * indent))
+ else:
+ script.append(head)
+
+ return '\n'.join(script), indent
+
+def _script_from_settings(settings):
+ """Returns an appropriate script, based on settings, according to
+ theme_settings definition to be used by theme_settings and
+ theme_create."""
+ script = []
+ # a script will be generated according to settings passed, which
+ # will then be evaluated by Tcl
+ for name, opts in settings.iteritems():
+ # will format specific keys according to Tcl code
+ if opts.get('configure'): # format 'configure'
+ s = ' '.join(map(unicode, _format_optdict(opts['configure'], True)))
+ script.append("ttk::style configure %s %s;" % (name, s))
+
+ if opts.get('map'): # format 'map'
+ s = ' '.join(map(unicode, _format_mapdict(opts['map'], True)))
+ script.append("ttk::style map %s %s;" % (name, s))
+
+ if 'layout' in opts: # format 'layout' which may be empty
+ if not opts['layout']:
+ s = 'null' # could be any other word, but this one makes sense
+ else:
+ s, _ = _format_layoutlist(opts['layout'])
+ script.append("ttk::style layout %s {\n%s\n}" % (name, s))
+
+ if opts.get('element create'): # format 'element create'
+ eopts = opts['element create']
+ etype = eopts[0]
+
+ # find where args end, and where kwargs start
+ argc = 1 # etype was the first one
+ while argc < len(eopts) and not hasattr(eopts[argc], 'iteritems'):
+ argc += 1
+
+ elemargs = eopts[1:argc]
+ elemkw = eopts[argc] if argc < len(eopts) and eopts[argc] else {}
+ spec, opts = _format_elemcreate(etype, True, *elemargs, **elemkw)
+
+ script.append("ttk::style element create %s %s %s %s" % (
+ name, etype, spec, opts))
+
+ return '\n'.join(script)
+
+def _dict_from_tcltuple(ttuple, cut_minus=True):
+ """Break tuple in pairs, format it properly, then build the return
+ dict. If cut_minus is True, the supposed '-' prefixing options will
+ be removed.
+
+ ttuple is expected to contain an even number of elements."""
+ opt_start = 1 if cut_minus else 0
+
+ retdict = {}
+ it = iter(ttuple)
+ for opt, val in zip(it, it):
+ retdict[str(opt)[opt_start:]] = val
+
+ return tclobjs_to_py(retdict)
+
+def _list_from_statespec(stuple):
+ """Construct a list from the given statespec tuple according to the
+ accepted statespec accepted by _format_mapdict."""
+ nval = []
+ for val in stuple:
+ typename = getattr(val, 'typename', None)
+ if typename is None:
+ nval.append(val)
+ else: # this is a Tcl object
+ val = str(val)
+ if typename == 'StateSpec':
+ val = val.split()
+ nval.append(val)
+
+ it = iter(nval)
+ return [_flatten(spec) for spec in zip(it, it)]
+
+def _list_from_layouttuple(ltuple):
+ """Construct a list from the tuple returned by ttk::layout, this is
+ somewhat the reverse of _format_layoutlist."""
+ res = []
+
+ indx = 0
+ while indx < len(ltuple):
+ name = ltuple[indx]
+ opts = {}
+ res.append((name, opts))
+ indx += 1
+
+ while indx < len(ltuple): # grab name's options
+ opt, val = ltuple[indx:indx + 2]
+ if not opt.startswith('-'): # found next name
+ break
+
+ opt = opt[1:] # remove the '-' from the option
+ indx += 2
+
+ if opt == 'children':
+ val = _list_from_layouttuple(val)
+
+ opts[opt] = val
+
+ return res
+
+def _val_or_dict(options, func, *args):
+ """Format options then call func with args and options and return
+ the appropriate result.
+
+ If no option is specified, a dict is returned. If a option is
+ specified with the None value, the value for that option is returned.
+ Otherwise, the function just sets the passed options and the caller
+ shouldn't be expecting a return value anyway."""
+ options = _format_optdict(options)
+ res = func(*(args + options))
+
+ if len(options) % 2: # option specified without a value, return its value
+ return res
+
+ return _dict_from_tcltuple(res)
+
+def _convert_stringval(value):
+ """Converts a value to, hopefully, a more appropriate Python object."""
+ value = unicode(value)
+ try:
+ value = int(value)
+ except (ValueError, TypeError):
+ pass
+
+ return value
+
+def tclobjs_to_py(adict):
+ """Returns adict with its values converted from Tcl objects to Python
+ objects."""
+ for opt, val in adict.iteritems():
+ if val and hasattr(val, '__len__') and not isinstance(val, basestring):
+ if getattr(val[0], 'typename', None) == 'StateSpec':
+ val = _list_from_statespec(val)
+ else:
+ val = map(_convert_stringval, val)
+
+ elif hasattr(val, 'typename'): # some other (single) Tcl object
+ val = _convert_stringval(val)
+
+ adict[opt] = val
+
+ return adict
+
+
+class Style(object):
+ """Manipulate style database."""
+
+ _name = "ttk::style"
+
+ def __init__(self, master=None):
+ if master is None:
+ if Tkinter._support_default_root:
+ master = Tkinter._default_root or Tkinter.Tk()
+ else:
+ raise RuntimeError("No master specified and Tkinter is "
+ "configured to not support default master")
+
+ self.master = master
+ self.tk = self.master.tk
+
+
+ def configure(self, style, query_opt=None, **kw):
+ """Query or sets the default value of the specified option(s) in
+ style.
+
+ Each key in kw is an option and each value is either a string or
+ a sequence identifying the value for that option."""
+ if query_opt is not None:
+ kw[query_opt] = None
+ return _val_or_dict(kw, self.tk.call, self._name, "configure", style)
+
+
+ def map(self, style, query_opt=None, **kw):
+ """Query or sets dynamic values of the specified option(s) in
+ style.
+
+ Each key in kw is an option and each value should be a list or a
+ tuple (usually) containing statespecs grouped in tuples, or list,
+ or something else of your preference. A statespec is compound of
+ one or more states and then a value."""
+ if query_opt is not None:
+ return _list_from_statespec(
+ self.tk.call(self._name, "map", style, '-%s' % query_opt))
+
+ return _dict_from_tcltuple(
+ self.tk.call(self._name, "map", style, *(_format_mapdict(kw))))
+
+
+ def lookup(self, style, option, state=None, default=None):
+ """Returns the value specified for option in style.
+
+ If state is specified it is expected to be a sequence of one
+ or more states. If the default argument is set, it is used as
+ a fallback value in case no specification for option is found."""
+ state = ' '.join(state) if state else ''
+
+ return self.tk.call(self._name, "lookup", style, '-%s' % option,
+ state, default)
+
+
+ def layout(self, style, layoutspec=None):
+ """Define the widget layout for given style. If layoutspec is
+ omitted, return the layout specification for given style.
+
+ layoutspec is expected to be a list or an object different than
+ None that evaluates to False if you want to "turn off" that style.
+ If it is a list (or tuple, or something else), each item should be
+ a tuple where the first item is the layout name and the second item
+ should have the format described below:
+
+ LAYOUTS
+
+ A layout can contain the value None, if takes no options, or
+ a dict of options specifying how to arrange the element.
+ The layout mechanism uses a simplified version of the pack
+ geometry manager: given an initial cavity, each element is
+ allocated a parcel. Valid options/values are:
+
+ side: whichside
+ Specifies which side of the cavity to place the
+ element; one of top, right, bottom or left. If
+ omitted, the element occupies the entire cavity.
+
+ sticky: nswe
+ Specifies where the element is placed inside its
+ allocated parcel.
+
+ children: [sublayout... ]
+ Specifies a list of elements to place inside the
+ element. Each element is a tuple (or other sequence)
+ where the first item is the layout name, and the other
+ is a LAYOUT."""
+ lspec = None
+ if layoutspec:
+ lspec = _format_layoutlist(layoutspec)[0]
+ elif layoutspec is not None: # will disable the layout ({}, '', etc)
+ lspec = "null" # could be any other word, but this may make sense
+ # when calling layout(style) later
+
+ return _list_from_layouttuple(
+ self.tk.call(self._name, "layout", style, lspec))
+
+
+ def element_create(self, elementname, etype, *args, **kw):
+ """Create a new element in the current theme of given etype."""
+ spec, opts = _format_elemcreate(etype, False, *args, **kw)
+ self.tk.call(self._name, "element", "create", elementname, etype,
+ spec, *opts)
+
+
+ def element_names(self):
+ """Returns the list of elements defined in the current theme."""
+ return self.tk.call(self._name, "element", "names")
+
+
+ def element_options(self, elementname):
+ """Return the list of elementname's options."""
+ return self.tk.call(self._name, "element", "options", elementname)
+
+
+ def theme_create(self, themename, parent=None, settings=None):
+ """Creates a new theme.
+
+ It is an error if themename already exists. If parent is
+ specified, the new theme will inherit styles, elements and
+ layouts from the specified parent theme. If settings are present,
+ they are expected to have the same syntax used for theme_settings."""
+ script = _script_from_settings(settings) if settings else ''
+
+ if parent:
+ self.tk.call(self._name, "theme", "create", themename,
+ "-parent", parent, "-settings", script)
+ else:
+ self.tk.call(self._name, "theme", "create", themename,
+ "-settings", script)
+
+
+ def theme_settings(self, themename, settings):
+ """Temporarily sets the current theme to themename, apply specified
+ settings and then restore the previous theme.
+
+ Each key in settings is a style and each value may contain the
+ keys 'configure', 'map', 'layout' and 'element create' and they
+ are expected to have the same format as specified by the methods
+ configure, map, layout and element_create respectively."""
+ script = _script_from_settings(settings)
+ self.tk.call(self._name, "theme", "settings", themename, script)
+
+
+ def theme_names(self):
+ """Returns a list of all known themes."""
+ return self.tk.call(self._name, "theme", "names")
+
+
+ def theme_use(self, themename=None):
+ """If themename is None, returns the theme in use, otherwise, set
+ the current theme to themename, refreshes all widgets and emits
+ a <<ThemeChanged>> event."""
+ if themename is None:
+ # Starting on Tk 8.6, checking this global is no longer needed
+ # since it allows doing self.tk.call(self._name, "theme", "use")
+ return self.tk.eval("return $ttk::currentTheme")
+
+ # using "ttk::setTheme" instead of "ttk::style theme use" causes
+ # the variable currentTheme to be updated, also, ttk::setTheme calls
+ # "ttk::style theme use" in order to change theme.
+ self.tk.call("ttk::setTheme", themename)
+
+
+class Widget(Tkinter.Widget):
+ """Base class for Tk themed widgets."""
+
+ def __init__(self, master, widgetname, kw=None):
+ """Constructs a Ttk Widget with the parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, takefocus, style
+
+ SCROLLABLE WIDGET OPTIONS
+
+ xscrollcommand, yscrollcommand
+
+ LABEL WIDGET OPTIONS
+
+ text, textvariable, underline, image, compound, width
+
+ WIDGET STATES
+
+ active, disabled, focus, pressed, selected, background,
+ readonly, alternate, invalid
+ """
+ Tkinter.Widget.__init__(self, master, widgetname, kw=kw)
+
+
+ def identify(self, x, y):
+ """Returns the name of the element at position x, y, or the empty
+ string if the point does not lie within any element.
+
+ x and y are pixel coordinates relative to the widget."""
+ return self.tk.call(self._w, "identify", x, y)
+
+
+ def instate(self, statespec, callback=None, *args, **kw):
+ """Test the widget's state.
+
+ If callback is not specified, returns True if the widget state
+ matches statespec and False otherwise. If callback is specified,
+ then it will be invoked with *args, **kw if the widget state
+ matches statespec. statespec is expected to be a sequence."""
+ ret = self.tk.call(self._w, "instate", ' '.join(statespec))
+ if ret and callback:
+ return callback(*args, **kw)
+
+ return bool(ret)
+
+
+ def state(self, statespec=None):
+ """Modify or inquire widget state.
+
+ Widget state is returned if statespec is None, otherwise it is
+ set according to the statespec flags and then a new state spec
+ is returned indicating which flags were changed. statespec is
+ expected to be a sequence."""
+ if statespec is not None:
+ statespec = ' '.join(statespec)
+
+ return self.tk.splitlist(str(self.tk.call(self._w, "state", statespec)))
+
+
+class Button(Widget):
+ """Ttk Button widget, displays a textual label and/or image, and
+ evaluates a command when pressed."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Button widget with the parent master.
+
+ STANDARD OPTIONS
+
+ class, compound, cursor, image, state, style, takefocus,
+ text, textvariable, underline, width
+
+ WIDGET-SPECIFIC OPTIONS
+
+ command, default, width
+ """
+ Widget.__init__(self, master, "ttk::button", kw)
+
+
+ def invoke(self):
+ """Invokes the command associated with the button."""
+ return self.tk.call(self._w, "invoke")
+
+
+class Checkbutton(Widget):
+ """Ttk Checkbutton widget which is either in on- or off-state."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Checkbutton widget with the parent master.
+
+ STANDARD OPTIONS
+
+ class, compound, cursor, image, state, style, takefocus,
+ text, textvariable, underline, width
+
+ WIDGET-SPECIFIC OPTIONS
+
+ command, offvalue, onvalue, variable
+ """
+ Widget.__init__(self, master, "ttk::checkbutton", kw)
+
+
+ def invoke(self):
+ """Toggles between the selected and deselected states and
+ invokes the associated command. If the widget is currently
+ selected, sets the option variable to the offvalue option
+ and deselects the widget; otherwise, sets the option variable
+ to the option onvalue.
+
+ Returns the result of the associated command."""
+ return self.tk.call(self._w, "invoke")
+
+
+class Entry(Widget, Tkinter.Entry):
+ """Ttk Entry widget displays a one-line text string and allows that
+ string to be edited by the user."""
+
+ def __init__(self, master=None, widget=None, **kw):
+ """Constructs a Ttk Entry widget with the parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, style, takefocus, xscrollcommand
+
+ WIDGET-SPECIFIC OPTIONS
+
+ exportselection, invalidcommand, justify, show, state,
+ textvariable, validate, validatecommand, width
+
+ VALIDATION MODES
+
+ none, key, focus, focusin, focusout, all
+ """
+ Widget.__init__(self, master, widget or "ttk::entry", kw)
+
+
+ def bbox(self, index):
+ """Return a tuple of (x, y, width, height) which describes the
+ bounding box of the character given by index."""
+ return self.tk.call(self._w, "bbox", index)
+
+
+ def identify(self, x, y):
+ """Returns the name of the element at position x, y, or the
+ empty string if the coordinates are outside the window."""
+ return self.tk.call(self._w, "identify", x, y)
+
+
+ def validate(self):
+ """Force revalidation, independent of the conditions specified
+ by the validate option. Returns False if validation fails, True
+ if it succeeds. Sets or clears the invalid state accordingly."""
+ return bool(self.tk.call(self._w, "validate"))
+
+
+class Combobox(Entry):
+ """Ttk Combobox widget combines a text field with a pop-down list of
+ values."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Combobox widget with the parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, style, takefocus
+
+ WIDGET-SPECIFIC OPTIONS
+
+ exportselection, justify, height, postcommand, state,
+ textvariable, values, width
+ """
+ # The "values" option may need special formatting, so leave to
+ # _format_optdict the responsability to format it
+ if "values" in kw:
+ kw["values"] = _format_optdict({'v': kw["values"]})[1]
+
+ Entry.__init__(self, master, "ttk::combobox", **kw)
+
+
+ def __setitem__(self, item, value):
+ if item == "values":
+ value = _format_optdict({item: value})[1]
+
+ Entry.__setitem__(self, item, value)
+
+
+ def configure(self, cnf=None, **kw):
+ """Custom Combobox configure, created to properly format the values
+ option."""
+ if "values" in kw:
+ kw["values"] = _format_optdict({'v': kw["values"]})[1]
+
+ return Entry.configure(self, cnf, **kw)
+
+
+ def current(self, newindex=None):
+ """If newindex is supplied, sets the combobox value to the
+ element at position newindex in the list of values. Otherwise,
+ returns the index of the current value in the list of values
+ or -1 if the current value does not appear in the list."""
+ return self.tk.call(self._w, "current", newindex)
+
+
+ def set(self, value):
+ """Sets the value of the combobox to value."""
+ self.tk.call(self._w, "set", value)
+
+
+class Frame(Widget):
+ """Ttk Frame widget is a container, used to group other widgets
+ together."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Frame with parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, style, takefocus
+
+ WIDGET-SPECIFIC OPTIONS
+
+ borderwidth, relief, padding, width, height
+ """
+ Widget.__init__(self, master, "ttk::frame", kw)
+
+
+class Label(Widget):
+ """Ttk Label widget displays a textual label and/or image."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Label with parent master.
+
+ STANDARD OPTIONS
+
+ class, compound, cursor, image, style, takefocus, text,
+ textvariable, underline, width
+
+ WIDGET-SPECIFIC OPTIONS
+
+ anchor, background, font, foreground, justify, padding,
+ relief, text, wraplength
+ """
+ Widget.__init__(self, master, "ttk::label", kw)
+
+
+class Labelframe(Widget):
+ """Ttk Labelframe widget is a container used to group other widgets
+ together. It has an optional label, which may be a plain text string
+ or another widget."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Labelframe with parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, style, takefocus
+
+ WIDGET-SPECIFIC OPTIONS
+ labelanchor, text, underline, padding, labelwidget, width,
+ height
+ """
+ Widget.__init__(self, master, "ttk::labelframe", kw)
+
+LabelFrame = Labelframe # Tkinter name compatibility
+
+
+class Menubutton(Widget):
+ """Ttk Menubutton widget displays a textual label and/or image, and
+ displays a menu when pressed."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Menubutton with parent master.
+
+ STANDARD OPTIONS
+
+ class, compound, cursor, image, state, style, takefocus,
+ text, textvariable, underline, width
+
+ WIDGET-SPECIFIC OPTIONS
+
+ direction, menu
+ """
+ Widget.__init__(self, master, "ttk::menubutton", kw)
+
+
+class Notebook(Widget):
+ """Ttk Notebook widget manages a collection of windows and displays
+ a single one at a time. Each child window is associated with a tab,
+ which the user may select to change the currently-displayed window."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Notebook with parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, style, takefocus
+
+ WIDGET-SPECIFIC OPTIONS
+
+ height, padding, width
+
+ TAB OPTIONS
+
+ state, sticky, padding, text, image, compound, underline
+
+ TAB IDENTIFIERS (tab_id)
+
+ The tab_id argument found in several methods may take any of
+ the following forms:
+
+ * An integer between zero and the number of tabs
+ * The name of a child window
+ * A positional specification of the form "@x,y", which
+ defines the tab
+ * The string "current", which identifies the
+ currently-selected tab
+ * The string "end", which returns the number of tabs (only
+ valid for method index)
+ """
+ Widget.__init__(self, master, "ttk::notebook", kw)
+
+
+ def add(self, child, **kw):
+ """Adds a new tab to the notebook.
+
+ If window is currently managed by the notebook but hidden, it is
+ restored to its previous position."""
+ self.tk.call(self._w, "add", child, *(_format_optdict(kw)))
+
+
+ def forget(self, tab_id):
+ """Removes the tab specified by tab_id, unmaps and unmanages the
+ associated window."""
+ self.tk.call(self._w, "forget", tab_id)
+
+
+ def hide(self, tab_id):
+ """Hides the tab specified by tab_id.
+
+ The tab will not be displayed, but the associated window remains
+ managed by the notebook and its configuration remembered. Hidden
+ tabs may be restored with the add command."""
+ self.tk.call(self._w, "hide", tab_id)
+
+
+ def identify(self, x, y):
+ """Returns the name of the tab element at position x, y, or the
+ empty string if none."""
+ return self.tk.call(self._w, "identify", x, y)
+
+
+ def index(self, tab_id):
+ """Returns the numeric index of the tab specified by tab_id, or
+ the total number of tabs if tab_id is the string "end"."""
+ return self.tk.call(self._w, "index", tab_id)
+
+
+ def insert(self, pos, child, **kw):
+ """Inserts a pane at the specified position.
+
+ pos is either the string end, an integer index, or the name of
+ a managed child. If child is already managed by the notebook,
+ moves it to the specified position."""
+ self.tk.call(self._w, "insert", pos, child, *(_format_optdict(kw)))
+
+
+ def select(self, tab_id=None):
+ """Selects the specified tab.
+
+ The associated child window will be displayed, and the
+ previously-selected window (if different) is unmapped. If tab_id
+ is omitted, returns the widget name of the currently selected
+ pane."""
+ return self.tk.call(self._w, "select", tab_id)
+
+
+ def tab(self, tab_id, option=None, **kw):
+ """Query or modify the options of the specific tab_id.
+
+ If kw is not given, returns a dict of the tab option values. If option
+ is specified, returns the value of that option. Otherwise, sets the
+ options to the corresponding values."""
+ if option is not None:
+ kw[option] = None
+ return _val_or_dict(kw, self.tk.call, self._w, "tab", tab_id)
+
+
+ def tabs(self):
+ """Returns a list of windows managed by the notebook."""
+ return self.tk.call(self._w, "tabs") or ()
+
+
+ def enable_traversal(self):
+ """Enable keyboard traversal for a toplevel window containing
+ this notebook.
+
+ This will extend the bindings for the toplevel window containing
+ this notebook as follows:
+
+ Control-Tab: selects the tab following the currently selected
+ one
+
+ Shift-Control-Tab: selects the tab preceding the currently
+ selected one
+
+ Alt-K: where K is the mnemonic (underlined) character of any
+ tab, will select that tab.
+
+ Multiple notebooks in a single toplevel may be enabled for
+ traversal, including nested notebooks. However, notebook traversal
+ only works properly if all panes are direct children of the
+ notebook."""
+ # The only, and good, difference I see is about mnemonics, which works
+ # after calling this method. Control-Tab and Shift-Control-Tab always
+ # works (here at least).
+ self.tk.call("ttk::notebook::enableTraversal", self._w)
+
+
+class Panedwindow(Widget, Tkinter.PanedWindow):
+ """Ttk Panedwindow widget displays a number of subwindows, stacked
+ either vertically or horizontally."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Panedwindow with parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, style, takefocus
+
+ WIDGET-SPECIFIC OPTIONS
+
+ orient, width, height
+
+ PANE OPTIONS
+
+ weight
+ """
+ Widget.__init__(self, master, "ttk::panedwindow", kw)
+
+
+ forget = Tkinter.PanedWindow.forget # overrides Pack.forget
+
+
+ def insert(self, pos, child, **kw):
+ """Inserts a pane at the specified positions.
+
+ pos is either the string end, and integer index, or the name
+ of a child. If child is already managed by the paned window,
+ moves it to the specified position."""
+ self.tk.call(self._w, "insert", pos, child, *(_format_optdict(kw)))
+
+
+ def pane(self, pane, option=None, **kw):
+ """Query or modify the options of the specified pane.
+
+ pane is either an integer index or the name of a managed subwindow.
+ If kw is not given, returns a dict of the pane option values. If
+ option is specified then the value for that option is returned.
+ Otherwise, sets the options to the correspoding values."""
+ if option is not None:
+ kw[option] = None
+ return _val_or_dict(kw, self.tk.call, self._w, "pane", pane)
+
+
+ def sashpos(self, index, newpos=None):
+ """If newpos is specified, sets the position of sash number index.
+
+ May adjust the positions of adjacent sashes to ensure that
+ positions are monotonically increasing. Sash positions are further
+ constrained to be between 0 and the total size of the widget.
+
+ Returns the new position of sash number index."""
+ return self.tk.call(self._w, "sashpos", index, newpos)
+
+PanedWindow = Panedwindow # Tkinter name compatibility
+
+
+class Progressbar(Widget):
+ """Ttk Progressbar widget shows the status of a long-running
+ operation. They can operate in two modes: determinate mode shows the
+ amount completed relative to the total amount of work to be done, and
+ indeterminate mode provides an animated display to let the user know
+ that something is happening."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Progressbar with parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, style, takefocus
+
+ WIDGET-SPECIFIC OPTIONS
+
+ orient, length, mode, maximum, value, variable, phase
+ """
+ Widget.__init__(self, master, "ttk::progressbar", kw)
+
+
+ def start(self, interval=None):
+ """Begin autoincrement mode: schedules a recurring timer event
+ that calls method step every interval milliseconds.
+
+ interval defaults to 50 milliseconds (20 steps/second) if ommited."""
+ self.tk.call(self._w, "start", interval)
+
+
+ def step(self, amount=None):
+ """Increments the value option by amount.
+
+ amount defaults to 1.0 if omitted."""
+ self.tk.call(self._w, "step", amount)
+
+
+ def stop(self):
+ """Stop autoincrement mode: cancels any recurring timer event
+ initiated by start."""
+ self.tk.call(self._w, "stop")
+
+
+class Radiobutton(Widget):
+ """Ttk Radiobutton widgets are used in groups to show or change a
+ set of mutually-exclusive options."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Radiobutton with parent master.
+
+ STANDARD OPTIONS
+
+ class, compound, cursor, image, state, style, takefocus,
+ text, textvariable, underline, width
+
+ WIDGET-SPECIFIC OPTIONS
+
+ command, value, variable
+ """
+ Widget.__init__(self, master, "ttk::radiobutton", kw)
+
+
+ def invoke(self):
+ """Sets the option variable to the option value, selects the
+ widget, and invokes the associated command.
+
+ Returns the result of the command, or an empty string if
+ no command is specified."""
+ return self.tk.call(self._w, "invoke")
+
+
+class Scale(Widget, Tkinter.Scale):
+ """Ttk Scale widget is typically used to control the numeric value of
+ a linked variable that varies uniformly over some range."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Scale with parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, style, takefocus
+
+ WIDGET-SPECIFIC OPTIONS
+
+ command, from, length, orient, to, value, variable
+ """
+ Widget.__init__(self, master, "ttk::scale", kw)
+
+
+ def configure(self, cnf=None, **kw):
+ """Modify or query scale options.
+
+ Setting a value for any of the "from", "from_" or "to" options
+ generates a <<RangeChanged>> event."""
+ if cnf:
+ kw.update(cnf)
+ Widget.configure(self, **kw)
+ if any(['from' in kw, 'from_' in kw, 'to' in kw]):
+ self.event_generate('<<RangeChanged>>')
+
+
+ def get(self, x=None, y=None):
+ """Get the current value of the value option, or the value
+ corresponding to the coordinates x, y if they are specified.
+
+ x and y are pixel coordinates relative to the scale widget
+ origin."""
+ return self.tk.call(self._w, 'get', x, y)
+
+
+class Scrollbar(Widget, Tkinter.Scrollbar):
+ """Ttk Scrollbar controls the viewport of a scrollable widget."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Scrollbar with parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, style, takefocus
+
+ WIDGET-SPECIFIC OPTIONS
+
+ command, orient
+ """
+ Widget.__init__(self, master, "ttk::scrollbar", kw)
+
+
+class Separator(Widget):
+ """Ttk Separator widget displays a horizontal or vertical separator
+ bar."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Separator with parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, style, takefocus
+
+ WIDGET-SPECIFIC OPTIONS
+
+ orient
+ """
+ Widget.__init__(self, master, "ttk::separator", kw)
+
+
+class Sizegrip(Widget):
+ """Ttk Sizegrip allows the user to resize the containing toplevel
+ window by pressing and dragging the grip."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Sizegrip with parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, state, style, takefocus
+ """
+ Widget.__init__(self, master, "ttk::sizegrip", kw)
+
+
+class Treeview(Widget):
+ """Ttk Treeview widget displays a hierarchical collection of items.
+
+ Each item has a textual label, an optional image, and an optional list
+ of data values. The data values are displayed in successive columns
+ after the tree label."""
+
+ def __init__(self, master=None, **kw):
+ """Construct a Ttk Treeview with parent master.
+
+ STANDARD OPTIONS
+
+ class, cursor, style, takefocus, xscrollcommand,
+ yscrollcommand
+
+ WIDGET-SPECIFIC OPTIONS
+
+ columns, displaycolumns, height, padding, selectmode, show
+
+ ITEM OPTIONS
+
+ text, image, values, open, tags
+
+ TAG OPTIONS
+
+ foreground, background, font, image
+ """
+ Widget.__init__(self, master, "ttk::treeview", kw)
+
+
+ def bbox(self, item, column=None):
+ """Returns the bounding box (relative to the treeview widget's
+ window) of the specified item in the form x y width height.
+
+ If column is specified, returns the bounding box of that cell.
+ If the item is not visible (i.e., if it is a descendant of a
+ closed item or is scrolled offscreen), returns an empty string."""
+ return self.tk.call(self._w, "bbox", item, column)
+
+
+ def get_children(self, item=None):
+ """Returns a tuple of children belonging to item.
+
+ If item is not specified, returns root children."""
+ return self.tk.call(self._w, "children", item or '') or ()
+
+
+ def set_children(self, item, *newchildren):
+ """Replaces item's child with newchildren.
+
+ Children present in item that are not present in newchildren
+ are detached from tree. No items in newchildren may be an
+ ancestor of item."""
+ self.tk.call(self._w, "children", item, newchildren)
+
+
+ def column(self, column, option=None, **kw):
+ """Query or modify the options for the specified column.
+
+ If kw is not given, returns a dict of the column option values. If
+ option is specified then the value for that option is returned.
+ Otherwise, sets the options to the corresponding values."""
+ if option is not None:
+ kw[option] = None
+ return _val_or_dict(kw, self.tk.call, self._w, "column", column)
+
+
+ def delete(self, *items):
+ """Delete all specified items and all their descendants. The root
+ item may not be deleted."""
+ self.tk.call(self._w, "delete", items)
+
+
+ def detach(self, *items):
+ """Unlinks all of the specified items from the tree.
+
+ The items and all of their descendants are still present, and may
+ be reinserted at another point in the tree, but will not be
+ displayed. The root item may not be detached."""
+ self.tk.call(self._w, "detach", items)
+
+
+ def exists(self, item):
+ """Returns True if the specified item is present in the three,
+ False otherwise."""
+ return bool(self.tk.call(self._w, "exists", item))
+
+
+ def focus(self, item=None):
+ """If item is specified, sets the focus item to item. Otherwise,
+ returns the current focus item, or '' if there is none."""
+ return self.tk.call(self._w, "focus", item)
+
+
+ def heading(self, column, option=None, **kw):
+ """Query or modify the heading options for the specified column.
+
+ If kw is not given, returns a dict of the heading option values. If
+ option is specified then the value for that option is returned.
+ Otherwise, sets the options to the corresponding values.
+
+ Valid options/values are:
+ text: text
+ The text to display in the column heading
+ image: image_name
+ Specifies an image to display to the right of the column
+ heading
+ anchor: anchor
+ Specifies how the heading text should be aligned. One of
+ the standard Tk anchor values
+ command: callback
+ A callback to be invoked when the heading label is
+ pressed.
+
+ To configure the tree column heading, call this with column = "#0" """
+ cmd = kw.get('command')
+ if cmd and not isinstance(cmd, basestring):
+ # callback not registered yet, do it now
+ kw['command'] = self.master.register(cmd, self._substitute)
+
+ if option is not None:
+ kw[option] = None
+
+ return _val_or_dict(kw, self.tk.call, self._w, 'heading', column)
+
+
+ def identify(self, component, x, y):
+ """Returns a description of the specified component under the
+ point given by x and y, or the empty string if no such component
+ is present at that position."""
+ return self.tk.call(self._w, "identify", component, x, y)
+
+
+ def identify_row(self, y):
+ """Returns the item ID of the item at position y."""
+ return self.identify("row", 0, y)
+
+
+ def identify_column(self, x):
+ """Returns the data column identifier of the cell at position x.
+
+ The tree column has ID #0."""
+ return self.identify("column", x, 0)
+
+
+ def identify_region(self, x, y):
+ """Returns one of:
+
+ heading: Tree heading area.
+ separator: Space between two columns headings;
+ tree: The tree area.
+ cell: A data cell.
+
+ * Availability: Tk 8.6"""
+ return self.identify("region", x, y)
+
+
+ def identify_element(self, x, y):
+ """Returns the element at position x, y.
+
+ * Availability: Tk 8.6"""
+ return self.identify("element", x, y)
+
+
+ def index(self, item):
+ """Returns the integer index of item within its parent's list
+ of children."""
+ return self.tk.call(self._w, "index", item)
+
+
+ def insert(self, parent, index, iid=None, **kw):
+ """Creates a new item and return the item identifier of the newly
+ created item.
+
+ parent is the item ID of the parent item, or the empty string
+ to create a new top-level item. index is an integer, or the value
+ end, specifying where in the list of parent's children to insert
+ the new item. If index is less than or equal to zero, the new node
+ is inserted at the beginning, if index is greater than or equal to
+ the current number of children, it is inserted at the end. If iid
+ is specified, it is used as the item identifier, iid must not
+ already exist in the tree. Otherwise, a new unique identifier
+ is generated."""
+ opts = _format_optdict(kw)
+ if iid:
+ res = self.tk.call(self._w, "insert", parent, index,
+ "-id", iid, *opts)
+ else:
+ res = self.tk.call(self._w, "insert", parent, index, *opts)
+
+ return res
+
+
+ def item(self, item, option=None, **kw):
+ """Query or modify the options for the specified item.
+
+ If no options are given, a dict with options/values for the item
+ is returned. If option is specified then the value for that option
+ is returned. Otherwise, sets the options to the corresponding
+ values as given by kw."""
+ if option is not None:
+ kw[option] = None
+ return _val_or_dict(kw, self.tk.call, self._w, "item", item)
+
+
+ def move(self, item, parent, index):
+ """Moves item to position index in parent's list of children.
+
+ It is illegal to move an item under one of its descendants. If
+ index is less than or equal to zero, item is moved to the
+ beginning, if greater than or equal to the number of children,
+ it is moved to the end. If item was detached it is reattached."""
+ self.tk.call(self._w, "move", item, parent, index)
+
+ reattach = move # A sensible method name for reattaching detached items
+
+
+ def next(self, item):
+ """Returns the identifier of item's next sibling, or '' if item
+ is the last child of its parent."""
+ return self.tk.call(self._w, "next", item)
+
+
+ def parent(self, item):
+ """Returns the ID of the parent of item, or '' if item is at the
+ top level of the hierarchy."""
+ return self.tk.call(self._w, "parent", item)
+
+
+ def prev(self, item):
+ """Returns the identifier of item's previous sibling, or '' if
+ item is the first child of its parent."""
+ return self.tk.call(self._w, "prev", item)
+
+
+ def see(self, item):
+ """Ensure that item is visible.
+
+ Sets all of item's ancestors open option to True, and scrolls
+ the widget if necessary so that item is within the visible
+ portion of the tree."""
+ self.tk.call(self._w, "see", item)
+
+
+ def selection(self, selop=None, items=None):
+ """If selop is not specified, returns selected items."""
+ return self.tk.call(self._w, "selection", selop, items)
+
+
+ def selection_set(self, items):
+ """items becomes the new selection."""
+ self.selection("set", items)
+
+
+ def selection_add(self, items):
+ """Add items to the selection."""
+ self.selection("add", items)
+
+
+ def selection_remove(self, items):
+ """Remove items from the selection."""
+ self.selection("remove", items)
+
+
+ def selection_toggle(self, items):
+ """Toggle the selection state of each item in items."""
+ self.selection("toggle", items)
+
+
+ def set(self, item, column=None, value=None):
+ """With one argument, returns a dictionary of column/value pairs
+ for the specified item. With two arguments, returns the current
+ value of the specified column. With three arguments, sets the
+ value of given column in given item to the specified value."""
+ res = self.tk.call(self._w, "set", item, column, value)
+ if column is None and value is None:
+ return _dict_from_tcltuple(res, False)
+ else:
+ return res
+
+
+ def tag_bind(self, tagname, sequence=None, callback=None):
+ """Bind a callback for the given event sequence to the tag tagname.
+ When an event is delivered to an item, the callbacks for each
+ of the item's tags option are called."""
+ self._bind((self._w, "tag", "bind", tagname), sequence, callback, add=0)
+
+
+ def tag_configure(self, tagname, option=None, **kw):
+ """Query or modify the options for the specified tagname.
+
+ If kw is not given, returns a dict of the option settings for tagname.
+ If option is specified, returns the value for that option for the
+ specified tagname. Otherwise, sets the options to the corresponding
+ values for the given tagname."""
+ if option is not None:
+ kw[option] = None
+ return _val_or_dict(kw, self.tk.call, self._w, "tag", "configure",
+ tagname)
+
+
+ def tag_has(self, tagname, item=None):
+ """If item is specified, returns 1 or 0 depending on whether the
+ specified item has the given tagname. Otherwise, returns a list of
+ all items which have the specified tag.
+
+ * Availability: Tk 8.6"""
+ return self.tk.call(self._w, "tag", "has", tagname, item)
+
+
+ def xview(self, *args):
+ """Query or modify horizontal position of the treeview."""
+ return self.tk.call(self._w, "xview", *args)
+
+
+ def yview(self, *args):
+ """Query or modify vertical position of the treeview."""
+ return self.tk.call(self._w, "yview", *args)
+
+
+# Extensions
+
+class LabeledScale(Frame, object):
+ """A Ttk Scale widget with a Ttk Label widget indicating its
+ current value.
+
+ The Ttk Scale can be accessed through instance.scale, and Ttk Label
+ can be accessed through instance.label"""
+
+ def __init__(self, master=None, variable=None, from_=0, to=10, **kw):
+ """Construct an horizontal LabeledScale with parent master, a
+ variable to be associated with the Ttk Scale widget and its range.
+ If variable is not specified, a Tkinter.IntVar is created.
+
+ WIDGET-SPECIFIC OPTIONS
+
+ compound: 'top' or 'bottom'
+ Specifies how to display the label relative to the scale.
+ Defaults to 'top'.
+ """
+ self._label_top = kw.pop('compound', 'top') == 'top'
+
+ Frame.__init__(self, master, **kw)
+ self._variable = variable or Tkinter.IntVar(master)
+ self._variable.set(from_)
+ self._last_valid = from_
+
+ self.label = Label(self)
+ self.scale = Scale(self, variable=self._variable, from_=from_, to=to)
+ self.scale.bind('<<RangeChanged>>', self._adjust)
+
+ # position scale and label according to the compound option
+ scale_side = 'bottom' if self._label_top else 'top'
+ label_side = 'top' if scale_side == 'bottom' else 'bottom'
+ self.scale.pack(side=scale_side, fill='x')
+ tmp = Label(self).pack(side=label_side) # place holder
+ self.label.place(anchor='n' if label_side == 'top' else 's')
+
+ # update the label as scale or variable changes
+ self.__tracecb = self._variable.trace_variable('w', self._adjust)
+ self.bind('<Configure>', self._adjust)
+ self.bind('<Map>', self._adjust)
+
+
+ def destroy(self):
+ """Destroy this widget and possibly its associated variable."""
+ try:
+ self._variable.trace_vdelete('w', self.__tracecb)
+ except AttributeError:
+ # widget has been destroyed already
+ pass
+ else:
+ del self._variable
+ Frame.destroy(self)
+
+
+ def _adjust(self, *args):
+ """Adjust the label position according to the scale."""
+ def adjust_label():
+ self.update_idletasks() # "force" scale redraw
+
+ x, y = self.scale.coords()
+ if self._label_top:
+ y = self.scale.winfo_y() - self.label.winfo_reqheight()
+ else:
+ y = self.scale.winfo_reqheight() + self.label.winfo_reqheight()
+
+ self.label.place_configure(x=x, y=y)
+
+ from_, to = self.scale['from'], self.scale['to']
+ if to < from_:
+ from_, to = to, from_
+ newval = self._variable.get()
+ if not from_ <= newval <= to:
+ # value outside range, set value back to the last valid one
+ self.value = self._last_valid
+ return
+
+ self._last_valid = newval
+ self.label['text'] = newval
+ self.after_idle(adjust_label)
+
+
+ def _get_value(self):
+ """Return current scale value."""
+ return self._variable.get()
+
+
+ def _set_value(self, val):
+ """Set new scale value."""
+ self._variable.set(val)
+
+
+ value = property(_get_value, _set_value)
+
+
+class OptionMenu(Menubutton):
+ """Themed OptionMenu, based after Tkinter's OptionMenu, which allows
+ the user to select a value from a menu."""
+
+ def __init__(self, master, variable, default=None, *values, **kwargs):
+ """Construct a themed OptionMenu widget with master as the parent,
+ the resource textvariable set to variable, the initially selected
+ value specified by the default parameter, the menu values given by
+ *values and additional keywords.
+
+ WIDGET-SPECIFIC OPTIONS
+
+ style: stylename
+ Menubutton style.
+ direction: 'above', 'below', 'left', 'right', or 'flush'
+ Menubutton direction.
+ command: callback
+ A callback that will be invoked after selecting an item.
+ """
+ kw = {'textvariable': variable, 'style': kwargs.pop('style', None),
+ 'direction': kwargs.pop('direction', None)}
+ Menubutton.__init__(self, master, **kw)
+ self['menu'] = Tkinter.Menu(self, tearoff=False)
+
+ self._variable = variable
+ self._callback = kwargs.pop('command', None)
+ if kwargs:
+ raise Tkinter.TclError('unknown option -%s' % (
+ kwargs.iterkeys().next()))
+
+ self.set_menu(default, *values)
+
+
+ def __getitem__(self, item):
+ if item == 'menu':
+ return self.nametowidget(Menubutton.__getitem__(self, item))
+
+ return Menubutton.__getitem__(self, item)
+
+
+ def set_menu(self, default=None, *values):
+ """Build a new menu of radiobuttons with *values and optionally
+ a default value."""
+ menu = self['menu']
+ menu.delete(0, 'end')
+ for val in values:
+ menu.add_radiobutton(label=val,
+ command=Tkinter._setit(self._variable, val, self._callback))
+
+ if default:
+ self._variable.set(default)
+
+
+ def destroy(self):
+ """Destroy this widget and its associated variable."""
+ del self._variable
+ Menubutton.destroy(self)