File Coverage

blib/lib/WWW/Form.pm

Criterion	Covered	Total	%
statement	231	366	63.1
branch	37	82	45.1
condition	15	28	53.5
subroutine	36	48	75.0
pod	30	30	100.0
total	349	554	63.0

package WWW::Form;
$WWW::Form::VERSION = '1.23';
use strict;
use warnings;

use 5.014;

use HTML::Entities ();


sub new {
    my $class = shift;

    # Hash that contains various bits of data in regard to the form fields,
    # i.e. the form field's label, its input type (e.g. radio, text, textarea,
    # select, etc.) validators to check the user entered input against a
    # default value to use before the form is submitted and an option group
    # hash if the type of the form input is select or radio this hash should
    # be keyed with the values you want to use for the name attributes of your
    # form inputs
    my $fieldsData = shift;

    # Values to populate value keys of field hashes with generally this will
    # be a hash of HTTP params needs to have the same keys as fieldsData
    my $fieldValues = shift || {};

    # Array ref of field name keys that should be in the order that you want
    # to display your form inputs
    my $fieldsOrder = shift || [];

    my $self = {};

    $self->{fieldsOrder} = $fieldsOrder;

    bless($self, $class);

    # Set up a fields hash ref for the fields, so we will not need
    # autovivificatiopn later
    $self->{fields} = {};

    # Creates and populates fields hash
    $self->_setFields($fieldsData, $fieldValues);

    return $self;
}



sub validateFields {
    my $self   = shift;

    # Initialize hash of valid fields
    my %validFields = ();

    # Init isValid property to 1 that is, the form starts out as being valid
    # until an invalid field is found, at which point the form gets set to
    # invalid (i.e., $self->{isValid} = 0)
    $self->{isValid} = 1;

    # Go through all the fields and look to see if they have any validators,
    # if so check the validators to see if the input is valid, if the field
    # has no validators then the field is always valid
    foreach my $fieldName (keys %{$self->{fields}}) {

        # Look up hash ref of data for the current field name
        my $field = $self->getField($fieldName);

        my $fieldValue = $self->getFieldValue($fieldName);

        # If this field has any validators, run them
        if (scalar(@{$field->{validators}}) > 0) {

            # Keeps track of how many validators pass
            my $validValidators = 0;

            # Check the field's validator(s) to see if the user input is valid
            foreach my $validator (@{$field->{validators}}) {

                if ($validator->validate($fieldValue)) {
                    # Increment the validator counter because the current
                    # validator passed, i.e. the form input was good
                    $validValidators++;
                }
                else {
                    # Mark field as invalid so error feedback can be displayed
                    # to the user
                    $field->{isValid} = 0;

                    # Mark form as invalid because at least one input is not
                    # valid
                    $self->{isValid} = 0;

                    # Add the validators feedback to the array of feedback for
                    # this field
                    push @{$field->{feedback}}, $validator->{feedback};
                }
            }

            # Only set the field to valid if ALL of the validators pass
            if (scalar(@{$field->{validators}}) == $validValidators) {
                $field->{isValid} = 1;
                $validFields{$fieldName} = $fieldValue;
            }
        }
        else {
            # This field didn't have any validators so it's ok
            $field->{isValid} = 1;
            $validFields{$fieldName} = $fieldValue;
        }
    }

    # Return hash ref of valid fields
    return \%validFields;
}


*validate_fields = \&validateFields;



sub getFields {
    my $self = shift;
    return $self->{fields};
}


*get_fields = \&getFields;



sub resetFields {
    my ($self, %args) = @_;
    my $fields = $self->getFields();

    for my $fieldName (keys %$fields) {
        $self->setFieldValue($fieldName, '');

        $self->getField($fieldName)->{defaultValue} = ''
            if ($args{include_defaults});
    }
}


*reset_fields = \&resetFields;



sub getField {
    my $self      = shift;
    my $fieldName = shift;
    return $self->{fields}{$fieldName};
}


*get_field = \&getField;



sub getFieldErrorFeedback {
    my $self      = shift;
    my $fieldName = shift;

    my $field = $self->getField($fieldName);

    if ($field->{feedback}) {
        return @{$field->{feedback}};
    }
    else {
        return ();
    }
}


*get_field_error_feedback = \&getFieldErrorFeedback;



sub getFieldsOrder {
    my $self = shift;
    return $self->{fieldsOrder};
}


*get_fields_order = \&getFieldsOrder;



