Programming Python (57 page)

Example 8-6. PP4E\Gui\Tour\dlg1.pyw

from tkinter import *
from tkinter.messagebox import *
def callback():
if askyesno('Verify', 'Do you really want to quit?'):
showwarning('Yes', 'Quit not yet implemented')
else:
showinfo('No', 'Quit has been cancelled')
errmsg = 'Sorry, no Spam allowed!'
Button(text='Quit', command=callback).pack(fill=X)
Button(text='Spam', command=(lambda: showerror('Spam', errmsg))).pack(fill=X)
mainloop()

Figure 8-7. dlg1 showwarning dialog

Let’s put some of
these canned dialogs to better use.
Example 8-7
implements an
attachable Quit button that uses standard dialogs to verify the quit
request. Because it’s a class, it can be attached and reused in any
application that needs a verifying Quit button. Because it uses
standard dialogs, it looks as it should on each GUI platform.

"""
a Quit button that verifies exit requests;
to reuse, attach an instance to other GUIs, and re-pack as desired
"""
from tkinter import *                          # get widget classes
from tkinter.messagebox import askokcancel     # get canned std dialog
class Quitter(Frame):                          # subclass our GUI
def __init__(self, parent=None):           # constructor method
Frame.__init__(self, parent)
self.pack()
widget = Button(self, text='Quit', command=self.quit)
widget.pack(side=LEFT, expand=YES, fill=BOTH)
def quit(self):
ans = askokcancel('Verify exit', "Really quit?")
if ans: Frame.quit(self)
if __name__ == '__main__':  Quitter().mainloop()

This module is mostly meant to be used elsewhere, but it puts up
the button it implements when run standalone.
Figure 8-10
shows the Quit
button itself in the upper left, and the
askokcancel
verification dialog that pops up
when Quit is pressed.

Figure 8-10. Quitter, with askokcancel dialog

If you press OK here,
Quitter
runs the
Frame
quit method to end
the GUI to which this button is attached (really, the
mainloop
call). But to really understand how
such a spring-loaded button can be useful, we need to move on and
study a client GUI in the next section.

So far, we’ve seen a
handful of standard dialogs, but there are quite a few
more. Instead of just throwing these up in dull screenshots, though,
let’s write a Python demo script to generate them on demand. Here’s
one way to do it. First of all, in
Example 8-8
we write a module
to define a table that maps a demo name to a standard dialog call (and
we use lambda to wrap the call if we need to pass extra arguments to
the dialog
function
).

# define a name:callback demos table
from tkinter.filedialog   import askopenfilename        # get standard dialogs
from tkinter.colorchooser import askcolor               # they live in Lib\tkinter
from tkinter.messagebox   import askquestion, showerror
from tkinter.simpledialog import askfloat
demos = {
'Open':  askopenfilename,
'Color': askcolor,
'Query': lambda: askquestion('Warning', 'You typed "rm *"\nConfirm?'),
'Error': lambda: showerror('Error!', "He's dead, Jim"),
'Input': lambda: askfloat('Entry', 'Enter credit card number')
}

I put this table in a module so that it might be reused as the
basis of other demo scripts later (dialogs are more fun than printing
to
stdout
). Next, we’ll write a
Python script, shown in
Example 8-9
, which simply
generates buttons for all of this table’s entries—use its keys as
button labels and its values as button callback handlers.

"create a bar of simple buttons that launch dialog demos"
from tkinter import *              # get base widget set
from dialogTable import demos      # button callback handlers
from quitter import Quitter        # attach a quit object to me
class Demo(Frame):
def __init__(self, parent=None, **options):
Frame.__init__(self, parent, **options)
self.pack()
Label(self, text="Basic demos").pack()
for (key, value) in demos.items():
Button(self, text=key, command=value).pack(side=TOP, fill=BOTH)
Quitter(self).pack(side=TOP, fill=BOTH)
if __name__ == '__main__': Demo().mainloop()

