You may or may not have noticed a few things about the window you created. For starters, it had a built-in minimize and maximize button, along with an "X" button to close the window. In addition, the user could stretch out the window. Go ahead and grab the right side of the window and pull it to the right a few inches. You will note that the label stays in the center near the top. This is a good thing.

Now, grab the bottom of the window and stretch it out. See the problem? No matter how far down you stretch the window, the label stays at the top. Ideally, when the user changes the size or shape of a window, you want the widget(s) inside to behave appropriately. With this in mind, modify your code so that the label centers when the window is resized:

import tkinter
from tkinter import *
Label(text='My first GUI!').pack(expand=YES, fill=BOTH)
mainloop( )

When you run this program, try resizing the window; you'll see the "My first GUI!" label stay centered no matter what the window looks like, as shown in Figure 13-2.

Figure 13.2. Figure 13-2

You've seen one method to assign not only text to your label, but also how to configure some of the widget's options, such as expand and fill. Though the method you used was convenient in this instance, you may find yourself wanting to create your widgets first, and then configuring their options later on.

import tkinter
from tkinter import *
root = Tk( )

widget = Label(root)
widget.config(text='My first GUI!')
widget.pack(side=TOP, expand=YES, fill=BOTH)
root.mainloop()

So far you've seen how to make a basic label, and how to format your widgets. But for a program to be successful, it not only has to look good; it has to actually do something. The next few examples not only teach you how to add more than one widget to your GUI, but teach you to apply actions to those widgets. Even more importantly, you learn to make the program respond to the user's actions.

You have learned how to create one type of widget so far — the label. In this example, you learn to create a button. Try typing the following code into a file called MyFirstButton.py:

import sys
from tkinter import *
widget = Button(None, text='Click Me', command=sys.exit)
widget.pack( )
widget.mainloop( )

This code is short and sweet and you may have noticed it looks very similar to the previous code. However, you will want to note that in addition to changing the widget type, you also added a new option, command. The value you added to command — sys.exit — tells Python to literally exit the system when the user clicks the button widget.

But what if you want to offer the user some option other than simply exiting the program? To do that, you have to add a second widget to your window. Create a new file and call it MultipleWidget.py:

from tkinter import *

def result( ):
    print('The sum of 2+2 is ',2+2)

win = Frame()
win.pack( )
Label(win,  text='Click Add to get the sum or Quit to Exit').pack(side=TOP)
Button(win, text='Add', command=result).pack(side=LEFT)
Button(win, text='Quit', command=win.quit).pack(side=RIGHT)

win.mainloop( )

This code introduces several new concepts we have yet to cover. First, you create a user-defined function, result(), and assign it the task of printing some text and returning the sum of 2+2. Next, you create three widgets. The first, a Label, holds some text, and has been giving the side=TOP option. Next, you create a button to call your user-defined function, which you place on the left side of the window. Lastly, you create a right-sided button and assign win.quit to command.

If the user clicks the Add button, it prints the text, "The sum of 2+2 is 4" to stdout. If the user clicks the Quit button, it closes the window.

One other thing to notice here is that for the first time we have introduced the use of the frame widget.

When creating a GUI, it is important to consider the hierarchy of your widgets. This hierarchy is commonly referred to as parent-child. In the preceding example, you created a number of widgets. The first widget is the top-level window, which acts as a parent. Next, you have a widget called win, which has a child of its own — a frame widget. The win widget, at this point, is a child of the top-level window.

Next, you have a label and two buttons, all of which are children of your frame widget. A frame widget is a widget whose purpose is to hold other widgets, and thus allow the programmer the flexibility to create a layout determining where on the window each widget should appear. As you get further into GUI programming, you will work with many different frame widgets, each occupying a specific spot on the top-level window, with each frame having its on set of widgets. These widgets that belong to each frame, being children of their respective frame, will be limited to the space provided them by their parent frame.

For example, if you have two frames of the same size, each taking up half of the window, and assign a button widget to each frame, the button assigned to the left frame will only be able to be placed within the left-hand side of the window. Likewise, the button assigned to the frame on the right side will be constrained to that section. If you were to pack the button in the left frame to the right, it would appear to the user to be in the center of the top-level window.

