thinking in tkinter

Subject: "Thinking in Tkinter"

Author : Stephen Ferg

About " Thinking In Tkinter "

I've been trying to teach myself Tkinter out of various books, and I'm finding it more difficult than I

think it should be.

The problem is that the authors of the books want to rush into telling me about all of the widgets in the

Tkinter toolbox, but never really pause to explain basic concepts. They don't explain how to "think in

Tkinter".

Here are a few short programs that begin to explain how to think in Tkinter. In them, I don't attempt to

catalog all of the types of widgets, attributes, and methods that are available in Tkinter. and I certainly

1) You must specify how you want the UI to *look*. That is, you must write code that determines what

the user will see on the computer screen.

2) You must decide what you want the UI to *do*. That is, you must write routines that accomplish the

tasks of the program.

3) You must associate the "looking" with the "doing". That is, you must write code that associates the

things that the user sees on the screen with the routines that you have written to perform the program's

tasks.

4) finally, you must write code that sits and waits for input from the user.

Some Gui-programming Jargon

GUI (graphical user interface) programming has some special jargon associated with these basic tasks.

"Events" are input events such as mouse clicks or presses of a key on the keyboard. These routines are

called "handlers" because they "handle" (that is, respond to) such events.

3) Associating an event handler with a widget is called "binding". Roughly, the process of binding

involves associating three different things:

(a) a type of event (e.g. a click of the left mouse button,

or a press of the ENTER key on the keyboard),

(b) a widget (e.g. a button), and

(c) an event-handler routine.

For example, we might bind (a) a single-click of the left mouse button on (b) the "CLOSE"

button/widget on the screen to (c) the "closeProgram" routine, which closes the window and shuts

-- like a big fight between the newly-wed couple in the house across the street. When interesting events

happen, the watchdog lady immediately is on the phone with the news to the police or to her neighbors.

The event loop is a lot like this watchdog lady. The event loop spends all of its time watching events go

by, and it sees all of them. Most of the events are uninteresting, and when it sees them, it does nothing.

But when it sees something interesting -- an event that it knows is interesting, because an event handler

has been bound to the event -- then it immediately calls up the event handler and lets it know that the

event has happened.

Program Behavior

This program eases you into user-interace programming by showing how these basic concepts are

implemented in a very simple program. This program doesn't use Tkinter or any form of GUI

programming. It just puts up a menu on the console, and gets simple keyboard input. Even so, as you

can see, it does the four basic tasks of user-interface programming.

[revised: 2003-02-23]

Program Source Code

#----- task 2: define the event handler routines ---------------------

def handle_A():

print "Wrong! Try again!"

# ------------ task 1: define the appearance of the screen ------------

print "\n"*100 # clear the screen

print " VERY CHALLENGING GUESSING GAME"

print "========================================================"

print "Press the letter of your answer, then the ENTER key."

print

print " A. Animal"

print " B. Vegetable"

print

# ---- task 4: the event loop. We loop forever, observing events. ---

while 1:

# We observe the next event

answer = raw_input().upper()

# -------------------------------------------------------

# Task 3: Associate interesting keyboard events with their

# clear the screen and exit the event loop

print "\n"*100

break

# Note that any other events are uninteresting, and are ignored

The Simplest Possible Tkinter Program -- Three Statements!

Of the four basic GUI tasks that we discussed in the last program, this program does only one -- it runs

the event loop.

(1) The first statement imports Tkinter, so that it is available for use. Note that the form of the import

(3) The third statement executes the "mainloop" (that is, the event loop) method of the "root" object. As

the mainloop runs, it waits for events to happen in root. If an event occurs, then it is handled and the

loop continues running, waiting for the next evernt. The loop continues to execute until a "destroy"

event happens to the root window. A "destroy" event is one that closes a window. When the root is

destroyed, the window is closed and the event loop is exited.

Program Behavior

When you run this program, you will see that (thanks to Tk) the toplevel window automatically comes

furnished with widgets to minimize, maximize, and close the window. Try them -- you'll see that they

really do work.

Clicking on the "close" widget (the "x" in a box, at the right of the title bar) generates a "destroy" event.

The destroy event terminates the main event loop. And since there are no statements after

"root.mainloop()", the program has nothing more to do, and ends.

[revised: 2003-02-23]

Program Source Code

from Tkinter import * ### (1)

* creating a GUI object and associating it with its parent

* packing

* containers vs. widgets

From now on, I'm going to distinguish between a container component and a widget. As I will be using

the terms, a "widget" is a GUI component that (usually) is visible and does things. A "container" in

contrast is simply a container -- a basket, as it were -- into which we can put widgets.

Tkinter provides a number of containers. "Canvas" is a container for drawing applications. The most

frequently used container is a "frame".

Frames are provided by Tkinter in a class called "Frame". An expression like:

Frame(myParent)