sub getFieldValue {
    my $self      = shift;
    my $fieldName = shift;
    return $self->getField($fieldName)->{value};
}


*get_field_value = \&getFieldValue;



sub isFieldValid {
    my $self      = shift;
    my $fieldName = shift;

    return $self->getField($fieldName)->{isValid};
}


*is_field_valid = \&isFieldValid;



sub getFieldValidators {
    my ($self, $fieldName) = @_;
    return $self->getField($fieldName)->{validators};
}


*get_field_validators = \&getFieldValidators;



sub getFieldType {
    my $self      = shift;
    my $fieldName = shift;
    return $self->getField($fieldName)->{type};
}


*get_field_type = \&getFieldType;



sub getFieldLabel {
    my $self  = shift;
    my $fieldName = shift;

    my $field = $self->getField($fieldName);

    if ($self->getFieldType($fieldName) eq 'checkbox') {
        return "" . $field->{label} . '';
    }
    else {
        return $field->{label};
    }
}


*get_field_label = \&getFieldLabel;



sub getFieldHint {
    my $self  = shift;
    my $fieldName = shift;

    my $field = $self->getField($fieldName);

    return $field->{hint};
}


*get_field_hint = \&getFieldHint;



sub setFieldValue {
    my $self      = shift;
    my $fieldName = shift;
    my $newValue  = shift;

    if (my $field = $self->getField($fieldName)) {
        $field->{value} = $newValue;
        #warn("set field value for field: $fieldName to '$new_value'");
    }
    else {
        #warn("could not find field for field name: '$fieldName'");
    }
}


*set_field_value = \&setFieldValue;



sub isValid {
    my $self = shift;
    return $self->{isValid};
}


*is_valid = \&isValid;



sub isSubmitted {
    my $self = shift;

    # The actual HTTP request method that the form was sent using
    my $formRequestMethod = shift;

    # This should be GET or POST, defaults to POST
    my $formMethodToCheck = shift || 'POST';

    if ($formRequestMethod eq $formMethodToCheck) {
        return 1;
    }
    else {
        return 0;
    }
}


*is_submitted = \&isSubmitted;



# Private method
#
# Populates fields hash for each field of the form
sub _setFields {
    my $self        = shift;
    my $fieldsData  = shift;
    my $fieldValues = shift;

    # TODO :
    # Create a _setField() method that will encapsulate the functionality
    # inside the loop. This will enable adding more variables to each field
    # in the sub-classes more easily.

    foreach my $fieldName (keys %{$fieldsData}) {
        $self->_setField(
            'name' => $fieldName,
            'params' => $fieldsData->{$fieldName},
            'value' => $fieldValues->{$fieldName}
        );
    }
}