Another important aspect of layout is known as packing order. When you create each widget, and pack them, they are given all of the space for their region. For instance, if you pack a button on the LEFT, it will occupy all of the left-hand space. When you create a second widget and pack it to the left as well, the initial button is shrunk, but still holds the left-most space. This process continues, with each button shrinking to provide room for the other widgets. However, the buttons never move from their original space. The first button packed to the left will always be the left-most; likewise, the second button packed to the left will always be the second closest to the left.

Though this may sound confusing, simply rearranging your previous code should shed some light on the matter:

from tkinter import *

def result( ):
    print('The sum of 2+2 is ',2+2)

win = Frame()
win.pack( )
Button(win, text='Add', command=result).pack(side=LEFT)
Label(win,  text='Click Add to get the sum or Quit to Exit').pack(side=TOP)
Button(win, text='Quit', command=win.quit).pack(side=RIGHT)

win.mainloop( )

Figure 13-3 shows how the program originally looked, before you modified your code.

Figure 13.3. Figure 13-3

And Figure 13-4 is how it looks with the modified code.

Figure 13.4. Figure 13-4

Form and function are key to creating a well-rounded GUI. Thus far, you have learned to add some code to your interfaces, and learned the basics of layout (there is much more to learn, but it is beyond the scope of this chapter). In this section, you take your program one step further and learn to control the actual appearance of your widgets.

import tkinter
from tkinter import *
root = Tk( )
labelfont = ('times', 24, 'italic')        # setting the family, size, and
                                            style
widget = Label(root, text='Eat At JOES')   # setting label text
widget.config(bg='black', fg='red')        # setting the back and foreground
                                            colors
widget.pack(expand=YES, fill=BOTH)
root.mainloop( )

The following table is a list of the different ways that you can customize a widget:

So far you have worked with the following widgets: the top-level window, frames, labels, and buttons. These are all powerful widgets, but sometimes you may want to give your users more options. That is where radio buttons and checkboxes come into play.

Aside from appearance, radio buttons and checkboxes differ in one significant way: radio buttons offer users a list of options, but allow them to select only one; checkboxes offer users many options, and lets them choose as many as they want.

import tkinter
from tkinter import *
state = ''
buttons = []

def choose(i):
    global state
    state = i
    for btn in buttons:
        btn.deselect( )
    buttons[i].select( )

root = Tk( )
for i in range(4):
    radio = Radiobutton(root, text=str(i),
                            value=str(i), command=(lambda i=i: choose(i)) )
    radio.pack(side=BOTTOM)
    buttons.append(radio)
root.mainloop( )
print("You chose the following number: ",state)

You can do something similar with checkboxes. In this instance however, you simply return whether the value of each checkbox is true or false:

from tkinter import *
states = []
def check(i):
    states[i] = not states[i]

root = Tk( )

for i in range(4):
    test = Checkbutton(root, text=str(i), command=(lambda i=i: check(i)) )
    test.pack(side=TOP)
    states.append(0)
root.mainloop( )
print(states)

If you run this program and check off boxes 2 and 3, then close the window, your result should be:

>>>
[0, True, True, 0]

Sometimes you want to give the user a piece of additional information. You are no doubt familiar with dialog boxes. They pop up anytime there is an error, or a program wants to confirm something, such as if you really want to uninstall a program, or if you want to display sensitive information.

Tkinter offers up two types of dialog boxes — modal and nonmodal. Modal dialog boxes wait for some action from the user before going away, and pause the progress of the program. Nonmodal dialog boxes do not interrupt the flow of the program.

import sys
from tkinter import *
popupper = (len(sys.argv) > 1)

def dialog( ):
    win = Toplevel( )
    Label(win, text='Do You Always Do What You Are Told?').pack( )
    Button(win, text='Now click this one', command=win.destroy).pack( )
    if popupper:
        win.focus_set( )
        win.grab_set( )
        win.wait_window( )
    print('You better obey me...')

root = Tk( )
Button(root, text='Click Me', command=dialog).pack( )
root.mainloop( )

This is just the tip of the iceberg when it comes to creating dialog boxes. Aside from warnings, error messages, and confirmations, dialog boxes can also be used to load files (think about using the open command in most applications), pick a color from a color wheel, and much, much more.

This chapter has covered many of the widget types so far, but many are still left to explore. A full guide to these is beyond the scope of this chapter, and indeed, this book, but at the very least you should be aware of their existence. The following table lists the different widget classes available to you, and offers an explanation of each one.