Programming Python (60 page)

Example 8-16. PP4E\Gui\tour\message.py

from tkinter import *
msg = Message(text="Oh by the way, which one's Pink?")
msg.config(bg='pink', font=('times', 16, 'italic'))
msg.pack(fill=X, expand=YES)
mainloop()

Example 8-17. PP4E\Gui\tour\entry1.py

from tkinter import *
from quitter import Quitter
def fetch():
print('Input => "%s"' % ent.get())             # get text
root = Tk()
ent = Entry(root)
ent.insert(0, 'Type words here')                   # set text
ent.pack(side=TOP, fill=X)                         # grow horiz
ent.focus()                                        # save a click
ent.bind('', (lambda event: fetch()))      # on enter key
btn = Button(root, text='Fetch', command=fetch)    # and on button
btn.pack(side=LEFT)
Quitter(root).pack(side=RIGHT)
root.mainloop()

Generally speaking, the
values typed into and displayed by
Entry
widgets are set and fetched with
either tied “variable” objects (described later in this chapter) or
Entry
widget method calls such as
this one:

ent.insert(0, 'some text')          # set value
value = ent.get()                   # fetch value (a string)

The first parameter to the
insert
method gives the position where the
text is to be inserted. Here, “0” means the front because offsets
start at zero, and integer
0
and
string
'0'
mean the same thing
(tkinter method arguments are always converted to strings if needed).
If the
Entry
widget might already
contain text, you also generally need to delete its contents before
setting it to a new value, or else new text will simply be added to
the text already present:

ent.delete(0, END)                  # first, delete from start to end
ent.insert(0, 'some text')          # then set value

The name
END
here is a
preassigned tkinter constant denoting the end of the widget; we’ll
revisit it in
Chapter 9
when we
meet the full-blown and multiple-line
Text
widget (
Entry
’s more powerful cousin). Since the
widget is empty after the deletion, this statement sequence is
equivalent to the prior one:

ent.delete('0', END)                # delete from start to end
ent.insert(END, 'some text')        # add at end of empty text

Either way, if you don’t delete the text first, new text that is
inserted is simply added. If you want to see how, try changing the
fetch
function in
Example 8-17
to look like
this—an “x” is added at the beginning and end of the input field on
each button or key press:

def fetch():
print('Input => "%s"' % ent.get())        # get text
ent.insert(END, 'x')                      # to clear: ent.delete('0', END)
ent.insert(0, 'x')                        # new text simply added

In later examples, we’ll also see the
Entry
widget’s
state='disabled'
option, which makes it read
only, as well as its
show='*'
option, which makes it display each character as a
*
(useful for password-type inputs). Try
this out on your own by changing and running this script for a quick
look.
Entry
supports other options
we’ll skip here, too; see later examples and other resources for
additional
details.

Example 8-18. PP4E\Gui\Tour\entry2.py

"""
use Entry widgets directly
lay out by rows with fixed-width labels: this and grid are best for forms
"""
from tkinter import *
from quitter import Quitter
fields = 'Name', 'Job', 'Pay'
def fetch(entries):
for entry in entries:
print('Input => "%s"' % entry.get())        # get text
def makeform(root, fields):
entries = []
for field in fields:
row = Frame(root)                           # make a new row
lab = Label(row, width=5, text=field)       # add label, entry
ent = Entry(row)
row.pack(side=TOP, fill=X)                  # pack row on top
lab.pack(side=LEFT)
ent.pack(side=RIGHT, expand=YES, fill=X)    # grow horizontal
entries.append(ent)
return entries
if __name__ == '__main__':
root = Tk()
ents = makeform(root, fields)
root.bind('', (lambda event: fetch(ents)))
Button(root, text='Fetch',
command= (lambda: fetch(ents))).pack(side=LEFT)
Quitter(root).pack(side=RIGHT)
root.mainloop()

Figure 8-24. entry2 (and entry3) expansion at work

Later on this tour, we’ll see how to make similar form layouts
with the
grid
geometry
manager, where we arrange by row and column numbers instead of frames.
But now that we have a handle on form layout, let’s see how to apply
the modal dialog techniques we met earlier to a more complex input
display.

Example 8-19
uses
the prior example’s
makeform
and
fetch
functions to generate a form
and prints its contents, much as before. Here, though, the input
fields are attached to a new
Toplevel
pop-up window created on demand,
and an OK button is added to the new window to trigger a window
destroy event that erases the pop up. As we learned earlier, the
wait_window
call pauses until the
destroy happens.

# make form dialog modal; must fetch before destroy with entries
from tkinter import *
from entry2 import makeform, fetch, fields
def show(entries, popup):
fetch(entries)                  # must fetch before window destroyed!
popup.destroy()                 # fails with msgs if stmt order is reversed
def ask():
popup = Toplevel()              # show form in modal dialog window
ents = makeform(popup, fields)
Button(popup, text='OK', command=(lambda: show(ents, popup))).pack()
popup.grab_set()
popup.focus_set()
popup.wait_window()             # wait for destroy here
root = Tk()
Button(root, text='Dialog', command=ask).pack()
root.mainloop()

When you run this code, pressing the button in this program’s
main window creates the blocking form input dialog in
Figure 8-25
, as
expected.

Figure 8-25. entry2-modal (and entry3-modal) displays

But a subtle danger is lurking in this modal dialog code:
because it fetches user inputs from
Entry
widgets embedded in the popped-up
display, it must fetch those inputs
before
destroying the pop-up window in the OK press callback handler. It
turns out that a
destroy
call
really does destroy all the child widgets of the window destroyed;
trying to fetch values from a destroyed
Entry
not only doesn’t work, but also
generates a traceback with error messages in the console window. Try
reversing the statement order in the
show
function to see for yourself.

To avoid this problem, we can either be careful to fetch before
destroying, or use tkinter variables, the subject of the
next section.