Here is a simple example that creates a form and
parses the data using the modules that we've just discussed. The
dynamic form that is output by the program is shown in Figure C-1.
Now, let's look at the program:
#!/usr/local/bin/perl5
use CGI::Form;
use CGI::Response qw(:Simple);
use CGI::Carp;
Before we can use any of the methods in the CGI modules, we
have to import them into our program. In the case of CGI::Response,
some of the "simple" methods, such as those that output the Content-type
and Pragma HTTP headers, are
not exported by the module so we have to literally specify it.
The NoCache
method from the CGI::Response class outputs
the following header information:
Pragma: no-cache
Content-Type: text/html
Expires: Mon, 29 Jan 1996 00:53:49 GMT
which instructs the server that HTML data
is about to follow, and that it should not cache the document.
$cgi_form = new CGI::Form ();
$user = $cgi_form->param ('name');
We create a new instance of the Form
object and store it in $cgi_form. Then, we
retrieve the value for the form field labeled name
so that we can use it to personalize the title of the document for
successive forms.
Here we see an example of inheritance. The param method is implemented in the
CGI::Request module, which is inherited by
CGI::Form. As a result, we can access the method
as though it was part of CGI::Form.
if ($user) {
$remote_user = "Welcomes $user";
} else {
$remote_user = join (" ", "- Welcome from", $cgi_form->cgi->var ("REMOTE_HOST"));
}
Here, we set the $remote_user variable
to a welcome message. If the $user variable
is not defined, we use the remote host name instead. Here is another
interesting call. The cgi method is implemented
in the CGI::Request module and interfaces with
CGI::Base. The var method
is defined in CGI::Base and returns the value
of a specific environment variable.
print <<Start_HTML;
<HTML>
<HEAD><TITLE>Welcome to Shishir's Track & Field Emporium</TITLE></HEAD>
<BODY>
<H1>Track and Field $remote_user</H1>
<HR>
Start_HTML
&display_form ($cgi_form);
print <<End_HTML;
<HR>
</BODY>
</HTML>
End_HTML
exit (0);
We output the header and footer with a form in between. The
form is created by the display_form subroutine,
which expects an instance of the CGI::Form
class.
The display_form subroutine creates a
form by calling several methods in the CGI::Form
class. Not only do these methods output the necessary HTML
to create the form, but they also check to see if there is any form
data that is being passed to the program, and use that data as default
information for the various fields--providing that the field (names)
are the same. This is actually an example that saves state, and
works as a result of setting the ACTION attribute
on the form to point back to this script; there is always data passed
to the program if the user submits the form.
sub display_form
{
local ($form) = @_;
Here the $form refers to an instance
of the CGI::Form object that we created earlier.
print $form->startform ();
print "Name: ";
print $form->textfield ('name'), "<BR>", "\n";
print "E-Mail Address: ";
print $form->textfield ('email'), "<BR>", "\n";
The startform
method outputs the necessary <FORM> tag to
start the form. The startform method uses a
default ACTION of the current script, and a default
METHOD of POST.
The textfield
method creates a text field. If the form data passed to this program
has a field titled name, the method will use
the passed-in value as a default. In other words, this is what it
does (assume that form data is stored in the %FORM
associative array):
$value = $FORM{'email'};
print qq|<INPUT TYPE="text" NAME="email" VALUE="$value">|;
This results in form fields containing data from the previous
request (or state). The CGI::Form object uses
the param method from the CGI::Request
module to retrieve the value for a specific form field.
print "<P>", "Snail Mail Address: ";
print $form->textarea ('address', undef, 5, 40);
Here we create a textarea titled "address"
with a size of 5 rows and 40 columns. The second argument to the
textarea method is used for placing default
information within a text area.
print "<P>", "What would you like to receive: ", "<BR>";
print $form->checkbox_group (-name => 'want',
-values => ['Latest Catalog',
'Up-to-date Track News',
'Catalog Specials'],
-default => 'Latest Catalog',
-linebreak => 'true');
See how easy it is to create a group of
checkboxes?
The labels for each checkbox default to the specified values. However,
you can pass a "-labels" argument if you want the labels to be different
than the values.
print "<P>", "Where do you live: ", "<BR>";
print $form->radio_group (-name => 'where',
-values => ['North America',
'South America',
'Europe',
'Australia',
'Antartica'],
-default => 'North America',
-linebreak => 'true');
print "<P>", "What type of events do you participate in: ", "<BR>";
print $form->popup_menu (-name => 'events',
-values => ['Sprints',
'Middle Distance',
'Distance',
'Field Events',
'Throws'],
-default => 'Sprints');
Radio buttons and popup menus are created in much the same
way as checkboxes.
if ( ($form->param ('events') eq "Sprints") && ($form->param ('send_entry')) ) {
if ($user) {
warn "Shishir, $user is a sprinter!! Yahoo!\n";
} else {
warn "Shishir, we have an *anonymous* sprinter here!\n";
}
}
We use the param method to check the
value of the events and send_entry fields.
If our check is successful, we call the warn
statement, which will output a message to the server log file in
the following format:
[Mon Jan 29 15:07:25 1996] simple.pl: Shishir, Jan Apell is a sprinter!! Yahoo!
Now, let's finish off the program.
print "<P>";
print $form->reset ();
print $form->defaults ();
print $form->submit ('send_entry', 'Submit');
print $form->endform ();
}
The reset, defaults,
and submit methods create different type of
buttons. reset allows you to clear the values
in the current form and display values from the previous state (or
session). The defaults button clears the form
entirely. And the submit
method creates a Submit button for you to send the data to the server.
![[Graphic: Figure C-1]](./figs/cgic01.gif)
