Since the Tkinter wiki is still down, here is the Tile wrapper I maintain:
#######
####November 2006: Posted by Kevin Walzer,
kw@codebykevin. com. Based on
Tile wrapper by Martin Franklin. This version updates the wrapper to
reflect changes in Tile commands, and adds support for Tile-based frames
(ttk::frame). Freely reusable.
import Tkinter
from Tkconstants import *
class Style:
def default(self, style, **kw):
"""Sets the default value of the specified option(s) in style"""
pass
def map_style(self, **kw):
"""Sets dynamic values of the specified option(s) in style. See
"STATE MAPS", below."""
pass
def layout(self, style, layoutSpec):
"""Define the widget layout for style style. See "LAYOUTS" below
for the format of layoutSpec. If layoutSpec is omitted, return the
layout specification for style style. """
pass
def element_create( self, name, type, *args):
"""Creates a new element in the current theme of type type. The
only built-in element type is image (see image(n)), although
themes may define other element types (see
Ttk_RegisterEle mentFactory).
"""
pass
def element_names(s elf):
"""Returns a list of all elements defined in the current theme. """
pass
def theme_create(se lf, name, parent=None, basedon=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 parent theme basedon. If -settings is
present,
script is evaluated in the context of the new theme as per
style theme
settings.
"""
pass
def theme_settings( self, name, script):
"""Temporar ily sets the current theme to themeName, evaluate
script,
then restore the previous theme. Typically script simply
defines styles
and elements, though arbitrary Tcl code may appear.
"""
pass
def theme_names(sel f):
"""Returns a list of the available themes. """
return self.tk.call("s tyle", "theme", "names")
def theme_use(self, theme):
"""Sets the current theme to themeName, and refreshes all
widgets."""
return self.tk.call("s tyle", "theme", "use", theme)
class Widget(Tkinter. Widget, Style):
def __init__(self, master, widgetName=None , cnf={}, kw={}, extra=()):
if not widgetName:
## why you would ever want to create a Tile Widget is
behond me!
widgetName="ttk ::widget"
Tkinter.Widget. __init__(self, master, widgetName, cnf, kw)
def instate(self, spec=None, script=None):
"""Test the widget's state. If script is not specified, returns 1
if the widget state matches statespec and 0 otherwise. If script
is specified, equivalent to if {[pathName instate stateSpec]}
script.
"""
return self.tk.call(se lf._w, "instate", spec, script)
def state(self, spec=None):
"""Modify or inquire widget state. If stateSpec is present, sets
the widget state: for each flag in stateSpec, sets the
corresponding
flag or clears it if prefixed by an exclamation point. Returns
a new
state spec indicating which flags were changed: ''set changes
[pathName state spec] ; pathName state $changes'' will restore
pathName to the original state. If stateSpec is not specified,
returns a list of the currently-enabled state flags.
"""
return self.tk.call(se lf._w, "state", spec)
class Button(Widget, Tkinter.Button) :
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::butto n", cnf, kw)
###add frame support here--KWs
class Frame(Widget, Tkinter.Frame):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::frame ", cnf, kw)
class Checkbutton(Wid get, Tkinter.Checkbu tton):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::checkbutt on", cnf, kw)
class Combobox(Widget , Tkinter.Entry):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::combobox" , cnf, kw)
def current(self, index=None):
"""If index 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(se lf._w, "current", index)
class Entry(Widget, Tkinter.Entry):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::entry ", cnf, kw)
def validate(self):
"""Force revalidation, independent of the conditions specified by
the -validate option. Returns 0 if the -validatecommand returns a
false value, or 1 if it returns a true value or is not specified.
"""
return self.tk.call(se lf._w, "validate")
class Label(Widget, Tkinter.Label):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::label ", cnf, kw)
###add LabelFrame class here--KW
class LabelFrame(Widg et, Tkinter.Label):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::labelfram e", cnf, kw)
class Menubutton(Widg et, Tkinter.Menubut ton):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::menubutto n", cnf, kw)
class Notebook(Widget ):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::notebook" , cnf, kw)
def add(self, child, cnf=(), **kw):
"""Adds a new tab to the notebook. When the tab is selected, the
child window will be displayed. child must be a direct child of
the notebook window. See TAB OPTIONS for the list of available
options.
"""
return self.tk.call((s elf._w, "add", child) +
self._options(c nf, kw))
def forget(self, index):
"""Removes the tab specified by index, unmaps and unmanages the
associated child window.
"""
return self.tk.call(se lf._w, "forget", index)
def index(self, index):
"""Returns the numeric index of the tab specified by index, or
the total number of tabs if index is the string "end".
"""
return self.tk.call(se lf._w, "index")
def select(self, index):
"""Selects the specified tab; the associated child pane will
be displayed, and the previously-selected pane (if different)
is unmapped.
"""
return self.tk.call(se lf._w, "select", index)
def tab(self, index, **kw):
"""Query or modify the options of the specific tab. If no
-option is specified, returns a dictionary of the tab option
values. If one -option is specified, returns the value of tha
t option. Otherwise, sets the -options to the corresponding
values. See TAB OPTIONS for the available options.
"""
return self.tk.call((s elf._w, "tab", index) + self._options(k w))
def tabs(self):
"""Returns a list of all pane windows managed by the widget."""
return self.tk.call(se lf._w, "tabs")
class Paned(Widget):
"""
WIDGET OPTIONS
Name Database name Database class
-orient orient Orient
Specifies the orientation of the window. If vertical, subpanes
are stacked top-to-bottom; if horizontal, subpanes are stacked
left-to-right.
PANE OPTIONS
The following options may be specified for each pane:
Name Database name Database class
-weight weight Weight
An integer specifying the relative stretchability of the pane.
When the paned window is resized, the extra space is added or
subracted to each pane proportionally to its -weight
"""
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::paned ", cnf, kw)
def add(self, subwindow, **kw):
"""Adds a new pane to the window. subwindow must be a direct
child of
the paned window pathname. See PANE OPTIONS for the list of
available
options.
"""
return self.tk.call((s elf._w, "add", subwindow) +
self._options(k w))
def forget(self, pane):
"""Removes the specified subpane from the widget. pane is
either an
integer index or the name of a managed subwindow.
"""
self.tk.call(se lf._w, "forget", pane)
def insert(self, pos, subwindow, **kw):
"""Inserts a pane at the specified position. pos is either the
string
end, an integer index, or the name of a managed subwindow. If
subwindow
is already managed by the paned window, moves it to the specified
position. See PANE OPTIONS for the list of available options.
"""
return self.tk.call((s elf._w, "insert", pos, subwindow) +
self._options(k w))
def pane(self, pane, **kw):
"""Query or modify the options of the specified pane, where
pane is
either an integer index or the name of a managed subwindow. If no
-option is specified, returns a dictionary of the pane option
values.
If one -option is specified, returns the value of that option.
Otherwise, sets the -options to the corresponding values.
"""
return self.tk.call((s elf._w, "pane", pane) + self._options(k w))
class Progressbar(Wid get):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::progressb ar", cnf, kw)
def step(self, amount=1.0):
"""Incremen ts the -value by amount. amount defaults to 1.0
if omitted. """
return self.tk.call(se lf._w, "step", amount)
def start(self):
self.tk.call("t tk::progressbar ::start", self._w)
def stop(self):
self.tk.call("t tk::progressbar ::stop", self._w)
class Radiobutton(Wid get, Tkinter.Radiobu tton):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::radiobutt on", cnf, kw)
class Scrollbar(Widge t, Tkinter.Scrollb ar):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::scrollbar ", cnf, kw)
class Separator(Widge t):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, "ttk::separator ", cnf, kw)
class Treeview(Widget , Tkinter.Listbox ):
def __init__(self, master=None, cnf={}, **kw):
Widget.__init__ (self, master, 'ttk::treeview' , cnf, kw)
def children(self, item, newchildren=Non e):
"""If newchildren is not specified, returns the list of
children belonging to item.
If newchildren is specified, replaces item's child list
with newchildren. Items in the old child list not present
in the new child list are detached from the tree. None of
the items in newchildren may be an ancestor of item.
"""
return self.tk.call(se lf._w, "children", item, newchildren)
def column(self, column, **kw):
"""Query or modify the options for the specified column.
If no options are specified, returns a dictionary of
option/value pairs. If a single option is specified,
returns the value of that option. Otherwise, the options
are updated with the specified values. The following
options may be set on each column:
-id name
The column name. This is a read-only option. For example,
[$pathname column #n -id] returns the data column
associated with data column #n.
-anchor
Specifies how the text in this column should be aligned
with respect to the cell. One of n, ne, e, se, s, sw, w,
nw, or center.
-width w
The width of the column in pixels. Default is something
reasonable, probably 200 or so.
"""
pass
def delete(self, items):
"""Deletes each of the items and all of their descendants.
The root item may not be deleted. See also: detach.
"""
return self.tk.call(se lf._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. See
also: delete.
"""
return self.tk.call(se lf._w, "detach", items)
def exists(self, item):
"""Returns 1 if the specified item is present in the
tree, 0 otherwise.
"""
return self.tk.call(se lf._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(se lf._w, "focus", item)
def heading(self, column, **kw):
"""Query or modify the heading options for the specified
column. Valid options are:
-text text
The text to display in the column heading.
-image imageName
Specifies an image to display to the right of the column
heading.
-command script
A script to evaluate when the heading label is pressed.
"""
pass
def identify(self, x, y):
"""Returns a description of the widget component under the
point given
by x and y. The return value is a list with one of the
following forms:
heading #n
The column heading for display column #n.
separator #n
The border to the right of display column #n.
cell itemid #n
The data value for item itemid in display column #n.
item itemid element
The tree label for item itemid; element is one of text,
image, or
indicator, or another element name depending on the style.
row itemid
The y position is over the item but x does not identify any
element
or displayed data value.
nothing
The coordinates are not over any identifiable object.
See COLUMN IDENTIFIERS for a discussion of display columns and
data
columns.
"""
pass
def index(self, item):
"""Returns the integer index of item within its parent's list of
children.
"""
pass
def insert(self, parent, index, id=None, **kw):
"""Creates a new 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 -id is specified, it is used as the item identifier; id
must
not already exist in the tree. Otherwise, a new unique
identifier is
generated.
returns the item identifier of the newly created item. See ITEM
OPTIONS for the list of available options.
"""
pass
def item(item, **kw):
"""Query or modify the options for the specified item. If no
-option
is specified, returns a dictionary of option/value pairs. If a
single
-option is specified, returns the value of that option.
Otherwise, the
item's options are updated with the specified values. See ITEM
OPTIONS
for the list of available options.
"""
pass
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's
moved to the end.
"""
pass
def next(self, item):
"""Returns the identifier of item's next sibling, or {} if item
is the
last child of its parent.
"""
pass
def parent(self, item):
"""Returns the ID of the parent of item, or {} if item is at
the top
level of the hierarchy.
"""
pass
def prev(self, item):
"""Returns the identifier of item's previous sibling, or {} if
item is
the first child of its parent.
"""
pass
def selection(self) :
"""Returns the list of selected items"""
pass
def selection_set(s elf, items):
"""items becomes the new selection. """
pass
def selection_add(s elf, items):
"""Add items to the selection """
pass
def selection_remov e(self, items):
"""Remove items from the selection """
pass
def selection_toggl e(self, items):
"""Toggle the selection state of each item in items. """
pass
def set(self, item, column, value=None):
"""If value is specified, sets the value of column column in
item item,
otherwise returns the current value. See COLUMN IDENTIFIERS.
"""
pass
if __name__=="__ma in__":
def callback():
print "Hello"
root = Tkinter.Tk()
root.tk.call("p ackage", "require", "tile")
f = Frame(root, width=150)
f.pack(fill="bo th", expand="yes")
b = Button(root, text="Tile Button", command=callbac k)
b.pack()
#~ c = Checkbutton(roo t)
#~ c.pack()
#~ print b.theme_names()
#~ cb = Combobox(root)
#~ cb.pack()
#~ e = Entry(root)
#~ e.validate()
#~ e.pack()
#~ l = Label(root, text="Tile Label")
#~ l.pack()
#~ mb = Menubutton(root )
#~ mb.pack()
#~ nb = Notebook(root)
#~ f1 = Label(nb, text="page1")
#~ nb.add(f1, text="Page1")
#~ f1.pack()
#~ f2 = Label(nb, text="page2")
#~ nb.add(f2, text="Page 2")
#~ f2.pack()
#~ nb.pack()
pb = Progressbar(roo t, mode="indetermi nate")
pb.pack()
pb.start()
b = Button(root, text="Start", command=pb.star t)
b.pack()
b = Button(root, text="Stop", command=pb.stop )
b.pack()
#~ rb = Radiobutton(roo t)
#~ rb.pack()
#~ text = Tkinter.Text(ro ot)
#~ scrol = Scrollbar(root)
#~ text.pack(side= "left", fill="both", expand="yes")
#~ scrol.pack(side ="left", fill="y")
#~ text['yscrollcommand '] = scrol.set
#~ scrol['command'] = text.yview
#~ l = Label(root, text="Label1")
#~ l.pack()
#~ s = Separator(root)
#~ s.pack(fill="x" )
#~ l = Label(root, text="Label2")
#~ l.pack()
#b.theme_use("d efault")
#~ b1 = Tkinter.Button( root, text="Tk Button", command=callbac k)
#~ b1.pack()
panes = Paned(root)
panes.pack(fill ="both", expand="yes")
label1 = Label(panes, text="pane1")
label2 = Label(panes, text="Pane2")
panes.add(label 1)
panes.add(label 2)
#~ tree = Treeview(root, columns=("One", "Two", "Three"))
#~ tree.insert(Non e, "end", text="Hello")
#~ tree.pack()
root.mainloop()
