6. Event-Driven Programming

The code in Example 6.1 opens a window as pictured in Fig. 6.1. The call to the title method sets the title of the window. The call to resizable makes the window a non-resizable window. The Tkinter.mainloop() calls the Tk event dispatch loop to process events from the windowing application. Even with a simple window like this, the call to mainloop is required because there are events that even a simple window must respond to. For example, when a window is moved on the screen it must respond to its redraw event. Redrawing the window is done automatically by the Tk code once the mainloop function is called.

A menu can be added to the application by creating a Menu widget and adding it to the root window. On Windows and Linux the menu will appear right at the top of the window. On a Mac, the menu appears at the top of the screen on the menu bar. This menu contains a File-> Exit menu item that quits the application when selected.

When adding a menu, you associate a command (i.e. a function) with each menu item added to the menu. The Exit menu item is associated with the quit function which calls the root’s destroy method. Notice the quit function has no parameters. Most event handlers do not have parameters but do have access to the enclosing scope.

A Frame is an invisible widget that can be used as a container for other widgets. Frames are sometimes useful in laying out a GUI application. Layout refers to getting all the widgets in the right place and making them stay there even when the window is resized. We don’t have to worry about resizing the window in the Reminder! application so layout will be a little easier.

In Fig. 6.2 there is a Frame widget. The frame is invisible. The text entry area is inside the frame and so is the New Reminder! button. Frames can be useful to group widgets together. They can also have a border around them. The border around this frame is 5 pixels wide. Adding the frame with a border gives a little edge to the window.

When the frame is created the first parameter to the Frame constructor is the window that the frame is to be packed into. This is true of every widget. The first parameter to the constructor when creating a widget is the widget it belongs to. In this way, widgets can be nested inside of widgets to form the GUI application. So, the mainFrame frame is a part of the root window. Recall that in Example 6.1 the variable root was set to the root Tk window.

Packing the mainFrame means to add it into the root window and make the contents of the frame visible. While a frame itself is invisible, by packing it the contents of the frame will be visible once the window is drawn. Packing is one method of making a widget visible. Other methods of making widgets visible are discussed in Sect. 6.9.

The Button widget is used to get button press input from a user. Buttons appear in the native button format of the operating system you are using so they may not look exactly like the button displayed in Fig. 6.2. Since a button must respond to being pressed, when you create a button you specify an event handler to handle the button presses. An event handler is added to the button in the same way a command was added to a menu item in Sect. 6.2.

Example 6.5 shows a button being created, being added to the main frame, and then being packed within the frame. The keyword argument text specifies the text to go on the button. The keyword command is used to specify a parameterless function to call when the button is pressed. The function post is a parameterless function and is defined in the same scope as the Button. Normally, a function is not defined within the scope of another function. However, in Tk programming it is much more common. Event handlers are almost always nested functions. By nesting the event handler in the main function, it has access to all the variables defined in the main function. In this example the post function needs to have access to the root variable as well as the notes and reminders variables. By defining post within the same scope as the root variable, the post function can use these values as needed. Since the function post cannot have any parameters as dictated by Tkinter API, the post function must access the root variable from the enclosing scope. To see the whole program in context refer to Chap. 15.

The post function gets the contents of the text field, called note, by using the get method on the note. Calling the get method with “1.0” and tkinter.END gets the text from beginning to end. The winfo_rootx() and winfo_rooty() methods get the x and y coordinates for the upper left corner of the root window. The post function then passes that information along with a couple of lists called notes and reminders to the addReminder function. The addReminder function adds a new reminder note to the screen as appears in Fig. 6.3.

Notice that when a command like post is provided to a button it is not written post(). This is because we are not calling post when the button is created. Instead, we are specifying that when the button is pressed the post function should be called. By providing the function name post to the button widget it can remember to call that function when it is pressed.

To create a Reminder! window another top level window is created. To do this, the button calls the addReminder function. There are two parts to a reminder, the window itself and the Text widget within the window. A list of reminder windows is maintained in a list called notes. A list of the text widgets is maintained in a list called reminders. These lists are parallel lists. This means that the first entry in both lists corresponds to the first reminder, the second element in both lists is the second reminder and so on. Parallel lists were first introduced in Sect. 4.​9 on p. 103. Both the window and the Text widget are needed to maintain the information about a reminder in the program.

