Python Cookbook 2Nd Edition Jun 1002005 [Electronic resources] نسخه متنی

Introduction

Credit: Fredrik Lundh, SecretLabs AB, author of
Python Standard Library

Back in the early days of interactive
computing, most computers offered terminals that looked and behaved
pretty much like clunky typewriters. The main difference from an
ordinary typewriter was that the computer was in the loop. It could
read what the user typed and print hard-copy output on a roll of
paper.

So when you found yourself in front of a 1960s Teletype ASR-33, the
only reasonable way to communicate with the computer was to type a
line of text, press the send key, hope that the computer would manage
to figure out what you meant, and wait for the response to appear on
the paper roll. This line-oriented way of communicating with your
computer is known as a command-line interface
(CLI).

Some 40 years later, the paper roll has been replaced with
high-resolution video displays, which can display text in multiple
typefaces, color photographs, and even animated 3D graphics. The
keyboard is still around, but we also have pointing devices such as
the mouse, trackballs, game controls, touchpads, and other input
devices.

The combination of a graphics display and the mouse made it possible
to create a new kind of user interface: the graphical user
interface (GUI). When done right, a GUI can give the user
a better overview of what a program can do (and what it is doing),
and make it easier to carry out many kinds of tasks.

However, most programming languages, including Python, make it easy
to write programs using teletype-style output and input. In Python,
you use the print statement to print text to the
display and the input and
raw_input functions to read expressions and text
strings from the keyboard.

Creating GUIs takes more work. You
need access to functions to draw text and graphics on the screen,
select typefaces and styles, and read information from the keyboard
and other input devices. You need to write code to interact with
other applications (via a window manager), keep your windows updated
when the user moves them around, and respond to key presses and mouse
actions.

To make this a
bit easier, programmers have developed graphical user
interface toolkits, which provide standard solutions to
these problems. A typical GUI toolkit provides a number of ready-made
GUI building blocks, usually called widgets.
Common standard widgets include text and image labels, buttons, and
text-entry fields. Many toolkits also provide more advanced widgets,
such as Tkinter's Text widget,
which is a rather competent text editor/display component.

All major toolkits are event based, which
means that your program hands control over to the toolkit (usually by
calling a "main loop" function or
method). The toolkit then calls back into your application when
certain events occurfor example, when the user clicks OK in a
dialog or when a window needs to be redrawn. Most toolkits also
provide ways to position widgets on the screen automatically (e.g.,
in tables, rows, or columns) and to modify widget behavior and
appearance.

Tkinter is
the de facto standard toolkit for Python and comes with most Python
distributions. Tkinter provides an object-oriented layer on top of
the Tcl/Tk GUI library and runs on Windows, Unix, and Macintosh
systems. Tkinter is easy to use but provides a relatively small
number of standard widgets. Tkinter extension libraries, such as
Pmw and Tix, supply many
components missing from plain Tkinter, and you can use
Tkinter's advanced Text and
Canvas widgets to create custom widgets. The
Widget Construction Kit, WCK, lets you write all sorts of new widgets
in pure Python: see http://effbot.org/zone/wck.

wxPython (http://www.wxPython.org) is another popular
toolkit; it is based on the wxWidgets C++ library
(http://www.wxWidgets.org).
wxPython is modeled somewhat after the Windows MFC library but is
available for multiple platforms. wxPython provides a rich set of
widgets, and it's relatively easy to create custom
widgets.

PyGTK
(http://www.pygtk.org) is an object-oriented
Python interface to the Gimp toolkit (GTK), used in projects such as
Gnome and the Gimp. PyGTK is a good choice for Linux applications,
especially if you want them to run in the Gnome environment.

PyQt (http://www.riverbankcomputing.co.uk/pyqt/index.php)
is a Python wrapper for TrollTech's
Qt library (http://www.trolltech.com), which is the basis
of the popular KDE environment, as well as the Qtopia environment for
hand-held computers; it also runs on Windows and Mac OS X. Qt and
PyQt require license fees for commercial (software that is not free)
use, but are free (licensed by the GPL) for free software
development. (No GPL-licensed Qt is currently available for Windows,
but one is under developmentsee http://kde-cygwin.sourceforge.net/qt3-win32/.)

You can also use
many other toolkits from Python. Mark Hammond's
Pythonwin gives access to Windows MFC. Greg Ewing is developing a
cross-platform GUI API, known as PyGUI (http://nz.cosc.canterbury.ac.nz/~greg/python_gui/),
developed specifically for Python and taking advantage of
Python's unique strengths. Also available are
interfaces to Motif/X11 and Mac OS X native toolboxes and many other
toolkits. Cameron Laird maintains a list of toolkits at http://starbase.neosoft.com/~claird/comp.lang.python/python_GUIl.
It currently lists about 20 toolkits. A Wiki page at http://www.python.org/cgi-bin/moinmoin/GuiProgramming
is actively maintained lists even more.

Finally, several projects, in various stages, are based on the idea
of overlaying easy unified APIs on top of one or more other toolkits
or graphical facilities. anygui (rather
dormantsee http://www.anygui.org),
PythonCard (pretty activesee http://pythoncard.sourceforge.net/),
Wax (http://zephyrfalcon.org/labs/dope_on_waxl),
and PyUI (http://pyui.sourceforge.net/) are examples of
this "higher-level" approach.