cpython/Doc/lib/tkinter.tex

\chapter{Graphical User Interfaces with Tk \label{tkinter}}

\index{GUI}
\index{Graphical User Interface}
\index{Tkinter}
\index{Tk}

Tk/Tcl has long been an integral part of Python.  It provides a robust
and platform independent windowing toolkit, that is available to
Python programmers using the \refmodule{Tkinter} module, and its
extension, the \refmodule{Tix} module.

The \refmodule{Tkinter} module is a thin object--oriented layer on top of
Tcl/Tk. To use \refmodule{Tkinter}, you don't need to write Tcl code,
but you will need to consult the Tk documentation, and occasionally
the Tcl documentation.  \refmodule{Tkinter} is a set of wrappers that
implement the Tk widgets as Python classes.  In addition, the internal
module \module{\_tkinter} provides a threadsafe mechanism which allows
Python and Tcl to interact.

Tk is not the only GUI for Python, but is however the most commonly
used one; see section~\ref{other-gui-modules}, ``Other User Interface
Modules and Packages,'' for more information on other GUI toolkits for
Python.

% Other sections I have in mind are
% Tkinter internals
% Freezing Tkinter applications

\localmoduletable


\section{\module{Tkinter} ---
         Python interface to Tcl/Tk}

\declaremodule{standard}{Tkinter}
\modulesynopsis{Interface to Tcl/Tk for graphical user interfaces}
\moduleauthor{Guido van Rossum}{guido@Python.org}

The \module{Tkinter} module (``Tk interface'') is the standard Python
interface to the Tk GUI toolkit, now maintained at ActiveState.  Both
Tk and \module{Tkinter} are available on most \UNIX{} platforms, as well
as on Windows and Macintosh systems.

