Home > Articles

  • Print
  • + Share This
This chapter is from the book

This chapter is from the book

1.7 Event Bindings

The next example provides a graphical front end for the factorial procedure. In addition to demonstrating two new widget classes, it illustrates Tk's binding mechanism. A binding causes a particular Tcl script to be evaluated whenever a particular event occurs in a particular window. The -command option for buttons is an example of a simple binding implemented by a particular widget class. Tk also includes a more general mechanism that can be used to extend the behavior of widgets in nearly arbitrary ways.

To run the example, copy the following script into a file factorial.tcl and invoke the file from your shell.

    #!/usr/bin/env wish
    proc factorial {val} {
        set result 1
        while {$val>0} {
            set result [expr $result*$val]
            incr val -1
        }
        return $result
    }
    entry .value -width 6 -relief sunken -textvariable value
    label .description -text "factorial is"
    label .result -textvariable result
    button .calculate -text "Calculate"         -command {set result [factorial $value]}
    bind .value <Return> {
        .calculate flash
        .calculate invoke
    }
    grid .value .description .result -padx 1m -pady 1m
    grid .calculate - - -padx 1m -pady 1m

This script produces a screen display like that in Figure 1.2. There is an entry widget in which you can click with the mouse and type a number. If you click the button labeled "Calculate," the result appears on the right side of the window; the same occurs if you press the Return key in the entry.

Figure 1.2

Figure 1.2 A graphical user interface that computes a factorial

This application consists of four widgets: one entry, one button, and two labels. Entries are widgets that display one-line text strings that you can edit interactively. The entry is configured with a -width of 6, which means it is large enough to display about six digits, and a -relief of sunken, which makes the entry appear sunken into the window. The -textvariable option for each entry specifies the name of a global variable to hold the entry's text—any changes you make in the entry are reflected in the variable and vice versa.

The .description label widget holds decorative text, and the .result label holds the result of the power computation. The -textvariable option for .result causes it to display whatever string is in the global variable result and to update itself whenever the variable changes. In contrast, .description displays a constant string.

The first grid command arranges the entry and two label widgets in a row from left to right. The -padx and -pady options make the display a bit more attractive by arranging for 1 millimeter of extra space on the left and right sides of each widget, and 1 millimeter of extra space above and below each widget. The m suffix specifies millimeters; you could also use c for centimeters, i for inches, p for points, or no suffix for pixels.

The second grid command arranges the button in a second row. Because the widget name occurs as the first argument, the gridder allocates the first column of the row to the button. The two - arguments following the widget name indicate to the gridder that the space allocated to the button widget should span two additional columns. The gridder then centers the button widget inside its allocated space.

The command creating the .calculate button occupies two lines in the script; the backslash at the end of the first line is a line-continuation character, which causes the newline to be treated as a space. The button's -command script connects the user interface to the factorial procedure. The script invokes factorial, passing it the values in the entry and storing the result in the result variable so that it is displayed in the .result widget.

The bind command has three arguments: the name of a widget, an event specification, and a Tcl script to invoke when the given event occurs in the given widget. <Return> specifies an event consisting of the user pressing the return key on the keyboard (which is still labeled "Return" on Mac keyboards but typically labeled "Enter" on most other English keyboards these days). Table 1.1 shows a few other event specifiers that you might find useful.

Table 1.1. Event Specifiers

Event specifer

Meaning

<Button-1>

Mouse button 1 is pressed

<1>

Shorthand for <Button-1>

<ButtonRelease-1>

Mouse button 1 is released

<Double-Button-1>

Double-click on mouse button 1

<Key-a>

Key a is pressed

<a> or a

Shorthand for <Key-a>

<Motion>

Pointer motion with any (or no) buttons or modifier keys pressed

<B1-Motion>

Pointer motion with button 1 pressed

The script for a binding has access to several pieces of information about the event, such as the location of the pointer when the event occurred. For an example, start up wish interactively and enter the following command in it:

    bind . <Motion> {puts "pointer at %x,%y"}

Now move the pointer over the window. Each time the pointer moves, a message is printed on standard output giving its new location. When the pointer motion event occurs, Tk scans the script for % sequences and replaces them with information about the event before passing the script to Tcl for evaluation. %x is replaced with the pointer's x-coordinate and %y is replaced with the pointer's y-coordinate.

The intent of a binding is to extend the generic built-in behavior of the entry (editing text strings) with an application-specific behavior. In this script, as a convenience we would like to allow the user to request the factorial calculation by pressing the Return key as an alternative to clicking the "Calculate" button. We could simply duplicate the button's command script, but if we were to modify the command script later, we'd need to remember to replicate the change in the binding script as well. Instead, we provide a binding script that "programmatically clicks" the button.

The binding script executes two commands called widget commands. Whenever a new widget is created, a new Tcl command is also created with the same name as the widget, and you can invoke this command to communicate with the widget. The first argument to a widget command selects one of several operations, and additional arguments are used as parameters for that operation. In this binding script, the first widget command flashes the button. (Depending on your system's color scheme, you might not see the button flash.) The second widget command causes the button widget to invoke its -command option just as if you had clicked the mouse button on it.

Each class of widget supports a different set of operations in its widget commands, but many of the operations are similar from class to class. For example, every widget class supports a configure widget command that can be used to modify any of the configuration options for the widget. If you run the factorial.tcl script interactively, you could type the following command to change the background of the entry widget to yellow:

    .value configure -background yellow

Or you could type

    .calculate configure -state disabled

to make the button unresponsive to user interaction.

  • + Share This
  • 🔖 Save To Your Account