Mad Libs Revista rewrites the Mad Libs program from Chapter 4 to use entry widgets to create a mad lib silly sentence. To start the game, execute the script g_mad_lib.tcl in this chapter’s code directory. Figures 12.1, 12.2, and 12.3 show the game in progress.

Figure 12.1. g_mad_lib.tcl’s opening window.

Figure 12.2. Type the requested parts of speech to play the game.

Figure 12.3. Click the Replace button to see the completed sentence.

The entry and spinbox widgets are very similar. They share many of the same features, attributes, and options. In fact, the spinbox widget is derived from the entry widget. Obviously, they have different behaviors and appearances. In the following discussion, I lump entry and spinbox widgets together to avoid having to repeat myself, but I’ll point out where the two widgets differ when necessary.

The entry widget displays a one-line, editable text string. By default, an entry’s string is empty. You can select all or part of an entry widget’s contents using the mouse, keyboard, or pro-grammatically using widget attributes and commands. If the text in an entry widget is too long to fit entirely within the widget’s window, only part of the text will be displayed. This much probably doesn’t surprise you. What you might not realize, though, is that you can change the view to display different portions of the text. A spinbox widget has all of the features of an entry widget plus the ability to allow users to spin through a fixed set of values (such as times or dates).

In addition to the standard options and attributes entry and spinbox widgets support, they have specific characteristics that I want to highlight (see Table 12.1).

Many commands for the entry and spinbox widgets accept index arguments. An index argument defines a particular character in the widget’s string value. These values are usually used in the context of selecting text or to refer to a portion of a widget’s text value that is already selected. You can use one of the following index arguments (out-of-range indices round to the nearest legal value):

To use the input validation capabilities of entry and spinbox widgets, set the -validate attribute to one of the values shown in Table 12.2 and set the -validatecommand attribute to a script or procedure that validates the text (by default, validation is disabled). If the validation script returns 1, true, or another valid Tcl Boolean value, the changes to the widget’s text will be accepted. Otherwise, the changes will be ignored, and the widget will not accept or show the change.

It is possible to perform percent substitutions on the -validatecommand and -invalidcommand, just as you would in a bind script. Tk recognizes substitutions shown in Table 12.3.

Mixing -textvariable and -validatecommand might cause unpleasant results. If you use -textvariable to set the value of entry and spinbox widgets for read-only purposes, there should be no problems. Problems occur when you try to set -textvariable to a value that your validation command (which is controlled by the -validatecommand). The issue is that setting -textvariable to an invalid value causes the -validate attribute to be reset to none, which means that your -invalidcommand script will not be triggered. Why does validate get set to none? To prevent an infinite loop: setting -textvariable to an invalid value causes -invalidcommand to execute, which might set -textvariable to an invalid value, which causes -invalidcommand to execute. Disabling validation avoids the possibility of the infinite loop.

Likewise, if an error occurs in the -validatecommand or -invalidcommand while evaluating their respective scripts (or if -validatecommand does not return a valid Tcl boolean value), then validation will be disabled. In addition, if you edit the widget’s value inside either the -validatecommand or -invalidcommand scripts, validation will be disabled. Again, one reason this occurs is to prevent infinite loops. In addition, editing the widget’s value during validation overrides the edit that was being validated.

Tip: If You Must Edit During Validation

If you absolutely must edit a widget’s value during validation and want to ensure that the -validate option remains set, include the following command in your validation script:

%W config -validate %v

This command reenables validation. However, your best course of action is to avoid edits during validation and code your scripts to edit widgets after validation.

Finally, avoid setting an associated -textVariable during validation, because doing so causes the widget to get out of sync with its associated variable.

In Chapter 11, I introduced the toplevel widget and used it to create a crude but effective message box. However, Tk comes with a very nice and easy-to-use message box, created with the tk_messageBox command. Its general syntax is:

tk_messageBox ?opt val? ?...?

The icons, text, and buttons displayed in the message box depend on the options you specify in opt and val. Table 12.4 shows the options that tk_messageBox supports.

When you click one of the buttons in the window, the window closes and returns a text string corresponding to the clicked button. The -type attribute determines the buttons that appear in the window. You can use one of the following values for -type:

This chapter’s game uses tk_messageBox, so please refer to g_mad_lib.tcl for an example of using this very useful command.

g_mad_lib.tcl is a classic demonstration that turning a simple, text-based program into a graphical program is rarely a simple “rewrite” at all. Rather, it is a completely new program. In this case, the only element of my original Mad Libs program that survived the rewrite is the source sentence and the code for extracting the text that needed to be replaced.

#!/usr/bin/wish
# g_mad_lib.tcl
# Demonstrate the entry widget

# Block 1
# Validation command
proc NotEmpty {val} {
    if {$val != {}} {
        return true
    } else {
        tk_messageBox -icon error -type ok -parent . 
            -message "Replacement word or phrase cannot be empty!"
        return false
    }
}

# Block 2
# Find all of the prompts in the text
proc FindPrompts {source} {
    global prompts inputs

    set i 0
    set j 0
    while {[string first "?" $source $j] != -1} {
        set start [string first "?" $source $j]
        set end [string first "?" $source [expr $start + 1]]
        set j [expr $end + 1];
        set prompt [string range $source [expr $start + 1] 
            [expr $end - 1]]
        lappend prompts [label .l$i -text [string totitle $prompt]]
        lappend inputs [entry .e$i -bg white -validate focusout 
            -vcmd {NotEmpty %P}]
        incr i
    }
}

# Block 3
# Draw the game prompts and entry boxes
proc DisplayPrompts {prompts inputs} {
    set len [llength $prompts]
    for {set i 0} {$i < $len} {incr i} {
        grid [lindex $prompts $i] [lindex $inputs $i] -sticky w
    }
    button .bShow -text "Replace" -command ShowMadLib
    button .bExit -text "Exit" -command exit
    grid .bShow .bExit -padx 5 -pady {20 5} -sticky e
}

# Block 4
# Create a list of replacement phrases from the player's input
proc GetFields {} {
    global inputs

    foreach input $inputs {
        lappend fields [$input get]
    }
    return $fields
}

# Block 5
# Build and display the completed mad lib
proc ShowMadLib {} {
    global line

    foreach field [GetFields] {
        set start [string first "?" $line]
        set end [string first "?" $line [expr $start + 1]]
        set line [string replace $line $start $end $field]
    }
    toplevel .w
    message .w.m -text $line
    grid .w.m
}

# Block 6
# The source sentence
set line "One day while I was ?verb ending in -ing? in my living room, "
append line "a ?adjective? ?mythical creature? fell through the roof. "
append line "It jumped on the ?piece of furniture? and knocked over the "
append line "?noun?. Then it ran into the dining room and ?past tense verb? "
append line "a ?noun?. After ?number? minutes of chasing it through the "
append line "house I finally caught it and put it outside. It quickly "
append line "flew away."

# List variables to contain the prompts and the player's input
set prompts {}
set inputs {}

# Parse the source sentence
FindPrompts $line

# Display the game window
DisplayPrompts $prompts $inputs