\begin{seealso}
\seetitle[http://www.python.org/topics/tkinter/]
         {Python Tkinter Resources}
         {The Python Tkinter Topic Guide provides a great
            deal of information on using Tk from Python and links to
            other sources of information on Tk.}

\seetitle[http://www.pythonware.com/library/an-introduction-to-tkinter.htm]
         {An Introduction to Tkinter}
         {Fredrik Lundh's on-line reference material.}

\seetitle[http://www.nmt.edu/tcc/help/pubs/lang.html]
         {Tkinter reference: a GUI for Python}
         {On-line reference material.}
        
\seetitle[http://jtkinter.sourceforge.net]
         {Tkinter for JPython}
         {The Jython interface to Tkinter.}

\seetitle[http://www.amazon.com/exec/obidos/ASIN/1884777813]
         {Python and Tkinter Programming}
         {The book by John Grayson (ISBN 1-884777-81-3).}
\end{seealso}


\subsection{Tkinter Modules}

Most of the time, the \refmodule{Tkinter} module is all you really
need, but a number of additional modules are available as well.  The
Tk interface is located in a binary module named \module{_tkinter}.
This module contains the low-level interface to Tk, and should never
be used directly by application programmers. It is usually a shared
library (or DLL), but might in some cases be statically linked with
the Python interpreter.

In addition to the Tk interface module, \refmodule{Tkinter} includes a
number of Python modules. The two most important modules are the
\refmodule{Tkinter} module itself, and a module called
\module{Tkconstants}. The former automatically imports the latter, so
to use Tkinter, all you need to do is to import one module:

\begin{verbatim}
import Tkinter
\end{verbatim}

Or, more often:

\begin{verbatim}
from Tkinter import *
\end{verbatim}

\begin{classdesc}{Tk}{screenName=None, baseName=None, className='Tk'}
The \class{Tk} class is instantiated without arguments.
This creates a toplevel widget of Tk which usually is the main window
of an appliation. Each instance has its own associated Tcl interpreter.
% FIXME: The following keyword arguments are currently recognized:
\end{classdesc}

Other modules that provide Tk support include:

\begin{description}
% \declaremodule{standard}{Tkconstants}
% \modulesynopsis{Constants used by Tkinter}
% FIXME 

\item[\module{tkColorChooser}]
Dialog to let the user choose a color.

\item[\module{tkCommonDialog}]
Base class for the dialogs defined in the other modules listed here.

\item[\module{tkFileDialog}]
Common dialogs to allow the user to specify a file to open or save.

\item[\module{tkFont}]
Utilities to help work with fonts.

\item[\module{tkMessageBox}]
Access to standard Tk dialog boxes.

\item[\module{tkSimpleDialog}]
Basic dialogs and convenience functions.

\item[\module{Tkdnd}]
Drag-and-drop support for \refmodule{Tkinter}.
This is experimental and should become deprecated when it is replaced 
with the Tk DND.

\item[\refmodule{turtle}]
Turtle graphics in a Tk window.

\end{description}

\subsection{Tkinter Life Preserver}
\sectionauthor{Matt Conway}{}
% Converted to LaTeX by Mike Clarkson.

This section is not designed to be an exhaustive tutorial on either
Tk or Tkinter.  Rather, it is intended as a stop gap, providing some
introductory orientation on the system.

Credits:
\begin{itemize}
\item   Tkinter was written by Steen Lumholt and Guido van Rossum.
\item   Tk was written by John Ousterhout while at Berkeley.
\item   This Life Preserver was written by Matt Conway at
the University of Virginia.
\item   The html rendering, and some liberal editing, was
produced from a FrameMaker version by Ken Manheimer.
\item   Fredrik Lundh elaborated and revised the class interface descriptions,
to get them current with Tk 4.2.
\item  Mike Clarkson converted the documentation to \LaTeX, and compiled the 
User Interface chapter of the reference manual.
\end{itemize}


\subsubsection{How To Use This Section}

This section is designed in two parts: the first half (roughly) covers
background material, while the second half can be taken to the
keyboard as a handy reference.

When trying to answer questions of the form ``how do I do blah'', it
is often best to find out how to do``blah'' in straight Tk, and then
convert this back into the corresponding \refmodule{Tkinter} call.
Python programmers can often guess at the correct Python command by
looking at the Tk documentation. This means that in order to use
Tkinter, you will have to know a little bit about Tk. This document
can't fulfill that role, so the best we can do is point you to the
best documentation that exists. Here are some hints:

\begin{itemize}
\item   The authors strongly suggest getting a copy of the Tk man
pages. Specifically, the man pages in the \code{mann} directory are most
useful. The \code{man3} man pages describe the C interface to the Tk
library and thus are not especially helpful for script writers.  

\item   Addison-Wesley publishes a book called \citetitle{Tcl and the
Tk Toolkit} by John Ousterhout (ISBN 0-201-63337-X) which is a good
introduction to Tcl and Tk for the novice.  The book is not
exhaustive, and for many details it defers to the man pages. 

\item   \file{Tkinter.py} is a last resort for most, but can be a good
place to go when nothing else makes sense.  
\end{itemize}

\begin{seealso}
\seetitle[http://tcl.activestate.com/]
        {ActiveState Tcl Home Page}
        {The Tk/Tcl development is largely taking place at
         ActiveState.}
\seetitle[http://www.amazon.com/exec/obidos/ASIN/020163337X]
        {Tcl and the Tk Toolkit}
        {The book by John Ousterhout, the inventor of Tcl .}
\seetitle[http://www.amazon.com/exec/obidos/ASIN/0130220280]
        {Practical Programming in Tcl and Tk}
        {Brent Welch's encyclopedic book.}
\end{seealso}


\subsubsection{A Simple Hello World Program} % HelloWorld.html

%begin{latexonly}
%\begin{figure}[hbtp]
%\centerline{\epsfig{file=HelloWorld.gif,width=.9\textwidth}}
%\vspace{.5cm}
%\caption{HelloWorld gadget image}
%\end{figure}
%See also the hello-world \ulink{notes}{classes/HelloWorld-notes.html} and
%\ulink{summary}{classes/HelloWorld-summary.html}.
%end{latexonly}


\begin{verbatim}
from Tkinter import *                                                    1
                                                                         2
class Application(Frame):                                                3
    def say_hi(self):                                                    4
        print "hi there, everyone!"                                      5
                                                                         6
    def createWidgets(self):                                             7
        self.QUIT = Button(self)                                         8
        self.QUIT["text"] = "QUIT"                                       9
        self.QUIT["fg"]   = "red"                                       10
        self.QUIT["command"] =  self.quit                               11
                                                                        12
        self.QUIT.pack({"side": "left"})                                13
                                                                        14
        self.hi_there = Button(self)                                    15
        self.hi_there["text"] = "Hello",                                16
        self.hi_there["command"] = self.say_hi                          17
                                                                        18
        self.hi_there.pack({"side": "left"})                            19
                                                                        20
                                                                        21
    def __init__(self, master=None):                                    22
        Frame.__init__(self, master)                                    23
            self.pack()                                                 24
        self.createWidgets()                                            25
                                                                        26
app = Application()                                                     27
app.mainloop()                                                          28
\end{verbatim}


\subsection{A (Very) Quick Look at Tcl/Tk} % BriefTclTk.html

The class hierarchy looks complicated, but in actual practice,
application programmers almost always refer to the classes at the very
bottom of the hierarchy. 

Notes:
\begin{itemize}
\item   These classes are provided for the purposes of
organizing certain functions under one namespace. They aren't meant to
be instantiated independently.

\item    The \class{Tk} class is meant to be instantiated only once in
an application. Application programmers need not instantiate one
explicitly, the system creates one whenever any of the other classes
are instantiated.

\item    The \class{Widget} class is not meant to be instantiated, it
is meant only for subclassing to make ``real'' widgets (in \Cpp, this
is called an `abstract class').
\end{itemize}

To make use of this reference material, there will be times when you
will need to know how to read short passages of Tk and how to identify
the various parts of a Tk command.  
(See section~\ref{tkinter-basic-mapping} for the
\refmodule{Tkinter} equivalents of what's below.)

Tk scripts are Tcl programs.  Like all Tcl programs, Tk scripts are
just lists of tokens separated by spaces.  A Tk widget is just its
\emph{class}, the \emph{options} that help configure it, and the
\emph{actions} that make it do useful things. 

To make a widget in Tk, the command is always of the form: 

\begin{verbatim}
                classCommand newPathname options
\end{verbatim}

\begin{description}
\item[\var{classCommand}]
denotes which kind of widget to make (a button, a label, a menu...)

\item[\var{newPathname}]
is the new name for this widget.  All names in Tk must be unique.  To
help enforce this, widgets in Tk are named with \emph{pathnames}, just
like files in a file system.  The top level widget, the \emph{root},
is called \code{.} (period) and children are delimited by more
periods.  For example, \code{.myApp.controlPanel.okButton} might be
the name of a widget.

\item[\var{options} ]
configure the widget's appearance and in some cases, its
behavior.  The options come in the form of a list of flags and values.
Flags are proceeded by a `-', like unix shell command flags, and
values are put in quotes if they are more than one word.
\end{description}

For example: 

\begin{verbatim}
    button   .fred   -fg red -text "hi there"
       ^       ^     \_____________________/
       |       |                |
     class    new            options
    command  widget  (-opt val -opt val ...)
\end{verbatim} 

Once created, the pathname to the widget becomes a new command.  This
new \var{widget command} is the programmer's handle for getting the new
widget to perform some \var{action}.  In C, you'd express this as
someAction(fred, someOptions), in \Cpp, you would express this as
fred.someAction(someOptions), and in Tk, you say: 

\begin{verbatim}
    .fred someAction someOptions 
\end{verbatim} 

Note that the object name, \code{.fred}, starts with a dot.

As you'd expect, the legal values for \var{someAction} will depend on
the widget's class: \code{.fred disable} works if fred is a
button (fred gets greyed out), but does not work if fred is a label
(disabling of labels is not supported in Tk). 

The legal values of \var{someOptions} is action dependent.  Some
actions, like \code{disable}, require no arguments, others, like
a text-entry box's \code{delete} command, would need arguments
to specify what range of text to delete.  


\subsection{Mapping Basic Tk into Tkinter
            \label{tkinter-basic-mapping}}

Class commands in Tk correspond to class constructors in Tkinter.

\begin{verbatim}
    button .fred                =====>  fred = Button()
\end{verbatim}

The master of an object is implicit in the new name given to it at
creation time.  In Tkinter, masters are specified explicitly.

\begin{verbatim}
    button .panel.fred          =====>  fred = Button(panel)
\end{verbatim}

The configuration options in Tk are given in lists of hyphened tags
followed by values.  In Tkinter, options are specified as
keyword-arguments in the instance constructor, and keyword-args for
configure calls or as instance indices, in dictionary style, for
established instances.  See section~\ref{tkinter-setting-options} on
setting options.

\begin{verbatim}
    button .fred -fg red        =====>  fred = Button(panel, fg = "red")
    .fred configure -fg red     =====>  fred["fg"] = red
                                OR ==>  fred.config(fg = "red")
\end{verbatim}

In Tk, to perform an action on a widget, use the widget name as a
command, and follow it with an action name, possibly with arguments
(options).  In Tkinter, you call methods on the class instance to
invoke actions on the widget.  The actions (methods) that a given
widget can perform are listed in the Tkinter.py module.

\begin{verbatim}
    .fred invoke                =====>  fred.invoke()
\end{verbatim}

To give a widget to the packer (geometry manager), you call pack with
optional arguments.  In Tkinter, the Pack class holds all this
functionality, and the various forms of the pack command are
implemented as methods.  All widgets in \refmodule{Tkinter} are
subclassed from the Packer, and so inherit all the packing
methods. See the \refmodule{Tix} module documentation for additional
information on the Form geometry manager.

\begin{verbatim}
    pack .fred -side left       =====>  fred.pack(side = "left")
\end{verbatim}


\subsection{How Tk and Tkinter are Related} % Relationship.html

\note{This was derived from a graphical image; the image will be used
      more directly in a subsequent version of this document.}

From the top down:
\begin{description}
\item[\b{Your App Here (Python)}]
A Python application makes a \refmodule{Tkinter} call.

\item[\b{Tkinter (Python Module)}]
This call (say, for example, creating a button widget), is
implemented in the \emph{Tkinter} module, which is written in
Python.  This Python function will parse the commands and the
arguments and convert them into a form that makes them look as if they
had come from a Tk script instead of a Python script.

\item[\b{tkinter (C)}]
These commands and their arguments will be passed to a C function
in the \emph{tkinter} - note the lowercase - extension module.

\item[\b{Tk Widgets} (C and Tcl)]
This C function is able to make calls into other C modules,
including the C functions that make up the Tk library.  Tk is
implemented in C and some Tcl.  The Tcl part of the Tk widgets is used
to bind certain default behaviors to widgets, and is executed once at
the point where the Python \refmodule{Tkinter} module is
imported. (The user never sees this stage).

\item[\b{Tk (C)}]
The Tk part of the Tk Widgets implement the final mapping to ...

\item[\b{Xlib (C)}]
the Xlib library to draw graphics on the screen.
\end{description}


\subsection{Handy Reference}

\subsubsection{Setting Options
               \label{tkinter-setting-options}}

Options control things like the color and border width of a widget.
Options can be set in three ways:

\begin{description}
\item[At object creation time, using keyword arguments]:
\begin{verbatim}
fred = Button(self, fg = "red", bg = "blue")
\end{verbatim}
\item[After object creation, treating the option name like a dictionary index]:
\begin{verbatim}
fred["fg"] = "red"
fred["bg"] = "blue"
\end{verbatim}
\item[Use the config() method to update multiple attrs subesequent to
object creation]:
\begin{verbatim}
fred.config(fg = "red", bg = "blue")
\end{verbatim}
\end{description}

For a complete explanation of a given option and its behavior, see the
Tk man pages for the widget in question.

Note that the man pages list "STANDARD OPTIONS" and "WIDGET SPECIFIC
OPTIONS" for each widget.  The former is a list of options that are
common to many widgets, the latter are the options that are
ideosyncratic to that particular widget.  The Standard Options are
documented on the \manpage{options}{3} man page.

No distinction between standard and widget-specific options is made in
this document.  Some options don't apply to some kinds of widgets.
Whether a given widget responds to a particular option depends on the
class of the widget; buttons have a \code{command} option, labels do not. 

The options supported by a given widget are listed in that widget's
man page, or can be queried at runtime by calling the
\kbd{config()} method with arguments, or by calling the keys()
method on that widget. The return value of these calls is a dictionary
whose key is the name of the option (e.g. \kbd{relief}) and whose
values are 5 tuples. 

(Some options, like \kbd{bg} are synonyms for common options with
hard-to-type names (\kbd{bg} is shorthand for "background"). 
Passing the \kbd{config()} method the name of a
shorthand option will return a 2-tuple, not 5-tuple. The 2-tuple
passed back will contain the name of the synonym ``real''
option. (\kbd{bg}, \kbd{background}))

\begin{tableiii}{c|l|l}{textrm}{Index}{Meaning}{Example}
  \lineiii{0}{option name}                       {\code{'relief'}}
  \lineiii{1}{option name for database lookup}   {\code{'relief'}}
  \lineiii{2}{option class for database lookup}  {\code{'Relief'}}
  \lineiii{3}{default value}                     {\code{'raised'}}
  \lineiii{4}{current value}                     {\code{'groove'}}
\end{tableiii}


Example:

\begin{verbatim}
>>> print fred.config()
{'relief' : ('relief', 'relief', 'Relief', 'raised', 'groove')}
\end{verbatim}

Of course, the dictionary printed will include all the options
available and their values.  This is meant only as an example.


\subsubsection{The Packer} % Packer.html
\index{packing (widgets)}

The packer is one of Tk's geometry-management mechanisms.  See also
\citetitle[classes/ClassPacker.html]{the Packer class interface}.

Geometry managers are used to specify the relative positioning of the
positioning of widgets within their container - their mutual
\emph{master}.  In contrast to the more cumbersome \emph{placer}
(which is used less commonly, and we do not cover here), the packer
takes qualitative relationship specification - \emph{above}, \emph{to
the left of}, \emph{filling}, etc - and works everything out to
determine the exact placement coordinates for you. 

The size of any \emph{master} widget is determined by the size of
the "slave widgets" inside.  The packer is used to control where slave
widgets appear inside the master into which they are packed.  You can
pack widgets into frames, and frames into other frames, in order to
achieve the kind of layout you desire.  Additionally, the arrangement
is dynamically adjusted to accomodate incremental changes to the
configuration, once it is packed.

Note that widgets do not appear until they have had their geometry
specified with a geometry manager.  It's a common early mistake to
leave out the geometry specification, and then be surprised when the
widget is created but nothing appears.  A widget will appear only
after it has had, for example, the packer's \method{pack()} method
applied to it.

The pack() method can be called with keyword-option/value pairs that
control where the widget is to appear within its container, and how it
is to behave when the main application window is resized.  Here are
some examples:

\begin{verbatim}
    fred.pack()                     # defaults to side = "top"
    fred.pack(side = "left")
    fred.pack(expand = 1)
\end{verbatim}


\subsubsection{Packer Options}

For more extensive information on the packer and the options that it
can take, see the man pages and page 183 of John Ousterhout's book.

\begin{description}
\item[\b{anchor }]
Anchor type.  Denotes where the packer is to place each slave in its
parcel.

\item[\b{expand}]
Boolean, \code{0} or \code{1}.

\item[\b{fill}]
Legal values: \code{'x'}, \code{'y'}, \code{'both'}, \code{'none'}.

\item[\b{ipadx} and \b{ipady}]
A distance - designating internal padding on each side of the slave
widget.

\item[\b{padx} and \b{pady}]
A distance - designating external padding on each side of the slave
widget.

\item[\b{side}]
Legal values are: \code{'left'}, \code{'right'}, \code{'top'},
\code{'bottom'}.
\end{description}


\subsubsection{Coupling Widget Variables} % VarCouplings.html

The current-value setting of some widgets (like text entry widgets)
can be connected directly to application variables by using special
options.  These options are \code{variable}, \code{textvariable},
\code{onvalue}, \code{offvalue}, and \code{value}.  This
connection works both ways: if the variable changes for any reason,
the widget it's connected to will be updated to reflect the new value. 

Unfortunately, in the current implementation of \refmodule{Tkinter} it is
not possible to hand over an arbitrary Python variable to a widget
through a \code{variable} or \code{textvariable} option.  The only
kinds of variables for which this works are variables that are
subclassed from a class called Variable, defined in the
\refmodule{Tkinter} module.

There are many useful subclasses of Variable already defined:
\class{StringVar}, \class{IntVar}, \class{DoubleVar}, and
\class{BooleanVar}.  To read the current value of such a variable,
call the \method{get()} method on
it, and to change its value you call the \method{set()} method.  If
you follow this protocol, the widget will always track the value of
the variable, with no further intervention on your part.

For example: 
\begin{verbatim}
class App(Frame):
    def __init__(self, master=None):
        Frame.__init__(self, master)
        self.pack()
        
        self.entrythingy = Entry()
        self.entrythingy.pack()
        
        self.button.pack()
        # here is the application variable
        self.contents = StringVar()
        # set it to some value
        self.contents.set("this is a variable")
        # tell the entry widget to watch this variable
        self.entrythingy["textvariable"] = self.contents
        
        # and here we get a callback when the user hits return.
        # we will have the program print out the value of the
        # application variable when the user hits return
        self.entrythingy.bind('<Key-Return>',
                              self.print_contents)

    def print_contents(self, event):
        print "hi. contents of entry is now ---->", \
              self.contents.get()
\end{verbatim}


\subsubsection{The Window Manager} % WindowMgr.html
\index{window manager (widgets)}

In Tk, there is a utility command, \code{wm}, for interacting with the
window manager.  Options to the \code{wm} command allow you to control
things like titles, placement, icon bitmaps, and the like.  In
\refmodule{Tkinter}, these commands have been implemented as methods
on the \class{Wm} class.  Toplevel widgets are subclassed from the
\class{Wm} class, and so can call the \class{Wm} methods directly.

%See also \citetitle[classes/ClassWm.html]{the Wm class interface}.

To get at the toplevel window that contains a given widget, you can
often just refer to the widget's master.  Of course if the widget has
been packed inside of a frame, the master won't represent a toplevel
window.  To get at the toplevel window that contains an arbitrary
widget, you can call the \method{_root()} method.  This
method begins with an underscore to denote the fact that this function
is part of the implementation, and not an interface to Tk functionality.

Here are some examples of typical usage:

\begin{verbatim}
import Tkinter
class App(Frame):
    def __init__(self, master=None):
        Frame.__init__(self, master)
        self.pack()


# create the application
myapp = App()

#
# here are method calls to the window manager class
#
myapp.master.title("My Do-Nothing Application")
myapp.master.maxsize(1000, 400)

# start the program
myapp.mainloop()
\end{verbatim}


\subsubsection{Tk Option Data Types} % OptionTypes.html

\index{Tk Option Data Types}

\begin{description}
\item[anchor]
Legal values are points of the compass: \code{"n"},
\code{"ne"}, \code{"e"}, \code{"se"}, \code{"s"},
\code{"sw"}, \code{"w"}, \code{"nw"}, and also
\code{"center"}.

\item[bitmap]
There are eight built-in, named bitmaps: \code{'error'}, \code{'gray25'},
\code{'gray50'}, \code{'hourglass'}, \code{'info'}, \code{'questhead'},
\code{'question'}, \code{'warning'}.  To specify an X bitmap
filename, give the full path to the file, preceded with an \code{@},
as in \code{"@/usr/contrib/bitmap/gumby.bit"}.

\item[boolean]
You can pass integers 0 or 1 or the stings \code{"yes"} or \code{"no"} .

\item[callback]
This is any Python function that takes no arguments.  For example: 
\begin{verbatim}
    def print_it():
            print "hi there"
    fred["command"] = print_it
\end{verbatim}

\item[color]
Colors can be given as the names of X colors in the rgb.txt file,
or as strings representing RGB values in 4 bit: \code{"\#RGB"}, 8
bit: \code{"\#RRGGBB"}, 12 bit" \code{"\#RRRGGGBBB"}, or 16 bit
\code{"\#RRRRGGGGBBBB"} ranges, where R,G,B here represent any
legal hex digit.  See page 160 of Ousterhout's book for details.  

\item[cursor]
The standard X cursor names from \file{cursorfont.h} can be used,
without the \code{XC_} prefix.  For example to get a hand cursor
(\constant{XC_hand2}), use the string \code{"hand2"}.  You can also
specify a bitmap and mask file of your own.  See page 179 of
Ousterhout's book.

\item[distance]
Screen distances can be specified in either pixels or absolute
distances.  Pixels are given as numbers and absolute distances as
strings, with the trailing character denoting units: \code{c}
for centimeters, \code{i} for inches, \code{m} for millimeters,
\code{p} for printer's points.  For example, 3.5 inches is expressed
as \code{"3.5i"}.

\item[font]
Tk uses a list font name format, such as \code{\{courier 10 bold\}}.
Font sizes with positive numbers are measured in points;
sizes with negative numbers are measured in pixels.

\item[geometry]
This is a string of the form \samp{\var{width}x\var{height}}, where
width and height are measured in pixels for most widgets (in
characters for widgets displaying text).  For example:
\code{fred["geometry"] = "200x100"}.

\item[justify]
Legal values are the strings: \code{"left"},
\code{"center"}, \code{"right"}, and \code{"fill"}.

\item[region]
This is a string with four space-delimited elements, each of
which is a legal distance (see above).  For example: \code{"2 3 4
5"} and \code{"3i 2i 4.5i 2i"} and \code{"3c 2c 4c 10.43c"} 
are all legal regions.

\item[relief]
Determines what the border style of a widget will be.  Legal
values are: \code{"raised"}, \code{"sunken"},
\code{"flat"}, \code{"groove"}, and \code{"ridge"}.

\item[scrollcommand]
This is almost always the \method{set()} method of some scrollbar
widget, but can be any widget method that takes a single argument.  
Refer to the file \file{Demo/tkinter/matt/canvas-with-scrollbars.py}
in the Python source distribution for an example.

\item[wrap:]
Must be one of: \code{"none"}, \code{"char"}, or \code{"word"}.
\end{description}


\subsubsection{Bindings and Events} % Bindings.html

\index{bind (widgets)}
\index{events (widgets)}

The bind method from the widget command allows you to watch for
certain events and to have a callback function trigger when that event
type occurs.  The form of the bind method is:

\begin{verbatim}
    def bind(self, sequence, func, add=''):
\end{verbatim}
where:

\begin{description}
\item[sequence]
is a string that denotes the target kind of event.  (See the bind
man page and page 201 of John Ousterhout's book for details).

\item[func]
is a Python function, taking one argument, to be invoked when the
event occurs.  An Event instance will be passed as the argument.
(Functions deployed this way are commonly known as \var{callbacks}.)

\item[add]
is optional, either \samp{} or \samp{+}.  Passing an empty string
denotes that this binding is to replace any other bindings that this
event is associated with.  Preceeding with a \samp{+} means that this
function is to be added to the list of functions bound to this event type.
\end{description}

For example:
\begin{verbatim}
    def turnRed(self, event):
        event.widget["activeforeground"] = "red"

    self.button.bind("<Enter>", self.turnRed)
\end{verbatim}

Notice how the widget field of the event is being accesed in the
\method{turnRed()} callback.  This field contains the widget that
caught the X event.  The following table lists the other event fields
you can access, and how they are denoted in Tk, which can be useful
when referring to the Tk man pages.

\begin{verbatim}
Tk      Tkinter Event Field             Tk      Tkinter Event Field 
--      -------------------             --      -------------------
%f      focus                           %A      char
%h      height                          %E      send_event
%k      keycode                         %K      keysym
%s      state                           %N      keysym_num
%t      time                            %T      type
%w      width                           %W      widget
%x      x                               %X      x_root
%y      y                               %Y      y_root
\end{verbatim}


\subsubsection{The index Parameter} % Index.html

A number of widgets require``index'' parameters to be passed.  These
are used to point at a specific place in a Text widget, or to
particular characters in an Entry widget, or to particular menu items
in a Menu widget.

\begin{description}
\item[\b{Entry widget indexes (index, view index, etc.)}]
Entry widgets have options that refer to character positions in the
text being displayed.  You can use these \refmodule{Tkinter} functions
to access these special points in text widgets:

\begin{description}
\item[AtEnd()]
refers to the last position in the text

\item[AtInsert()]
refers to the point where the text cursor is

\item[AtSelFirst()]
indicates the beginning point of the selected text

\item[AtSelLast()]
denotes the last point of the selected text and finally

\item[At(x\optional{, y})]
refers to the character at pixel location \var{x}, \var{y} (with
\var{y} not used in the case of a text entry widget, which contains a
single line of text).
\end{description}

\item[\b{Text widget indexes}]
The index notation for Text widgets is very rich and is best described
in the Tk man pages.

\item[\b{Menu indexes (menu.invoke(), menu.entryconfig(), etc.)}]

Some options and methods for menus manipulate specific menu entries.
Anytime a menu index is needed for an option or a parameter, you may
pass in: 
\begin{itemize}
\item   an integer which refers to the numeric position of the entry in
the widget, counted from the top, starting with 0; 
\item   the string \code{'active'}, which refers to the menu position that is
currently under the cursor;
\item   the string \code{"last"} which refers to the last menu
item;  
\item   An integer preceded by \code{@}, as in \code{@6}, where the integer is
interpreted as a y pixel coordinate in the menu's coordinate system;
\item   the string \code{"none"}, which indicates no menu entry at all, most
often used with menu.activate() to deactivate all entries, and
finally,
\item   a text string that is pattern matched against the label of the
menu entry, as scanned from the top of the menu to the bottom.  Note
that this index type is considered after all the others, which means
that matches for menu items labelled \code{last}, \code{active}, or
\code{none} may be interpreted as the above literals, instead.
\end{itemize}
\end{description}


\section{\module{Tix} ---
         Extension widgets for Tk}

\declaremodule{standard}{Tix}
\modulesynopsis{Tk Extension Widgets for Tkinter}
\sectionauthor{Mike Clarkson}{mikeclarkson@users.sourceforge.net}

\index{Tix}

The \module{Tix} (Tk Interface Extension) module provides an
additional rich set of widgets. Although the standard Tk library has
many useful widgets, they are far from complete. The \module{Tix}
library provides most of the commonly needed widgets that are missing
from standard Tk: \class{HList}, \class{ComboBox}, \class{Control}
(a.k.a. SpinBox) and an assortment of scrollable widgets. \module{Tix}
also includes many more widgets that are generally useful in a wide
range of applications: \class{NoteBook}, \class{FileEntry},
\class{PanedWindow}, etc; there are more than 40 of them.

With all these new widgets, you can introduce new interaction
techniques into applications, creating more useful and more intuitive
user interfaces. You can design your application by choosing the most
appropriate widgets to match the special needs of your application and
users. 

\begin{seealso}
\seetitle[http://tix.sourceforge.net/]
        {Tix Homepage}
        {See the home page for \module{Tix}.}
\seetitle[http://tix.sourceforge.net/dist/current/man/]
        {Tix Man Pages}
        {On-line version of the man pages and reference material.}
\seetitle[http://tix.sourceforge.net/dist/current/docs/tix-book/tix.book.html]
        {Tix Programming Guide}
        {On-line version of the programmer's reference material.}
\seetitle[http://tix.sourceforge.net/Tide/]
        {Tix Development Applications}
        {Tix applications for development of Tix and Tkinter programs.
         Tide applications work under Tk or Tkinter, and include
         \program{TixInspect}, an inspector to remotely modify and
         debug Tix/Tk/Tkinter applications.}
\end{seealso}


\subsection{Using Tix}

\begin{classdesc}{Tix}{screenName\optional{, baseName\optional{, className}}}
    Toplevel widget of Tix which represents mostly the main window
    of an application. It has an associated Tcl interpreter.

Classes in the \refmodule{Tix} module subclasses the classes in the
\refmodule{Tkinter} module. The former imports the latter, so to use
\refmodule{Tix} with Tkinter, all you need to do is to import one
module. In general, you can just import \refmodule{Tix}, and replace
the toplevel call to \class{Tkinter.Tk} with \class{Tix.Tk}:
\begin{verbatim}
import Tix
from Tkconstants import *
root = Tix.Tk()
\end{verbatim}
\end{classdesc}

To use \refmodule{Tix}, you must have the \refmodule{Tix} widgets installed,
usually alongside your installation of the Tk widgets.
To test your installation, try the following:
\begin{verbatim}
import Tix
root = Tix.Tk()
root.tk.eval('package require Tix')
\end{verbatim}

If this fails, you have a Tk installation problem which must be
resolved before proceeding. Use the environment variable \envvar{TIX_LIBRARY}
to point to the installed \refmodule{Tix} library directory, and
make sure you have the dynamic object library (\file{tix8183.dll} or
\file{libtix8183.so}) in  the same directory that contains your Tk
dynamic object library (\file{tk8183.dll} or \file{libtk8183.so}). The
directory with the dynamic object library should also have a file
called \file{pkgIndex.tcl} (case sensitive), which contains the line:

\begin{verbatim}
package ifneeded Tix 8.1 [list load "[file join $dir tix8183.dll]" Tix]
\end{verbatim} % $ <-- bow to font-lock


\subsection{Tix Widgets}

\ulink{Tix}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/TixIntro.htm}
introduces over 40 widget classes to the \refmodule{Tkinter} 
repertoire.  There is a demo of all the \refmodule{Tix} widgets in the
\file{Demo/tix} directory of the standard distribution.


% The Python sample code is still being added to Python, hence commented out


\subsubsection{Basic Widgets}

\begin{classdesc}{Balloon}{}
A \ulink{Balloon}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixBalloon.htm}
that pops up over a widget to provide help.  When the user moves the
cursor inside a widget to which a Balloon widget has been bound, a
small pop-up window with a descriptive message will be shown on the
screen.
\end{classdesc}

% Python Demo of:
% \ulink{Balloon}{http://tix.sourceforge.net/dist/current/demos/samples/Balloon.tcl}

\begin{classdesc}{ButtonBox}{}
The \ulink{ButtonBox}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixButtonBox.htm}
widget creates a box of buttons, such as is commonly used for \code{Ok
Cancel}.
\end{classdesc}

% Python Demo of:
% \ulink{ButtonBox}{http://tix.sourceforge.net/dist/current/demos/samples/BtnBox.tcl}

\begin{classdesc}{ComboBox}{}
The \ulink{ComboBox}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixComboBox.htm}
widget is similar to the combo box control in MS Windows. The user can
select a choice by either typing in the entry subwdget or selecting
from the listbox subwidget.
\end{classdesc}

% Python Demo of:
% \ulink{ComboBox}{http://tix.sourceforge.net/dist/current/demos/samples/ComboBox.tcl}

\begin{classdesc}{Control}{}
The \ulink{Control}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixControl.htm}
widget is also known as the \class{SpinBox} widget. The user can
adjust the value by pressing the two arrow buttons or by entering the
value directly into the entry. The new value will be checked against
the user-defined upper and lower limits.
\end{classdesc}

% Python Demo of:
% \ulink{Control}{http://tix.sourceforge.net/dist/current/demos/samples/Control.tcl}

\begin{classdesc}{LabelEntry}{}
The \ulink{LabelEntry}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixLabelEntry.htm}
widget packages an entry widget and a label into one mega widget. It
can be used be used to simplify the creation of ``entry-form'' type of
interface.
\end{classdesc}

% Python Demo of:
% \ulink{LabelEntry}{http://tix.sourceforge.net/dist/current/demos/samples/LabEntry.tcl}

\begin{classdesc}{LabelFrame}{}
The \ulink{LabelFrame}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixLabelFrame.htm}
widget packages a frame widget and a label into one mega widget.  To
create widgets inside a LabelFrame widget, one creates the new widgets
relative to the \member{frame} subwidget and manage them inside the
\member{frame} subwidget.
\end{classdesc}

% Python Demo of:
% \ulink{LabelFrame}{http://tix.sourceforge.net/dist/current/demos/samples/LabFrame.tcl}

\begin{classdesc}{Meter}{}
The \ulink{Meter}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixMeter.htm}
widget can be used to show the progress of a background job which may
take a long time to execute.
\end{classdesc}

% Python Demo of:
% \ulink{Meter}{http://tix.sourceforge.net/dist/current/demos/samples/Meter.tcl}

\begin{classdesc}{OptionMenu}{}
The \ulink{OptionMenu}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixOptionMenu.htm}
creates a menu button of options.
\end{classdesc}

% Python Demo of:
% \ulink{OptionMenu}{http://tix.sourceforge.net/dist/current/demos/samples/OptMenu.tcl}

\begin{classdesc}{PopupMenu}{}
The \ulink{PopupMenu}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixPopupMenu.htm}
widget can be used as a replacement of the \code{tk_popup}
command. The advantage of the \refmodule{Tix} \class{PopupMenu} widget
is it requires less application code to manipulate.
\end{classdesc}

% Python Demo of:
% \ulink{PopupMenu}{http://tix.sourceforge.net/dist/current/demos/samples/PopMenu.tcl}

\begin{classdesc}{Select}{}
The \ulink{Select}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixSelect.htm}
widget is a container of button subwidgets. It can be used to provide
radio-box or check-box style of selection options for the user.
\end{classdesc}

% Python Demo of:
% \ulink{Select}{http://tix.sourceforge.net/dist/current/demos/samples/Select.tcl}

\begin{classdesc}{StdButtonBox}{}
The \ulink{StdButtonBox}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixStdButtonBox.htm}
widget is a group of standard buttons for Motif-like dialog boxes.
\end{classdesc}

% Python Demo of:
% \ulink{StdButtonBox}{http://tix.sourceforge.net/dist/current/demos/samples/StdBBox.tcl}


\subsubsection{File Selectors}

\begin{classdesc}{DirList}{}
The \ulink{DirList}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixDirList.htm} widget
displays a list view of a directory, its previous directories and its
sub-directories. The user can choose one of the directories displayed
in the list or change to another directory.
\end{classdesc}

% Python Demo of:
% \ulink{DirList}{http://tix.sourceforge.net/dist/current/demos/samples/DirList.tcl}

\begin{classdesc}{DirTree}{}
The \ulink{DirTree}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixDirTree.htm}
widget displays a tree view of a directory, its previous directories
and its sub-directories. The user can choose one of the directories
displayed in the list or change to another directory.
\end{classdesc}

% Python Demo of:
% \ulink{DirTree}{http://tix.sourceforge.net/dist/current/demos/samples/DirTree.tcl}

\begin{classdesc}{DirSelectDialog}{}
The \ulink{DirSelectDialog}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixDirSelectDialog.htm}
widget presents the directories in the file system in a dialog
window.  The user can use this dialog window to navigate through the
file system to select the desired directory.
\end{classdesc}

% Python Demo of:
% \ulink{DirSelectDialog}{http://tix.sourceforge.net/dist/current/demos/samples/DirDlg.tcl}

\begin{classdesc}{DirSelectBox}{}
The \class{DirSelectBox} is similar
to the standard Motif(TM) directory-selection box. It is generally used for
the user to choose a directory. DirSelectBox stores the directories mostly
recently selected into a ComboBox widget so that they can be quickly
selected again.
\end{classdesc}

\begin{classdesc}{ExFileSelectBox}{}
The \ulink{ExFileSelectBox}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixExFileSelectBox.htm}
widget is usually embedded in a tixExFileSelectDialog widget. It
provides an convenient method for the user to select files. The style
of the \class{ExFileSelectBox} widget is very similar to the standard
file dialog on MS Windows 3.1.
\end{classdesc}

% Python Demo of:
%\ulink{ExFileSelectDialog}{http://tix.sourceforge.net/dist/current/demos/samples/EFileDlg.tcl}

\begin{classdesc}{FileSelectBox}{}
The \ulink{FileSelectBox}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixFileSelectBox.htm}
is similar to the standard Motif(TM) file-selection box. It is
generally used for the user to choose a file. FileSelectBox stores the
files mostly recently selected into a \class{ComboBox} widget so that
they can be quickly selected again.
\end{classdesc}

% Python Demo of:
% \ulink{FileSelectDialog}{http://tix.sourceforge.net/dist/current/demos/samples/FileDlg.tcl}

\begin{classdesc}{FileEntry}{}
The \ulink{FileEntry}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixFileEntry.htm}
widget can be used to input a filename. The user can type in the
filename manually. Alternatively, the user can press the button widget
that sits next to the entry, which will bring up a file selection
dialog.
\end{classdesc}

% Python Demo of:
% \ulink{FileEntry}{http://tix.sourceforge.net/dist/current/demos/samples/FileEnt.tcl}


\subsubsection{Hierachical ListBox}

\begin{classdesc}{HList}{}
The \ulink{HList}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixHList.htm}
widget can be used to display any data that have a hierarchical
structure, for example, file system directory trees. The list entries
are indented and connected by branch lines according to their places
in the hierachy.
\end{classdesc}

% Python Demo of:
% \ulink{HList}{http://tix.sourceforge.net/dist/current/demos/samples/HList1.tcl}

\begin{classdesc}{CheckList}{}
The \ulink{CheckList}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixCheckList.htm}
widget displays a list of items to be selected by the user. CheckList
acts similarly to the Tk checkbutton or radiobutton widgets, except it
is capable of handling many more items than checkbuttons or
radiobuttons.
\end{classdesc}

% Python Demo of:
% \ulink{ CheckList}{http://tix.sourceforge.net/dist/current/demos/samples/ChkList.tcl}
% Python Demo of:
% \ulink{ScrolledHList (1)}{http://tix.sourceforge.net/dist/current/demos/samples/SHList.tcl}
% Python Demo of:
% \ulink{ScrolledHList (2)}{http://tix.sourceforge.net/dist/current/demos/samples/SHList2.tcl}

\begin{classdesc}{Tree}{}
The \ulink{Tree}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixTree.htm}
widget can be used to display hierachical data in a tree form. The
user can adjust the view of the tree by opening or closing parts of
the tree.
\end{classdesc}

% Python Demo of:
% \ulink{Tree}{http://tix.sourceforge.net/dist/current/demos/samples/Tree.tcl}

% Python Demo of:
% \ulink{Tree (Dynamic)}{http://tix.sourceforge.net/dist/current/demos/samples/DynTree.tcl}


\subsubsection{Tabular ListBox}

\begin{classdesc}{TList}{}
The \ulink{TList}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixTList.htm}
widget can be used to display data in a tabular format. The list
entries of a \class{TList} widget are similar to the entries in the Tk
listbox widget.  The main differences are (1) the \class{TList} widget
can display the list entries in a two dimensional format and (2) you
can use graphical images as well as multiple colors and fonts for the
list entries.
\end{classdesc}

% Python Demo of:
% \ulink{ScrolledTList (1)}{http://tix.sourceforge.net/dist/current/demos/samples/STList1.tcl}
% Python Demo of:
% \ulink{ScrolledTList (2)}{http://tix.sourceforge.net/dist/current/demos/samples/STList2.tcl}

% Grid has yet to be added to Python
% \subsubsection{Grid Widget}
% Python Demo of:
% \ulink{Simple Grid}{http://tix.sourceforge.net/dist/current/demos/samples/SGrid0.tcl}
% Python Demo of:
% \ulink{ScrolledGrid}{http://tix.sourceforge.net/dist/current/demos/samples/SGrid1.tcl}
% Python Demo of:
% \ulink{Editable Grid}{http://tix.sourceforge.net/dist/current/demos/samples/EditGrid.tcl}


\subsubsection{Manager Widgets}

\begin{classdesc}{PanedWindow}{}
The \ulink{PanedWindow}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixPanedWindow.htm}
widget allows the user to interactively manipulate the sizes of
several panes.  The panes can be arranged either vertically or
horizontally.  The user changes the sizes of the panes by dragging the
resize handle between two panes.
\end{classdesc}

% Python Demo of:
% \ulink{PanedWindow}{http://tix.sourceforge.net/dist/current/demos/samples/PanedWin.tcl}

\begin{classdesc}{ListNoteBook}{}
The \ulink{ListNoteBook}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixListNoteBook.htm}
widget is very similar to the \class{TixNoteBook} widget: it can be
used to display many windows in a limited space using a notebook
metaphor. The notebook is divided into a stack of pages (windows). At
one time only one of these pages can be shown. The user can navigate
through these pages by choosing the name of the desired page in the
\member{hlist} subwidget.
\end{classdesc}

% Python Demo of:
% \ulink{ListNoteBook}{http://tix.sourceforge.net/dist/current/demos/samples/ListNBK.tcl}

\begin{classdesc}{NoteBook}{}
The \ulink{NoteBook}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixNoteBook.htm}
widget can be used to display many windows in a limited space using a
notebook metaphor. The notebook is divided into a stack of pages. At
one time only one of these pages can be shown. The user can navigate
through these pages by choosing the visual ``tabs'' at the top of the
NoteBook widget.
\end{classdesc}

% Python Demo of:
% \ulink{NoteBook}{http://tix.sourceforge.net/dist/current/demos/samples/NoteBook.tcl}


% \subsubsection{Scrolled Widgets}
% Python Demo of:
% \ulink{ScrolledListBox}{http://tix.sourceforge.net/dist/current/demos/samples/SListBox.tcl}
% Python Demo of:
% \ulink{ScrolledText}{http://tix.sourceforge.net/dist/current/demos/samples/SText.tcl}
% Python Demo of:
% \ulink{ScrolledWindow}{http://tix.sourceforge.net/dist/current/demos/samples/SWindow.tcl}
% Python Demo of:
% \ulink{Canvas Object View}{http://tix.sourceforge.net/dist/current/demos/samples/CObjView.tcl}


\subsubsection{Image Types}

The \refmodule{Tix} module adds:
\begin{itemize}
\item 
\ulink{pixmap}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/pixmap.htm}
capabilities to all \refmodule{Tix} and \refmodule{Tkinter} widgets to
create color images from XPM files.

% Python Demo of: \ulink{XPM Image In Button}{http://tix.sourceforge.net/dist/current/demos/samples/Xpm.tcl}

% Python Demo of: \ulink{XPM Image In Menu}{http://tix.sourceforge.net/dist/current/demos/samples/Xpm1.tcl}

\item
\ulink{Compound}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/compound.html}
image types can be used to create images that consists of multiple
horizontal lines; each line is composed of a series of items (texts,
bitmaps, images or spaces) arranged from left to right. For example, a
compound image can be used to display a bitmap and a text string
simutaneously in a Tk \class{Button} widget.

% Python Demo of:
% \ulink{Compound Image In Buttons}{http://tix.sourceforge.net/dist/current/demos/samples/CmpImg.tcl}

% Python Demo of:
% \ulink{Compound Image In NoteBook}{http://tix.sourceforge.net/dist/current/demos/samples/CmpImg2.tcl}

% Python Demo of:
% \ulink{Compound Image Notebook Color Tabs}{http://tix.sourceforge.net/dist/current/demos/samples/CmpImg4.tcl}

% Python Demo of:
% \ulink{Compound Image Icons}{http://tix.sourceforge.net/dist/current/demos/samples/CmpImg3.tcl}
\end{itemize}


\subsubsection{Miscellaneous Widgets}

\begin{classdesc}{InputOnly}{}
The \ulink{InputOnly}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixInputOnly.htm}
widgets are to accept inputs from the user, which can be done with the
\code{bind} command (\UNIX{} only).
\end{classdesc}

\subsubsection{Form Geometry Manager}

In addition, \refmodule{Tix} augments \refmodule{Tkinter} by providing:

\begin{classdesc}{Form}{}
The \ulink{Form}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tixForm.htm}
geometry manager based on attachment rules for all Tk widgets.
\end{classdesc}


%begin{latexonly}
%\subsection{Tix Class Structure}
%
%\begin{figure}[hbtp]
%\centerline{\epsfig{file=hierarchy.png,width=.9\textwidth}}
%\vspace{.5cm}
%\caption{The Class Hierarchy of Tix Widgets}
%\end{figure}
%end{latexonly}

\subsection{Tix Commands}

\begin{classdesc}{tixCommand}{}
The \ulink{tix commands}
{http://tix.sourceforge.net/dist/current/man/html/TixCmd/tix.htm}
provide access to miscellaneous elements of \refmodule{Tix}'s internal
state and the  \refmodule{Tix} application context.  Most of the information
manipulated by these methods pertains to the application as a whole,
or to a screen or display, rather than to a particular window.

To view the current settings, the common usage is:
\begin{verbatim}
import Tix
root = Tix.Tk()
print root.tix_configure()
\end{verbatim}
\end{classdesc}

\begin{methoddesc}{tix_configure}{\optional{cnf,} **kw}
Query or modify the configuration options of the Tix application
context. If no option is specified, returns a dictionary all of the
available options.  If option is specified with no value, then the
method returns a list describing the one named option (this list will
be identical to the corresponding sublist of the value returned if no
option is specified).  If one or more option-value pairs are
specified, then the method modifies the given option(s) to have the
given value(s); in this case the method returns an empty string.
Option may be any of the configuration options.
\end{methoddesc}

\begin{methoddesc}{tix_cget}{option}
Returns the current value of the configuration option given by
\var{option}. Option may be any of the configuration options.
\end{methoddesc}

\begin{methoddesc}{tix_getbitmap}{name}
Locates a bitmap file of the name \code{name.xpm} or \code{name} in
one of the bitmap directories (see the \method{tix_addbitmapdir()}
method).  By using \method{tix_getbitmap()}, you can avoid hard
coding the pathnames of the bitmap files in your application. When
successful, it returns the complete pathname of the bitmap file,
prefixed with the character \samp{@}.  The returned value can be used to
configure the \code{bitmap} option of the Tk and Tix widgets.
\end{methoddesc}

\begin{methoddesc}{tix_addbitmapdir}{directory}
Tix maintains a list of directories under which the
\method{tix_getimage()} and \method{tix_getbitmap()} methods will
search for image files.  The standard bitmap directory is
\file{\$TIX_LIBRARY/bitmaps}. The \method{tix_addbitmapdir()} method
adds \var{directory} into this list. By using this method, the image
files of an applications can also be located using the
\method{tix_getimage()} or \method{tix_getbitmap()} method.
\end{methoddesc}

\begin{methoddesc}{tix_filedialog}{\optional{dlgclass}}
Returns the file selection dialog that may be shared among different
calls from this application.  This method will create a file selection
dialog widget when it is called the first time. This dialog will be
returned by all subsequent calls to \method{tix_filedialog()}.  An
optional dlgclass parameter can be passed as a string to specified
what type of file selection dialog widget is desired.  Possible
options are \code{tix}, \code{FileSelectDialog} or
\code{tixExFileSelectDialog}.
\end{methoddesc}


\begin{methoddesc}{tix_getimage}{self, name}
Locates an image file of the name \file{name.xpm}, \file{name.xbm} or
\file{name.ppm} in one of the bitmap directories (see the
\method{tix_addbitmapdir()} method above). If more than one file with
the same name (but different extensions) exist, then the image type is
chosen according to the depth of the X display: xbm images are chosen
on monochrome displays and color images are chosen on color
displays. By using \method{tix_getimage()}, you can avoid hard coding
the pathnames of the image files in your application. When successful,
this method returns the name of the newly created image, which can be
used to configure the \code{image} option of the Tk and Tix widgets.
\end{methoddesc}

\begin{methoddesc}{tix_option_get}{name}
Gets the options manitained by the Tix scheme mechanism.
\end{methoddesc}

\begin{methoddesc}{tix_resetoptions}{newScheme, newFontSet\optional{,
                                     newScmPrio}}
Resets the scheme and fontset of the Tix application to
\var{newScheme} and \var{newFontSet}, respectively.  This affects only
those widgets created after this call.  Therefore, it is best to call
the resetoptions method before the creation of any widgets in a Tix
application.

The optional parameter \var{newScmPrio} can be given to reset the
priority level of the Tk options set by the Tix schemes.

Because of the way Tk handles the X option database, after Tix has
been has imported and inited, it is not possible to reset the color
schemes and font sets using the \method{tix_config()} method.
Instead, the \method{tix_resetoptions()} method must be used.
\end{methoddesc}


\input{libturtle}


\section{Idle \label{idle}}

%\declaremodule{standard}{idle}
%\modulesynopsis{A Python Integrated Developement Environment}
\moduleauthor{Guido van Rossum}{guido@Python.org}

Idle is the Python IDE built with the \refmodule{Tkinter} GUI toolkit.  
\index{Idle}
\index{Python Editor}
\index{Integrated Developement Environment}


IDLE has the following features:

\begin{itemize}
\item   coded in 100\% pure Python, using the \refmodule{Tkinter} GUI toolkit

\item   cross-platform: works on Windows and \UNIX{} (on Mac OS, there are
currently problems with Tcl/Tk)

\item   multi-window text editor with multiple undo, Python colorizing
and many other features, e.g. smart indent and call tips

\item   Python shell window (a.k.a. interactive interpreter)

\item   debugger (not complete, but you can set breakpoints, view  and step)
\end{itemize}


\subsection{Menus}

\subsubsection{File menu}

\begin{description}
\item[New window]     create a new editing window
\item[Open...]        open an existing file
\item[Open module...] open an existing module (searches sys.path)
\item[Class browser]  show classes and methods in current file
\item[Path browser]   show sys.path directories, modules, classes and methods
\end{description}
\index{Class browser}
\index{Path browser}

\begin{description}
\item[Save]   save current window to the associated file (unsaved
windows have a * before and after the window title)

\item[Save As...]     save current window to new file, which becomes
the associated file
\item[Save Copy As...]        save current window to different file
without changing the associated file
\end{description}

\begin{description}
\item[Close]  close current window (asks to save if unsaved)
\item[Exit]   close all windows and quit IDLE (asks to save if unsaved)
\end{description}


\subsubsection{Edit menu}

\begin{description}
\item[Undo]   Undo last change to current window (max 1000 changes)
\item[Redo]   Redo last undone change to current window
\end{description}

\begin{description}
\item[Cut]    Copy selection into system-wide clipboard; then delete selection
\item[Copy]   Copy selection into system-wide clipboard
\item[Paste]  Insert system-wide clipboard into window
\item[Select All]     Select the entire contents of the edit buffer
\end{description}

\begin{description}
\item[Find...]        Open a search dialog box with many options
\item[Find again]     Repeat last search
\item[Find selection] Search for the string in the selection
\item[Find in Files...]       Open a search dialog box for searching files
\item[Replace...]     Open a search-and-replace dialog box
\item[Go to line]     Ask for a line number and show that line
\end{description}

\begin{description}
\item[Indent region]  Shift selected lines right 4 spaces
\item[Dedent region]  Shift selected lines left 4 spaces
\item[Comment out region]     Insert \#\# in front of selected lines
\item[Uncomment region]       Remove leading \# or \#\# from selected lines
\item[Tabify region]  Turns \emph{leading} stretches of spaces into tabs
\item[Untabify region]        Turn \emph{all} tabs into the right number of spaces
\item[Expand word]    Expand the word you have typed to match another
                word in the same buffer; repeat to get a different expansion
\item[Format Paragraph]       Reformat the current blank-line-separated paragraph
\end{description}

\begin{description}
\item[Import module]  Import or reload the current module
\item[Run script]     Execute the current file in the __main__ namespace
\end{description}

\index{Import module}
\index{Run script}


\subsubsection{Windows menu}

\begin{description}
\item[Zoom Height]    toggles the window between normal size (24x80)
        and maximum height.
\end{description}

The rest of this menu lists the names of all open windows; select one
to bring it to the foreground (deiconifying it if necessary).


\subsubsection{Debug menu (in the Python Shell window only)}

\begin{description}
\item[Go to file/line]        look around the insert point for a filename
                and linenumber, open the file, and show the line.
\item[Open stack viewer]      show the stack traceback of the last exception
\item[Debugger toggle]        Run commands in the shell under the debugger
\item[JIT Stack viewer toggle]        Open stack viewer on traceback
\end{description}

\index{stack viewer}
\index{debugger}


\subsection{Basic editing and navigation}

\begin{itemize}
\item   \kbd{Backspace} deletes to the left; \kbd{Del} deletes to the right
\item   Arrow keys and \kbd{Page Up}/\kbd{Page Down} to move around
\item   \kbd{Home}/\kbd{End} go to begin/end of line
\item   \kbd{C-Home}/\kbd{C-End} go to begin/end of file
\item   Some \program{Emacs} bindings may also work, including \kbd{C-B},
        \kbd{C-P}, \kbd{C-A}, \kbd{C-E}, \kbd{C-D}, \kbd{C-L}
\end{itemize}


\subsubsection{Automatic indentation}

After a block-opening statement, the next line is indented by 4 spaces
(in the Python Shell window by one tab).  After certain keywords
(break, return etc.) the next line is dedented.  In leading
indentation, \kbd{Backspace} deletes up to 4 spaces if they are there.
\kbd{Tab} inserts 1-4 spaces (in the Python Shell window one tab).
See also the indent/dedent region commands in the edit menu.


\subsubsection{Python Shell window}

\begin{itemize}
\item   \kbd{C-C} interrupts executing command
\item   \kbd{C-D} sends end-of-file; closes window if typed at
a \samp{>>>~} prompt
\end{itemize}

\begin{itemize}
\item   \kbd{Alt-p} retrieves previous command matching what you have typed
\item   \kbd{Alt-n} retrieves next
\item   \kbd{Return} while on any previous command retrieves that command
\item   \kbd{Alt-/} (Expand word) is also useful here
\end{itemize}

\index{indentation}


\subsection{Syntax colors}

The coloring is applied in a background ``thread,'' so you may
occasionally see uncolorized text.  To change the color
scheme, edit the \code{[Colors]} section in \file{config.txt}.

\begin{description}
\item[Python syntax colors:]

\begin{description}
\item[Keywords]       orange
\item[Strings ]       green
\item[Comments]       red
\item[Definitions]    blue
\end{description}

\item[Shell colors:]
\begin{description}
\item[Console output] brown
\item[stdout]         blue
\item[stderr]       dark green
\item[stdin]       black
\end{description}
\end{description}


\subsubsection{Command line usage}

\begin{verbatim}
idle.py [-c command] [-d] [-e] [-s] [-t title] [arg] ...

-c command  run this command
-d          enable debugger
-e          edit mode; arguments are files to be edited
-s          run $IDLESTARTUP or $PYTHONSTARTUP first
-t title    set title of shell window
\end{verbatim}

If there are arguments:

\begin{enumerate}
\item   If \programopt{-e} is used, arguments are files opened for
        editing and \code{sys.argv} reflects the arguments passed to
        IDLE itself.

\item   Otherwise, if \programopt{-c} is used, all arguments are
        placed in \code{sys.argv[1:...]}, with \code{sys.argv[0]} set
        to \code{'-c'}.

\item   Otherwise, if neither \programopt{-e} nor \programopt{-c} is
        used, the first argument is a script which is executed with
        the remaining arguments in \code{sys.argv[1:...]}  and
        \code{sys.argv[0]} set to the script name.  If the script name
        is '-', no script is executed but an interactive Python
        session is started; the arguments are still available in
        \code{sys.argv}.
\end{enumerate}


\section{Other Graphical User Interface Packages
         \label{other-gui-packages}}


There are an number of extension widget sets to \refmodule{Tkinter}.

\begin{seealso*}
\seetitle[http://pmw.sourceforge.net/]{Python megawidgets}{is a
toolkit for building high-level compound widgets in Python using the
\refmodule{Tkinter} module.  It consists of a set of base classes and
a library of flexible and extensible megawidgets built on this
foundation. These megawidgets include notebooks, comboboxes, selection
widgets, paned widgets, scrolled widgets, dialog windows, etc.  Also,
with the Pmw.Blt interface to BLT, the busy, graph, stripchart, tabset
and vector commands are be available.

The initial ideas for Pmw were taken from the Tk \code{itcl}
extensions \code{[incr Tk]} by Michael McLennan and \code{[incr
Widgets]} by Mark Ulferts. Several of the megawidgets are direct
translations from the itcl to Python. It offers most of the range of
widgets that \code{[incr Widgets]} does, and is almost as complete as
Tix, lacking however Tix's fast \class{HList} widget for drawing trees.
}
\seetitle[http://tkinter.effbot.org]{Tkinter3000}{
is a Widget Construction Kit that allows you to write new Tkinter
widgets in Python using Mixins. It is built on top of Tkinter,
and does not offer the extended range of widgets that \refmodule{Tix} does,
but does allow a form of  building mega-widgets. The project is
still in the early stages.
}
\end{seealso*}


Tk is not the only GUI for Python, but is however the
most commonly used one.

\begin{seealso*}
\seetitle[http://www.wxwindows.org]{wxWindows}{
is a GUI toolkit that combines the most attractive attributes of Qt,
Tk, Motif, and GTK+ in one powerful and efficient package. It is
implemented in \Cpp. wxWindows supports two flavors of \UNIX{}
implementation: GTK+ and Motif, and under Windows, it has a standard
Microsoft Foundation Classes (MFC) appearance, because it uses Win32
widgets.  There is a Python class wrapper, independent of Tkinter.

wxWindows is much richer in widgets than \refmodule{Tkinter}, with its
help system, sophisticated HTML and image viewers, and other
specialized widgets, extensive documentation, and printing capabilities.
}
\seetitle[http://www.thekompany.com]{PyKDE}{
PyKDE is a SIP wrapped interface to the Qt toolkit.
The Qt \Cpp{} toolkit lies at the heart of the KDE desktop, and the
Qt toolkit allows very tight integration with KDE, and also Windows
portability. SIP is a tool for generating bindings for \Cpp{} libraries
as Python classes, and is specifically designed for Python.
}
\seetitle[http://fxpy.sourceforge.net/]{FXPy}{
is a Python extension module which provides an interface to the 
\citetitle[http://www.cfdrc.com/FOX/fox.html]{FOX} GUI.
FOX is a \Cpp{} based Toolkit for developing Graphical User Interfaces
easily and effectively. It offers a wide, and growing, collection of
Controls, and provides state of the art facilities such as drag and
drop, selection, as well as OpenGL widgets for 3D graphical
manipulation.  FOX also implements icons, images, and user-convenience
features such as status line help, and tooltips.  

Even though FOX offers a large collection of controls already, FOX
leverages \Cpp{} to allow programmers to easily build additional Controls
and GUI elements, simply by taking existing controls, and creating a
derived class which simply adds or redefines the desired behavior.
}
\seetitle[http://www.daa.com.au/\~james/pygtk/]{PyGTK}{
is a set of bindings for the \ulink{GTK}{http://www.gtk.org/} widget set.
It provides an object oriented interface that is slightly higher
level than the C one. It automatically does all the type casting and
reference counting that you would have to do normally with the C
API. There are also \ulink{bindings}{http://www.daa.com.au/\~james/gnome/}
to  \ulink{GNOME}{http://www.gnome.org}, and a 
\ulink{tutorial}
{http://laguna.fmedic.unam.mx/\~daniel/pygtutorial/pygtutorial/index.html}
is available.
}
\end{seealso*}

% XXX Reference URLs that compare the different UI packages