diff --git a/pysollib/tile/basetilemfxdialog.py b/pysollib/tile/basetilemfxdialog.py
index 6628fc1b..58ff19a1 100644
--- a/pysollib/tile/basetilemfxdialog.py
+++ b/pysollib/tile/basetilemfxdialog.py
@@ -1,4 +1,5 @@
-from . import ttk
+from six.moves import tkinter_ttk as ttk
+
from .tkwidget import MfxDialog
diff --git a/pysollib/tile/fontsdialog.py b/pysollib/tile/fontsdialog.py
index 109b8ce4..d8f12fce 100644
--- a/pysollib/tile/fontsdialog.py
+++ b/pysollib/tile/fontsdialog.py
@@ -27,8 +27,8 @@ from pysollib.ui.tktile.tkutil import bind
from six.moves import tkinter
from six.moves import tkinter_font
+from six.moves import tkinter_ttk as ttk
-from . import ttk
from .tkwidget import MfxDialog
from .tkwidget import PysolScale
diff --git a/pysollib/tile/menubar.py b/pysollib/tile/menubar.py
index d4db3144..76fb1434 100644
--- a/pysollib/tile/menubar.py
+++ b/pysollib/tile/menubar.py
@@ -29,7 +29,8 @@ from pysollib.ui.tktile.menubar import MfxMenu, PysolMenubarTkCommon
from pysollib.ui.tktile.solverdialog import connect_game_solver_dialog
from pysollib.util import CARDSET
-from . import ttk
+from six.moves import tkinter_ttk as ttk
+
from .selectgame import SelectGameDialog, SelectGameDialogWithPreview
from .selecttile import SelectTileDialogWithPreview
from .soundoptionsdialog import SoundOptionsDialog
diff --git a/pysollib/tile/playeroptionsdialog.py b/pysollib/tile/playeroptionsdialog.py
index ce4dd3ee..074266f7 100644
--- a/pysollib/tile/playeroptionsdialog.py
+++ b/pysollib/tile/playeroptionsdialog.py
@@ -25,8 +25,8 @@ from pysollib.mfxutil import KwStruct
from pysollib.mygettext import _
from six.moves import tkinter
+from six.moves import tkinter_ttk as ttk
-from . import ttk
from .tkwidget import MfxDialog
diff --git a/pysollib/tile/progressbar.py b/pysollib/tile/progressbar.py
index 6b3505fe..883a9263 100644
--- a/pysollib/tile/progressbar.py
+++ b/pysollib/tile/progressbar.py
@@ -25,8 +25,7 @@ from pysollib.ui.tktile.tkconst import EVENT_HANDLED
from pysollib.ui.tktile.tkutil import makeToplevel, setTransient
from six.moves import tkinter
-
-from . import ttk
+from six.moves import tkinter_ttk as ttk
# ************************************************************************
# * a simple progress bar
diff --git a/pysollib/tile/selectcardset.py b/pysollib/tile/selectcardset.py
index de26dad8..45b45f41 100644
--- a/pysollib/tile/selectcardset.py
+++ b/pysollib/tile/selectcardset.py
@@ -32,8 +32,8 @@ from pysollib.ui.tktile.tkutil import loadImage
from pysollib.util import CARDSET
from six.moves import tkinter
+from six.moves import tkinter_ttk as ttk
-from . import ttk
from .selecttree import SelectDialogTreeCanvas
from .selecttree import SelectDialogTreeLeaf, SelectDialogTreeNode
from .tkwidget import MfxDialog, MfxScrolledCanvas, PysolScale
diff --git a/pysollib/tile/selectgame.py b/pysollib/tile/selectgame.py
index 2150265b..56200bdd 100644
--- a/pysollib/tile/selectgame.py
+++ b/pysollib/tile/selectgame.py
@@ -32,8 +32,8 @@ from pysollib.ui.tktile.selecttree import SelectDialogTreeData
from pysollib.ui.tktile.tkutil import unbind_destroy
from six.moves import UserList
+from six.moves import tkinter_ttk as ttk
-from . import ttk
from .selecttree import SelectDialogTreeCanvas
from .selecttree import SelectDialogTreeLeaf, SelectDialogTreeNode
from .tkwidget import MfxDialog, MfxScrolledCanvas
diff --git a/pysollib/tile/selecttile.py b/pysollib/tile/selecttile.py
index 59407032..be09d4b7 100644
--- a/pysollib/tile/selecttile.py
+++ b/pysollib/tile/selecttile.py
@@ -28,8 +28,8 @@ from pysollib.ui.tktile.selecttree import SelectDialogTreeData
import six
from six.moves import tkinter
from six.moves import tkinter_colorchooser
+from six.moves import tkinter_ttk as ttk
-from . import ttk
from .selecttree import SelectDialogTreeCanvas
from .selecttree import SelectDialogTreeLeaf, SelectDialogTreeNode
from .tkwidget import MfxDialog, MfxScrolledCanvas
diff --git a/pysollib/tile/soundoptionsdialog.py b/pysollib/tile/soundoptionsdialog.py
index ea1f8711..8072b7e8 100644
--- a/pysollib/tile/soundoptionsdialog.py
+++ b/pysollib/tile/soundoptionsdialog.py
@@ -30,8 +30,8 @@ from pysollib.settings import TITLE
from pysollib.ui.tktile.tkconst import EVENT_HANDLED
from six.moves import tkinter
+from six.moves import tkinter_ttk as ttk
-from . import ttk
from .tkwidget import MfxDialog, MfxMessageDialog
from .tkwidget import PysolScale
diff --git a/pysollib/tile/statusbar.py b/pysollib/tile/statusbar.py
index 14406bb7..a3b47ab8 100644
--- a/pysollib/tile/statusbar.py
+++ b/pysollib/tile/statusbar.py
@@ -29,8 +29,8 @@ from pysollib.mygettext import _
import six
from six.moves import tkinter
+from six.moves import tkinter_ttk as ttk
-from . import ttk
from .tkwidget import MfxTooltip
if __name__ == '__main__':
diff --git a/pysollib/tile/timeoutsdialog.py b/pysollib/tile/timeoutsdialog.py
index 0b57bfd0..896d1f3d 100644
--- a/pysollib/tile/timeoutsdialog.py
+++ b/pysollib/tile/timeoutsdialog.py
@@ -25,8 +25,8 @@ from pysollib.mfxutil import KwStruct
from pysollib.mygettext import _
from six.moves import tkinter
+from six.moves import tkinter_ttk as ttk
-from . import ttk
from .tkwidget import MfxDialog, PysolScale
diff --git a/pysollib/tile/tkhtml.py b/pysollib/tile/tkhtml.py
index fbff7659..4ede24f0 100644
--- a/pysollib/tile/tkhtml.py
+++ b/pysollib/tile/tkhtml.py
@@ -29,8 +29,8 @@ from pysollib.mygettext import _
from pysollib.ui.tktile.tkhtml import Base_HTMLViewer
from six.moves import tkinter
+from six.moves import tkinter_ttk as ttk
-from . import ttk
from .statusbar import HtmlStatusbar
from .tkwidget import MfxMessageDialog
diff --git a/pysollib/tile/tkstats.py b/pysollib/tile/tkstats.py
index ad6e5fb7..43882258 100644
--- a/pysollib/tile/tkstats.py
+++ b/pysollib/tile/tkstats.py
@@ -33,8 +33,8 @@ from pysollib.ui.tktile.tkutil import bind, loadImage
from six.moves import tkinter
from six.moves import tkinter_font
+from six.moves import tkinter_ttk as ttk
-from . import ttk
from .tkwidget import MfxDialog, MfxMessageDialog
diff --git a/pysollib/tile/tkwidget.py b/pysollib/tile/tkwidget.py
index 256396a2..c0ea0d9d 100644
--- a/pysollib/tile/tkwidget.py
+++ b/pysollib/tile/tkwidget.py
@@ -38,8 +38,7 @@ import six
from six import PY2
from six.moves import tkinter
from six.moves import tkinter_font
-
-from . import ttk
+from six.moves import tkinter_ttk as ttk
# ************************************************************************
# * abstract base class for the dialogs in this module
diff --git a/pysollib/tile/toolbar.py b/pysollib/tile/toolbar.py
index 14125ec6..98c70134 100644
--- a/pysollib/tile/toolbar.py
+++ b/pysollib/tile/toolbar.py
@@ -33,8 +33,8 @@ from pysollib.util import IMAGE_EXTENSIONS
from pysollib.winsystems import TkSettings
from six.moves import tkinter
+from six.moves import tkinter_ttk as ttk
-from . import ttk
from .tkwidget import MfxTooltip
diff --git a/pysollib/tile/ttk.py b/pysollib/tile/ttk.py
deleted file mode 100644
index aa290225..00000000
--- a/pysollib/tile/ttk.py
+++ /dev/null
@@ -1,1555 +0,0 @@
-"""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"
-
-__author__ = "Guilherme Polo <ggpolo@gmail.com>"
-
-import six
-from six.moves 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
-
-
-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.items():
- if ignore and opt in ignore:
- continue
-
- if isinstance(value, (list, tuple)):
- v = []
- for val in value:
- if isinstance(val, six.string_types):
- v.append(six.text_type(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.items():
-
- 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.items():
- # will format specific keys according to Tcl code
- if opts.get('configure'): # format 'configure'
- s = ' '.join(
- map(six.text_type, _format_optdict(opts['configure'], True)))
- script.append("ttk::style configure %s %s;" % (name, s))
-
- if opts.get('map'): # format 'map'
- s = ' '.join(map(six.text_type,
- _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 = {}
- for opt, val in zip(iter(ttuple[::2]), iter(ttuple[1::2])):
- 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)
-
- return [_flatten(spec) for spec in zip(iter(nval[::2]), iter(nval[1::2]))]
-
-
-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 = six.text_type(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.items():
- if val and hasattr(val, '__len__') and \
- not isinstance(val, six.string_types):
- if getattr(val[0], 'typename', None) == 'StateSpec':
- val = _list_from_statespec(val)
- else:
- val = list(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)
- # could be any other word, but this may make sense
- # when calling layout(style) later
- lspec = "null"
-
- 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 responsibility 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 ommitted."""
- 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, six.string_types):
- # 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 kw is not given, returns a dict of item 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, "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')
- 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."""
- self._variable.trace_vdelete('w', self.__tracecb)
- 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' % (
- next(iter(kwargs.keys()))))
-
- 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)
diff --git a/pysollib/tile/wizarddialog.py b/pysollib/tile/wizarddialog.py
index 4af0c4c0..a33f061f 100644
--- a/pysollib/tile/wizarddialog.py
+++ b/pysollib/tile/wizarddialog.py
@@ -28,8 +28,8 @@ from pysollib.wizardutil import WizardWidgets
import six
from six.moves import tkinter
+from six.moves import tkinter_ttk as ttk
-from . import ttk
from .tkwidget import MfxDialog
from .tkwidget import PysolCombo, PysolScale
diff --git a/pysollib/winsystems/common.py b/pysollib/winsystems/common.py
index 815ddd54..2ea85330 100644
--- a/pysollib/winsystems/common.py
+++ b/pysollib/winsystems/common.py
@@ -33,7 +33,7 @@ from pysollib.settings import VERSION
if TOOLKIT == 'tk':
if USE_TILE:
- from pysollib.tile import ttk
+ from six.moves import tkinter_ttk as ttk
def init_tile(app, top):
diff --git a/pysollib/winsystems/win32.py b/pysollib/winsystems/win32.py
index 4c436adc..d3f75c7d 100644
--- a/pysollib/winsystems/win32.py
+++ b/pysollib/winsystems/win32.py
@@ -25,7 +25,7 @@ from pysollib.settings import TOOLKIT, USE_TILE
from pysollib.winsystems.common import BaseTkSettings, base_init_root_window
if USE_TILE:
- from pysollib.tile import ttk
+ from six.moves import tkinter_ttk as ttk
def init_root_window(root, app):
diff --git a/pysollib/winsystems/x11.py b/pysollib/winsystems/x11.py
index f755ab4e..4cc17d7f 100644
--- a/pysollib/winsystems/x11.py
+++ b/pysollib/winsystems/x11.py
@@ -33,7 +33,7 @@ from pysollib.winsystems.common import \
if TOOLKIT == 'tk':
if USE_TILE:
- from pysollib.tile import ttk
+ from six.moves import tkinter_ttk as ttk
# ************************************************************************