sub _getFieldInitParams
{
    my $self = shift;

    my %args = (@_);

    my $fieldName = $args{name};
    my $params = $args{params};
    my $user_given_field_value = $args{value};

    # This is the output parameters that we eventually place under
    # $out_params->. It is declared it so it can later be filled
    # in by a different function other
    my $out_params = {};

    # Use the supplied field value if one is given. Generally the supplied
    # data will be a hash of HTTP POST data
    my $fieldValue = '';

    # Only use the default value of a check box if the form has been
    # submitted, that is, the default value should be the value that you
    # want to show up in the POST data if the checkbox is selected when
    # the form is submitted
    if ($params->{type} eq 'checkbox') {

        # If the checkbox was selected then we're going to use the default
        # value for the checkbox input's value in our WWW::Form object, if
        # the checkbox was not selected and the form was submitted that
        # variable will not show up in the hash of HTTP variables
        if ($user_given_field_value) {
            $fieldValue = $params->{defaultValue};
        }

        # See if this checkbox should be checked by default
        $out_params->{defaultChecked} =
            $params->{defaultChecked};
    }
    else {
        # If a key exists in the $fieldValues hashref, use that value
        # instead of the default, we generally want to favor displaying
        # user entered values than defaults
        if (defined($user_given_field_value)) {
            $fieldValue = $user_given_field_value;
        }
        else {
            $fieldValue = $params->{defaultValue};
        }
    }

    # Value suitable for displaying to users as a label for a form input,
    # e.g. 'Email address', 'Full name', 'Street address', 'Phone number',
    # etc.
    $out_params->{label} = $params->{label};

    # Holds the value that the user enters after the form is submitted
    $out_params->{value} = $fieldValue;

    # The value to pre-populate a form input with before the form is
    # submitted, the only exception is a checkbox form input in the case
    # of a checkbox, the default value will be the value of the checkbox
    # input if the check box is selected and the form is submitted, see
    # form_test.pl for an example
    $out_params->{defaultValue} =
        $params->{defaultValue};

    # The validators for this field, validators are used to test user
    # entered form input to make sure that it the user entered data is
    # acceptable
    $out_params->{validators} =
        \@{$params->{validators}};

    # Type of the form input, i.e. 'radio', 'text', 'select', 'checkbox',
    # etc. this is mainly used to determine what type of HTML method
    # should be used to display the form input in a web page
    $out_params->{type} = $params->{type};

    # If any validators fail, this property will contain the error
    # feedback associated with those failing validators
    $out_params->{feedback} = [];

    # If the input type is a select box or a radio button then we need an
    # array of labels and values for the radio button group or select box
    # option groups
    if (my $optionsGroup = $params->{optionsGroup}) {
        $out_params->{optionsGroup} = \@{$optionsGroup};
    }

    # Arbitrary HTML attributes that will be used when the field's input
    # element is displayed.
    $out_params->{extraAttributes} =
        ($params->{extraAttributes} || "");

    # Add the hint
    # 2004-Jan-04 - Added by Shlomi Fish:
    #  Ben, no. Actually it's a hint that will always be displayed below
    #  the table row to instruct the users what to input there. For instance
    #  +----------+---------------------------+
    #  |  City:   | [================]        |
    #  +----------+---------------------------+
    #  |  Input the city in which you live    |
    #  |  in.                                 |
    #  +---------------------------------------
    #  So "Input the city..." would be the hint.
    if (my $hint = $params->{hint})
    {
        $out_params->{hint} = $hint;
    }

    # Add the container_attributes. These are HTML attributes that would
    # be added to the rows of this HTML row.
    if (my $attribs = $params->{container_attributes})
    {
        $out_params->{container_attributes} = $attribs;
    }

    # Add the hint_container_attributes. These are HTML attributes that
    # would  be added to the Hint row of this HTML row.
    if (my $attribs = $params->{hint_container_attributes})
    {
        $out_params->{hint_container_attributes} = $attribs;
    }

    return $out_params;
}

# This function should not be left alone in sub-classing.
# Instead override _getFieldInitParams() to add your own parameters
# there.
sub _setField
{
    my $self = shift;

    my %args = (@_);

    my $params = $self->_getFieldInitParams(%args);

    $self->{fields}{$args{name}} = $params;

    return $self;
}


sub asString {
    my $self = shift;
    require Data::Dumper;
    return Data::Dumper::Dumper($self);
}


*as_string = \&asString;

sub _getFieldType
{
    my $self = shift;
    my $fieldName = shift;

    return $self->getField($fieldName)->{type};
}

#-----------------------------------------------------------------------------
# Convenience methods for displaying HTML form data including form inputs,
# labels, and error feedback
#
# Note: You do not need to use these methods to display your form inputs, but
# they should be reasonably flexible enough to handle most cases
#-----------------------------------------------------------------------------


sub getFieldFormInputHTML {
    my $self = shift;

    # The value of the HTML name attribute of the form field
    my $fieldName = shift;

    # A string that can contain an arbitrary number of HTML attribute
    # name=value pairs, this lets you apply CSS classes to form inputs
    # or control the size of your text inputs, for example
    my $attributesString = shift || '';

    my $type = $self->_getFieldType($fieldName);

    if ($type =~ /text$|password|hidden|file/) {

        return $self->_getInputHTML($fieldName, $attributesString);

    }
    elsif ($type eq 'checkbox') {

        return $self->_getCheckBoxHTML($fieldName, $attributesString);

    }
    elsif ($type eq 'radio') {

        return $self->_getRadioButtonHTML($fieldName, $attributesString);

    }
    elsif ($type eq 'select') {

        return $self->_getSelectBoxHTML($fieldName, $attributesString);

    }
    elsif ($type eq 'textarea') {

        return $self->_getTextAreaHTML($fieldName, $attributesString);
    }
}


*get_field_form_input_HTML = \&getFieldFormInputHTML;



sub getFieldLabelTdHTML
{
    return "
}


sub getFieldInputTdHTML
{
    return "
}


