Scripting Graphical Commands with Tcl/Tk Mini-HOWTO
Prev |  | Next

# 4. Adding Features

Providing multiple buttons to control a single application is, perhaps, a bit of overkill, as is calling separate procedures for each action. A third problem is that apachectl prints a message to standard output to indicate how the command has been acted upon. The application could be improved by including a text widget to display the output of apachectl.

In the following script, we will redesign the application to use a radiobutton chooser and a single button by modifying the screen procedure , and build a text widget in a new frame. We also remove the start, stop, and restart procedures and create 2 new procedures. The first, init, will handle the conditionals created by the radio button selection, the second, put_text, will launch Apache and print the apachectl output to a text widget:

    #!/usr/bin/wish

    set apachectl "/usr/local/apache_new/bin/apachectl"

    proc screen {} {
      frame .top -borderwidth 10
      pack .top -fill x
      radiobutton .top.start -text "start" -variable mode -value start
      radiobutton .top.stop  -text "stop" -variable mode -value stop
      radiobutton .top.restart -text "restart" -variable mode -value restart
      button .top.submit -text execute -command init
      pack .top.start .top.stop .top.restart .top.submit -side left -padx 0p -pady 0 -anchor n
      frame .bottom
      pack .bottom -fill x
      text .bottom.main -relief sunken -bd 2 -yscrollcommand ".bottom.scroll set"
      scrollbar .bottom.scroll -command ".bottom.main yview"
      pack .bottom.main -side left -fill y
      pack .bottom.scroll -side right -fill y
    }

    proc init { } {
     global mode action
     switch $mode {
        stop     {set action "stop"}
        restart  {set action "restart"}
        default  {set action "start"}
      }
    	put_text
    }

    proc put_text {} {
      global action apachectl
      set f [ open "| $apachectl $action" r]
      while {[gets $f x] >= 0} {
        .bottom.main insert 1.0 "$x\n"
      }
      catch {close $f}
    }
    screen

First, let's have a look at the screen procedure. The radiobutton command works just like html radiobuttons. The -variable parameter accepts the name of the variable as an argument. The -value parameter accepts the variable's value as an argument. The button, .top.submit uses the -command parameter to to call the init procedure defined later in the script. These buttons are then packed into the top frame and a second frame called bottom is created.

The bottom frame is composed of a text widget and a scrollbar. Text widgets are created with the text command which takes a variety of options. In this case, we have used the -relief option which specifies the 3D effect for the field (other values for -relief include raised, flat, ridge, solid, groove); -bd option, which specifies borderwidth; and the yscrollcommand which specifies the name of a scrollbar that will be engaged by the textfield. Our scrollbar widget takes one option, -command which specifies how to behave when text scrolls beyond the screen of the text widget that it is interacting with.

The init procedure loads the mode variable into its local namespace using the global command and uses a switch statement to set the value of the global variable, action.

In this example, the switch command tests whether "$mode" matches the first word on each line in the list, and performs the action specified on the second word of each line. The default value is specified at the bottom of the list and defines the action performed if no match is found. Switch accepts 4 options: -exact, which requires a case-sensitive match, -glob, which uses a glob-style pattern match, -regexp, which uses regular-expression style matching, and --, which indicates the end of options, and is typically used if the pattern being matched has a "-" as a prefix.

Note: We could have used an if-elseif-else conditional chain rather than the switch statement:

    if { $mode == "stop" } {
      set action "stop"
    } elseif { $mode == "restart" } {
      set action "restart"
    } else {
      set action "start"
    }

The final thing that the init procedure does is call the put_text procedure.

The put_text procedure reads in the value of action that was set in the init procedure, executes apachectl with the appropriate argument as specified by action, and prints apache's output to the .bottom.main text widget.

    proc put_text {} {
     	global action apachectl
     	set f [ open "| $apachectl $action" r]
    	while {[gets $f x] >= 0} {
     		.bottom.main insert 1.0 "$x\n"
    	}
    }

The put_text procedure introduces 3 new commands:

First, it sets the value of a variable, f, to the output of the open command. Open can be used to open a file, pipe stream or serial port and returns an identifier which can be used for reading, writing, or closing a stream. Since the first character following the open is a pipe "|", $apachectl $action is treated as a command, and is executed as though the exec had been given. The r specifies that the stream is read-only. Other parameters are as follows:

    r read only
    r+  read and write if file exists
    w write only
    w+  read and write if file exists
    a write only.  Create new file if none exists.
    a+  read and write. Create new file if none exists.

The second new command is while. While is a typical while loop which executes a body of arguments so long as the specified condition is met. In this case, while will read a line of input and save it to the variable x until there is nothing left to read. The insert command inserts each line of input to the zero'th character of line 1 (1.0) of the .bottom.main text widget.

Prev | Home | Next
Tcl and Tk Basics |  | Conclusions