To add a reminder to the screen a toplevel window is created, the new window is not resizable and is positioned over the top of the existing window using the geometry method. Calling geometry on a window with a string like “+10+10” positions the window at (10,10) pixels measured from the upper left corner of the screen. Since the root window’s coordinates were passed to the function, the new window is positioned approximately on top of the root window.

The text is copied into the reminder. Then the window and the Text widget are copied into the notes and reminders lists, respectively. The last line of the method adds an event handler for the window deletion event. If the reminder window is closed, the user is getting rid of that reminder. In that case, the reminder window and corresponding Text widget are removed from the notes and reminders lists. The remove method looks for a matching element of the list and removes it. The only matching element of a window or Text entry widget is the original window or widget added to the list.

The deleteWindowHandler function is a case where accessing the enclosing scope is exactly what we want. We can’t pass parameters to the deleteWindowHandler function, but we can access the notes, reminders, reminder, and notewin variables from the enclosing scope to remove the window from the program when it is closed.

The code in the try...except block attempts to read the information when the application starts. This code is located in the main function of the application. When the window deletion event occurs for the main window, the appClosing handler is called. The appClosing function writes the file, overwriting any file that was read when the application started. The complete code for the Reminder! application can be found in Chap. 15.

Assume we wish to enhance the Reminder! application by allowing the user to set the title of each reminder. Instead of the reminder note just having Reminder! as its title, it could have a user-defined title. So when the New Reminder! button was pressed for the application in Fig. 6.4 a new window would appear with “Don’t forget trash!” as its title. This can be done by adding a label and an entry widget to the application.

The Label widget is the text “Title:” that appears in the figure. The Entry widget is the one line text field. While a Text widget can handle multiple lines, an Entry widget holds just one line of text.

A new frame is created because it will need to contain the two elements on one line in the application. Without a new frame, the “Title:” label would be packed above the Entry widget. Within the titleFrame frame, the titleLabel and titleText widgets are added using the grid layout instead of the pack layout. In a grid layout you specify which row and column of the grid the widget should be placed in. The columnspan argument specifies that the titleText widget should span 2 of the three columns of the row.

A StringVar is an object with a get and a set method. The titleText Entry widget is created specifying a textvariable called noteTitle which is required to be of type StringVar. To retrieve the text of the Entry widget we can write noteTitle.get() and to set the text of the widget we can write noteTitle.set(“Whatever Text We Want”). StringVars make it easy to set and retrieve text from an Entry widget.

There is a little more code to write to complete the extension of this application to include the title information in the reminders and in the text file that stores the reminders. This code is left as an exercise.

When widgets are packed or gridded in an application, their appearance within the application is called their layout. Sometimes, when widgets are placed within an application they appear in the right place when the application starts, but if the window is resized, they don’t look right. Understanding something about layout management can help you correctly plan your application’s layout and avoid these kinds of problems.

Packing widgets places them one above another in what is sometimes called a flow layout. Each widget appears above the next when packed. The Tk packer is responsible for packer layout management. There are some options that can affect how packing is done. Normally the packer places one widget above another in a flow layout. But these options let the programmer have some control about how that flow is managed.

The Tk gridder is responsible for grid layout management. Grid layout allows widgets to be placed in a specific column and/or row of a container widget. As we have seen, it is possible for one widget to span more than one column or row in a grid. The rowspan parameter sets the number of rows a widget should span. The columnspan option was used in Example 6.8. It is also possible to tell the gridder how it should use the space within a row and column. Normally a widget is centered within the available space. But, if the widget can use it, the gridder can be told to expand the widget to take up the available space. The sticky option tells the gridder to stick the widget to one or more sides of the available area. The tkinter.E and tkinter.W constants stand for east and west. By adding east and west together in Example 6.8 the entry widget will expand to the full width of its allowable size. In that example it has no affect on the layout, since the window cannot be resized anyway, but nonetheless it demonstrates its use.

While packing and gridding are the two most common forms of layout management, there is also a placer. The placer places widgets explicitly within the X,Y plane of the application. The packer, gridder, and placer are the three layout managers for Tkinter. Each of these layout managers have more options available for layout that are not discussed here but can be found by searching for “tkinter layout management” on the internet.

Here are three examples.

There are other dialogs available including a color chooser and file chooser. There are also several other options that are possible with each of these dialogs. Again, more information can be found online.

These are solutions to the practice problems in this chapter. You should only consult these answers after you have tried each of them for yourself first. Practice problems are meant to help reinforce the material you have just read so make use of them.