sub renderFieldHTMLRow
{
    my $self = shift;
    my (%args) = (@_);
    my $fieldName = $args{'fieldName'};
    my $attributesString = $args{'attributesString'};
    my $tr_attr_string = $args{'trAttrString'};
    return
        "" . $self->getFieldLabelTdHTML($fieldName) .
        $self->getFieldLabel($fieldName) . "
        $self->getFieldInputTdHTML($fieldName) . $self->getFieldFormInputHTML(
            $fieldName,
            $attributesString
        )
        . "
}


sub renderHintHTMLRow
{
    my $self = shift;
    my $fieldName = shift;
    my (%func_args) = (@_);

    my $field = $self->getField($fieldName);

    my $tr_attributes = $self->_getTrAttributes($fieldName);

    my $form_args = $func_args{'form_args'};

    my $hint = $self->getFieldHint($fieldName);

    if (defined($hint)) {
        my %hint_attributes = ();
        my $hint_attributes = $form_args->{'hint_container_attributes'};

        if (defined($hint_attributes)) {
            %hint_attributes = (%hint_attributes, %$hint_attributes);
        }

        %hint_attributes = (%hint_attributes, %$tr_attributes);

        if (exists($field->{hint_container_attributes})) {
            %hint_attributes = (%hint_attributes, %{$field->{hint_container_attributes}});
        }

        my $hint_attr_string = $self->_render_attributes(\%hint_attributes);
        return "
    }
    else
    {
        return "";
    }
}

sub _getTrAttributes
{
    my $self = shift;
    my $fieldName = shift;

    my %tr_attributes = ();

    my $field = $self->getField($fieldName);

    if (exists($field->{container_attributes})) {
        %tr_attributes = (%tr_attributes, %{$field->{container_attributes}});
    }
    return \%tr_attributes;
}

sub _render_attributes {
    my $self = shift;
    my $attribs = shift;

    # We sort the keys to produce reproducible output on perl 5.8.1 and above
    # where the order of the hash keys is not deterministic
    return join("",
            map { " $_=\"" . $self->_escapeValue($attribs->{$_}) . "\"" }
                (sort {$a cmp $b} keys(%$attribs))
            );
}

sub _getTrAttrString
{
    my $self = shift;
    my $fieldName = shift;
    return $self->_render_attributes($self->_getTrAttributes($fieldName));
}


sub getFieldHTMLRow {
    my $self = shift;
    my $fieldName = shift;

    if ($self->_getFieldType($fieldName) eq "hidden")
    {
        return $self->_getHiddenFieldHTMLRow($fieldName);
    }

    my %func_args = (@_);
    my $attributesString = $func_args{'attributesString'};
    my $form_args = $func_args{'form_args'};

    my $field = $self->getField($fieldName);

    $attributesString ||= $field->{extraAttributes};

    my @feedback = $self->getFieldErrorFeedback($fieldName);

    my $html = "";

    my $tr_attr_string = $self->_getTrAttrString($fieldName);

    foreach my $error (@feedback) {
        $html .= "
            . "$error"
            . "
    }

    $html .= $self->renderFieldHTMLRow(
        'fieldName' => $fieldName,
        'attributesString' => $attributesString,
        'trAttrString' => $tr_attr_string,
        );

    $html .=
        $self->renderHintHTMLRow(
            $fieldName,
            'form_args' => $form_args,
        );

    return $html;
}


*get_field_HTML_row = \&getFieldHTMLRow;


sub getFieldHTMLRowNoHidden
{
    my $self = shift;
    my $fieldName = shift;

    if ($self->_getFieldType($fieldName) eq "hidden")
    {
        return "";
    }
    else
    {
        return $self->getFieldHTMLRow($fieldName);
    }
}


*get_field_HTML_row_no_hidden = \&getFieldHTMLRowNoHidden;


sub getFieldFeedbackHTML {
    my $self      = shift;
    my $fieldName = shift;

    my @feedback = $self->getFieldErrorFeedback($fieldName);

    my $feedbackHTML = '';

    foreach my $fieldFeedback (@feedback) {
        $feedbackHTML .= "\n";
        $feedbackHTML .= $fieldFeedback . "\n\n";
    }

    return $feedbackHTML;
}


*get_field_feedback_HTML = \&getFieldFeedbackHTML;



sub startForm {
    my ($self, %args) = @_;

    my $method = $args{method} || 'post';
    my $attributes = $args{attributes} || {};

    my $name_attributes = '';
    if ($args{name}) {
        $name_attributes = " name='$args{name}' id='$args{name}'";
    }

    my $html = "
        . " method='$method'$name_attributes";

    # If this form contains a file input then set the enctype attribute
    # to multipart/form-data
    if ($args{is_file_upload}) {
        $html .= " enctype='multipart/form-data'";
    }

    for my $attribute (keys %{$attributes}) {
        $html .= " $attribute='$attributes->{$attribute}'";
    }

    # Chop off last space if there is one
    $html =~ s/\s$//;

    return $html . '>';
}