This script creates the window shown in
Figure 8-11
when run as a standalone program;
it’s a bar of demo buttons that simply route control back to the
values of the table in the module
dialogTable
when pressed.

Figure 8-11. demoDlg main window

Notice that because this script is driven by the contents of
the
dialogTable
module’s
dictionary, we can change the set of demo buttons displayed by
changing just
dialog
Table
(we don’t need to change any
executable code in
demoDlg
). Also
note that the Quit button here is an attached instance of the
Quitter
class of the prior section whose
frame is repacked to stretch like the other buttons as needed
here—it’s at least one bit of code that you never have to write
again.

This script’s class also takes care to pass any
**options
constructor configuration keyword
arguments on to its
Frame
superclass. Though not used here, this allows callers to pass in
configuration options at creation time (
Demo(o=v)
), instead of configuring after the
fact (
d.config(o=v)
). This isn’t
strictly required, but it makes the demo class work just like a normal
tkinter frame widget (which is what subclassing makes it, after all).
We’ll see how this can be used to good effect later.

We’ve already seen some of the dialogs triggered by this demo
bar window’s other buttons, so I’ll just step through the new ones
here. Pressing the main window’s Query button, for example, generates
the standard pop up in
Figure 8-12
.

Figure 8-12. demoDlg query, askquestion dialog

This
askquestion
dialog looks
like the
askyesno
we saw earlier,
but actually it returns either string
"yes"
or
"no"
(
askyesno
and
askokcancel
return
True
or
False
instead—trivial but true). Pressing
the demo bar’s Input button generates the standard
askfloat
dialog box shown in
Figure 8-13
.

Figure 8-13. demoDlg input, askfloat dialog

This dialog automatically checks the input for valid
floating-point syntax before it returns, and it is representative of a
collection of single-value input dialogs (
askinteger
and
askstring
prompt for integer and string
inputs, too). It returns the input as a
floating
-
point
number object (not as a string)
when the OK button or Enter key is pressed, or the Python
None
object if the user clicks Cancel. Its
two relatives return the input as integer and string objects
instead.

When the demo bar’s Open button is pressed, we get the standard
file open dialog made by calling
askopenfilename
and captured in
Figure 8-14
. This is Windows
7’s look-and-feel; it can look radically different on Macs, Linux, and
older versions of Windows, but appropriately so.

Figure 8-14. demoDlg open, askopenfilename dialog

A similar dialog for selecting a save-as filename is produced by
calling
asksaveasfilename
(see the
Text
widget section in
Chapter 9
for a first example). Both
file dialogs let the user navigate through the filesystem to select a
subject filename, which is returned with its full directory pathname
when Open is pressed; an empty string comes back if Cancel is pressed
instead. Both also have additional protocols not demonstrated by this
example:

Another common dialog call in the tkinter
filedialog
module,
askdirectory
, can be used to pop up a dialog
that allows users to choose a directory rather than a file. It
presents a tree view that users can navigate to pick the desired
directory, and it accepts keyword arguments including
initialdir
and
title
. The corresponding
Directory
object remembers the last
directory selected and starts there the next time the dialog is
shown.

We’ll use most of these interfaces later in the book, especially
for the file dialogs in the PyEdit example in
Chapter 11
, but feel free to flip ahead for
more details now. The directory selection dialog will show up in the
PyPhoto example in
Chapter 11
and the
PyMailGUI example in
Chapter 14
; again,
skip ahead for code and screenshots.

Finally, the demo bar’s Color button triggers a standard
askcolor
call, which generates the
standard color selection dialog shown in
Figure 8-15
.

Figure 8-15. demoDlg color, askcolor dialog

If you press its OK button, it returns a data structure that
identifies the selected color, which can be used in all color contexts
in tkinter. It includes RGB values and a hexadecimal color string
(e.g.,
((160, 160, 160),
'#a0a0a0')
). More on how this tuple can be useful in a
moment. If you press Cancel, the script gets back a tuple containing
two nones (
None
s of the Python
variety,
that is).