*start_form = \&startForm;



sub endForm {
    my $self = shift;
    return '';
}


*end_form = \&endForm;



sub getFormHTML {
    my ($self, %args) = @_;

    my $html = $self->startForm(%args) . "\n";

    $html .= $self->getHiddenFieldsHTML();
    $html .= "\n"; 




792




 





 





 





 





 





 



   




793




 





 





 





 





 





 



     # Go through all of our form fields and build an HTML input for each field 




794




2





 





 





 





 





3



     for my $fieldName (@{$self->getFieldsOrder()}) { 




 




2





 





 





 





 





7



   




795




 





 





 





 





 





 



         #warn("field name is: $fieldName"); 




796




5





 





 





 





 





12



         $html .= $self->getFieldHTMLRowNoHidden( 




797




 





 





 





 





 





 



             $fieldName, 




798




 





 





 





 





 





 



             'form_args' => \%args, 




799




 





 





 





 





 





 



         ); 




800




 





 





 





 





 





 



     } 




801




 





 





 





 





 





 



   




802




2





 





 





 





 





5



     $html .= "\n";

    # Go through all of our form fields and build an HTML input for each field
    for my $fieldName (@{$self->getFieldsOrder()}) {
        #warn("field name is: $fieldName");
        $html .= $self->getFieldHTMLRowNoHidden(
            $fieldName,
            'form_args' => \%args,
        );
    }

    $html .= "

    unless ($args{submit_label}) {
        $args{submit_label} = 'Submit';
    }

    unless ($args{submit_name}) {
        $args{submit_name} = 'submit';
    }

    # Add submit button
    $html .= "" . $self->_getSubmitButtonHTML(%args) . "\n";

    return $html . $self->endForm() . "\n";
}


*get_form_HTML = \&getFormHTML;


sub getHiddenFieldsHTML
{
    my $self = shift;

    return
        join("",
            (map { $self->_getInputHTML($_, "") . "\n" }
            grep { $self->_getFieldType($_) eq "hidden" }
            (@{$self->getFieldsOrder()}))
        );
}


*get_hidden_fields_HTML = \&getHiddenFieldsHTML;

sub _getHiddenFieldHTMLRow
{
    my $self = shift;
    my $fieldName = shift;
    return "
        "
        "
        "
}

#-----------------------------------------------------------------------------
# More private methods
#-----------------------------------------------------------------------------

# Returns HTML to display a form text input.
sub _getInputHTML {
    my $self             = shift;
    my $fieldName        = shift;
    my $attributesString = shift;

    my $field = $self->getField($fieldName);

    my $inputHTML = "
    . " name='$fieldName' id='$fieldName' value=\"";

    my $value_to_put;
    if ($field->{type} eq 'checkbox') {
        $value_to_put = $field->{defaultValue};
    }
    else {
        $value_to_put = $field->{value};
    }
    $inputHTML .= $self->_escapeValue($value_to_put);

    $inputHTML .= "\"" . $attributesString  . " />";

    return $inputHTML;
}



sub getSubmitButtonHTML {
    my ($class, %args) = @_;

    if (exists($args{buttons})) {
        my $xhtml;
        foreach my $button (@{$args{buttons}}) {
            $xhtml .= $class->_getSubmitButtonHTML(%$button);
        }
        return $xhtml;
    }

    my $type = $args{submit_type} || 'submit';

    # Optional param that specifies an image for the submit button, this
    # should only be used if the type is 'image'
    my $img_src = $args{submit_src} || '';

    my $label = $args{submit_label} || 'Submit';

    my $xhtml = "

    # If the type was specified as 'image' add the src attribute, otherwise
    # add a value attribute
    if ($type eq 'image') {
        # Warn the developer if type is 'image' and a src key wasn't specified
        unless ($img_src) {
            warn(
                "Won't be able to display image submit button properly" .
                " because src for image was not specified"
            );
        }

        $xhtml .= " src='$img_src'";
    }
    else {
        $xhtml .= " value='$label'";
    }

    my $attributes = $args{submit_attributes} || {};

    if ($args{submit_class}) {
        # Add class attribute if it's there
        $xhtml .= " class='$args{submit_class}'";
        # Add id attribute that uses same value as class, eventually should
        # use separate params, though!
        $xhtml .= " id='$args{submit_class}'";
    }

    if ($args{submit_name}) {
        $xhtml .= " name='$args{submit_name}'";

    }

    # Add any other attribute name value pairs that the developer may want to
    # enter
    for my $attribute (keys %{$attributes}) {
        $xhtml .= " $attribute='$attributes->{$attribute}'";
    }

    $xhtml =~ s/\s$//; # Remove trailing whitespace
    $xhtml .= " />\n";
    return $xhtml;
}


# We have lots of names for this method.  It used to be private, but now it's
# public.
*_get_submit_button_HTML = \&getSubmitButtonHTML;


*get_submit_button_HTML = \&getSubmitButtonHTML;
*_getSubmitButtonHTML = \&getSubmitButtonHTML;


# Returns HTML to display a checkbox.
sub _getCheckBoxHTML {
    my $self             = shift;
    my $fieldName        = shift;
    my $attributesString = shift;

    my $field = $self->getField($fieldName);

    if ($self->getFieldValue($fieldName) || $field->{defaultChecked}) {
        $attributesString .= " checked='checked'";
    }

    return $self->_getInputHTML($fieldName, $attributesString);
}

# Returns a radio button group
sub _getRadioButtonHTML {
    my $self             = shift;
    my $fieldName        = shift;
    my $attributesString = shift;

    my $field = $self->getField($fieldName);

    # Get the select boxes' list of options
    my $group = $field->{optionsGroup};

    my $inputHTML = '';

    if ($group) {
        foreach my $option (@{$group}) {
            $inputHTML .= '';

            # Reset for each radio button in the group
            my $isChecked = '';

            my $value = $option->{value};
            my $label = $option->{label};

            if ($value eq $self->getFieldValue($fieldName)) {
                $isChecked = " checked='checked'";
            }

            $inputHTML .= "
            . " name='$fieldName'";

        $inputHTML .= " value=\"". $self->_escapeValue($value) . "\" ";
        $inputHTML .= $attributesString
            . $isChecked
            . " /> $label";
        }
    }
    else {
        warn(
            "No option group found for radio button group named: '$fieldName'"
        );
    }
    return $inputHTML;
}

# Returns HTML to display a textarea.
sub _getTextAreaHTML {
    my $self             = shift;
    my $fieldName        = shift;
    my $attributesString = shift;

    my $field = $self->getField($fieldName);

    my $textarea = "</tr>

<tr>
<td  class="h" >
<a name="1020">1020</a>
</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td class="s">     . $attributesString; </td>
</tr>

<tr>
<td  class="h" >
<a name="1021">1021</a>
</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td class="s">   </td>
</tr>

<tr>
<td  class="h" >
<a name="1022">1022</a>
</td>

<td  class="c3" >

3

</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td >

7

</td>

<td class="s">     $textarea .= ">"; </td>
</tr>

<tr>
<td  class="h" >
<a name="1023">1023</a>
</td>

<td  class="c3" >

3

</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td >

9

</td>

<td class="s">     $textarea .= $self->_escapeValue($field->{value}); </td>
</tr>

<tr>
<td  class="h" >
<a name="1024">1024</a>
</td>

<td  class="c3" >

3

</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td >

 

</td>

<td >

139

</td>

<td class="s">     $textarea .= "";

    return $textarea;
}

# Returns HTML to display a select box.
sub _getSelectBoxHTML {
    my $self             = shift;
    my $fieldName        = shift;
    my $attributesString = shift;

    my $html = "\n";

    # Get the select boxes' list of options
    my $group = $self->getField($fieldName)->{optionsGroup};

    if ($group) {
        foreach my $option (@{$group}) {
            my $value = $option->{value};
            my $label = $option->{label};

            # If the current user value is equal to the current option value
            # then the current option should be selected in the form
            my $isSelected;

            if ($value eq $self->getField($fieldName)->{value}) {
                $isSelected = " selected='selected'";
            }
            else {
                $isSelected = "";
            }
            $html .= "_escapeValue($value)
            . "\"${isSelected}>$label\n";
        }
    }
    else {
        warn("No option group found for select box named: '$fieldName'");
    }

    $html .= "\n";
    return $html;
}

sub _escapeValue {
    my $self = shift;
    my $string = shift;
    return HTML::Entities::encode_entities($string);
}

1;

__END__