HTML::Form man page on HP-UX

Man page or keyword search:  
man Server   10987 pages
apropos Keyword Search (all sections)
Output format
HP-UX logo
[printable version]

HTML::Form(3)	      User Contributed Perl Documentation	 HTML::Form(3)

       HTML::Form - Class that represents an HTML form element

	use HTML::Form;
	$form = HTML::Form->parse($html, $base_uri);
	$form->value(query => "Perl");

	use LWP::UserAgent;
	$ua = LWP::UserAgent->new;
	$response = $ua->request($form->click);

       Objects of the "HTML::Form" class represents a single HTML "<form> ...
       </form>" instance.  A form consists of a sequence of inputs that usu‐
       ally have names, and which can take on various values.  The state of a
       form can be tweaked and it can then be asked to provide "HTTP::Request"
       objects that can be passed to the request() method of "LWP::UserAgent".

       The following methods are available:

       @forms = HTML::Form->parse( $response )
       @forms = HTML::Form->parse( $html_document, $base )
       @forms = HTML::Form->parse( $html_document, %opt )
	   The parse() class method will parse an HTML document and build up
	   "HTML::Form" objects for each <form> element found.	If called in
	   scalar context only returns the first <form>.  Returns an empty
	   list if there are no forms to be found.

	   The $base is the URI used to retrieve the $html_document.  It is
	   needed to resolve relative action URIs.  If the document was
	   retrieved with LWP then this this parameter is obtained from the
	   $response->base() method, as shown by the following example:

	       my $ua = LWP::UserAgent->new;
	       my $response = $ua->get("");
	       my @forms = HTML::Form->parse($response->decoded_content,

	   The parse() method can parse from an "HTTP::Response" object
	   directly, so the example above can be more conveniently written as:

	       my $ua = LWP::UserAgent->new;
	       my $response = $ua->get("");
	       my @forms = HTML::Form->parse($response);

	   Note that any object that implements a decoded_content() and base()
	   method with similar behaviour as "HTTP::Response" will do.

	   Finally options might be passed in to control how the parse method
	   behaves.  The following options are currently recognized:

	   "base => $uri"
	       Another way to provide the base URI.

	   "verbose => $bool"
	       Warn (print messages to STDERR) about any bad HTML form con‐
	       structs found.  You can trap these with $SIG{__WARN__}.

	   "strict => $bool"
	       Initialize any form objects with the given strict attribute.

       $method = $form->method
       $form->method( $new_method )
	   This method is gets/sets the method name used for the
	   "HTTP::Request" generated.  It is a string like "GET" or "POST".

       $action = $form->action
       $form->action( $new_action )
	   This method gets/sets the URI which we want to apply the request
	   method to.

       $enctype = $form->enctype
       $form->enctype( $new_enctype )
	   This method gets/sets the encoding type for the form data.  It is a
	   string like "application/x-www-form-urlencoded" or "multi‐

       $value = $form->attr( $name )
       $form->attr( $name, $new_value )
	   This method give access to the original HTML attributes of the
	   <form> tag.	The $name should always be passed in lower case.


	      @f = HTML::Form->parse( $html, $foo );
	      @f = grep $_->attr("id") eq "foo", @f;
	      die "No form named 'foo' found" unless @f;
	      $foo = shift @f;

       $bool = $form->strict
       $form->strict( $bool )
	   Gets/sets the strict attribute of a form.  If the strict is turned
	   on the methods that change values of the form will croak if you try
	   to set illegal values or modify readonly fields.  The default is
	   not to be strict.

       @inputs = $form->inputs
	   This method returns the list of inputs in the form.	If called in
	   scalar context it returns the number of inputs contained in the
	   form.  See "INPUTS" for what methods are available for the input
	   objects returned.

       $input = $form->find_input( $name )
       $input = $form->find_input( $name, $type )
       $input = $form->find_input( $name, $type, $index )
	   This method is used to locate specific inputs within the form.  All
	   inputs that match the arguments given are returned.	In scalar con‐
	   text only the first is returned, or "undef" if none match.

	   If $name is specified, then the input must have the indicated name.

	   If $type is specified, then the input must have the specified type.
	   The following type names are used: "text", "password", "hidden",
	   "textarea", "file", "image", "submit", "radio", "checkbox" and

	   The $index is the sequence number of the input matched where 1 is
	   the first.  If combined with $name and/or $type then it select the
	   nth input with the given name and/or type.

       $value = $form->value( $name )
       $form->value( $name, $new_value )
	   The value() method can be used to get/set the value of some input.
	   If strict is enabled and no input has the indicated name, then this
	   method will croak.

	   If multiple inputs have the same name, only the first one will be

	   The call:


	   is basically a short-hand for:


       @names = $form->param
       @values = $form->param( $name )
       $form->param( $name, $value, ... )
       $form->param( $name, \@values )
	   Alternative interface to examining and setting the values of the

	   If called without arguments then it returns the names of all the
	   inputs in the form.	The names will not repeat even if multiple
	   inputs have the same name.  In scalar context the number of differ‐
	   ent names is returned.

	   If called with a single argument then it returns the value or val‐
	   ues of inputs with the given name.  If called in scalar context
	   only the first value is returned.  If no input exists with the
	   given name, then "undef" is returned.

	   If called with 2 or more arguments then it will set values of the
	   named inputs.  This form will croak if no inputs have the given
	   name or if any of the values provided does not fit.	Values can
	   also be provided as a reference to an array.	 This form will allow
	   unsetting all values with the given name as well.

	   This interface resembles that of the param() function of the CGI

       $form->try_others( \&callback )
	   This method will iterate over all permutations of unvisited enumer‐
	   ated values (<select>, <radio>, <checkbox>) and invoke the callback
	   for each.  The callback is passed the $form as argument.  The
	   return value from the callback is ignored and the try_others()
	   method itself does not return anything.

       $request = $form->make_request
	   Will return an "HTTP::Request" object that reflects the current
	   setting of the form.	 You might want to use the click() method

       $request = $form->click
       $request = $form->click( $name )
       $request = $form->click( $x, $y )
       $request = $form->click( $name, $x, $y )
	   Will "click" on the first clickable input (which will be of type
	   "submit" or "image").  The result of clicking is an "HTTP::Request"
	   object that can then be passed to "LWP::UserAgent" if you want to
	   obtain the server response.

	   If a $name is specified, we will click on the first clickable input
	   with the given name, and the method will croak if no clickable
	   input with the given name is found.	If $name is not specified,
	   then it is ok if the form contains no clickable inputs.  In this
	   case the click() method returns the same request as the
	   make_request() method would do.

	   If there are multiple clickable inputs with the same name, then
	   there is no way to get the click() method of the "HTML::Form" to
	   click on any but the first.	If you need this you would have to
	   locate the input with find_input() and invoke the click() method on
	   the given input yourself.

	   A click coordinate pair can also be provided, but this only makes a
	   difference if you clicked on an image.  The default coordinate is
	   (1,1).  The upper-left corner of the image is (0,0), but some badly
	   coded CGI scripts are known to not recognize this.  Therefore (1,1)
	   was selected as a safer default.

       @kw = $form->form
	   Returns the current setting as a sequence of key/value pairs.  Note
	   that keys might be repeated, which means that some values might be
	   lost if the return values are assigned to a hash.

	   In scalar context this method returns the number of key/value pairs

	   Returns a textual representation of current state of the form.
	   Mainly useful for debugging.	 If called in void context, then the
	   dump is printed on STDERR.

       An "HTML::Form" objects contains a sequence of inputs.  References to
       the inputs can be obtained with the $form->inputs or $form->find_input

       Note that there is not a one-to-one correspondence between input
       objects and <input> elements in the HTML document.  An input object
       basically represents a name/value pair, so when multiple HTML elements
       contribute to the same name/value pair in the submitted form they are

       The input elements that are mapped one-to-one are "text", "textarea",
       "password", "hidden", "file", "image", "submit" and "checkbox".	For
       the "radio" and "option" inputs the story is not as simple: All <input
       type="radio"> elements with the same name will contribute to the same
       input radio object.  The number of radio input objects will be the same
       as the number of distinct names used for the <input type="radio"> ele‐
       ments.  For a <select> element without the "multiple" attribute there
       will be one input object of type of "option".  For a <select multiple>
       element there will be one input object for each contained <option> ele‐
       ment.  Each one of these option objects will have the same name.

       The following methods are available for the input objects:

	   Returns the type of this input.  The type is one of the following
	   strings: "text", "password", "hidden", "textarea", "file", "image",
	   "submit", "radio", "checkbox" or "option".

       $name = $input->name
       $input->name( $new_name )
	   This method can be used to get/set the current name of the input.

       $value = $input->value
       $input->value( $new_value )
	   This method can be used to get/set the current value of an input.

	   If strict is enabled and the input only can take an enumerated list
	   of values, then it is an error to try to set it to something else
	   and the method will croak if you try.

	   You will also be able to set the value of read-only inputs, but a
	   warning will be generated if running under "perl -w".

	   Returns a list of all values that an input can take.	 For inputs
	   that do not have discrete values, this returns an empty list.

	   Returns a list of all values not tried yet.

	   For some inputs the values can have names that are different from
	   the values themselves.  The number of names returned by this method
	   will match the number of values reported by $input->possible_val‐

	   When setting values using the value() method it is also possible to
	   use the value names in place of the value itself.

       $bool = $input->readonly
       $input->readonly( $bool )
	   This method is used to get/set the value of the readonly attribute.
	   You are allowed to modify the value of readonly inputs, but setting
	   the value will generate some noise when warnings are enabled.  Hid‐
	   den fields always start out readonly.

       $bool = $input->disabled
       $input->disabled( $bool )
	   This method is used to get/set the value of the disabled attribute.
	   Disabled inputs do not contribute any key/value pairs for the form

	   Returns a (possible empty) list of key/value pairs that should be
	   incorporated in the form value from this input.

	   Some input types represent toggles that can be turned on/off.  This
	   includes "checkbox" and "option" inputs.  Calling this method turns
	   this input on without having to know the value name.	 If the input
	   is already on, then nothing happens.

	   This has the same effect as:


	   The input can be turned off with:


       $input->click($form, $x, $y)
	   Some input types (currently "submit" buttons and "images") can be
	   clicked to submit the form.	The click() method returns the corre‐
	   sponding "HTTP::Request" object.

       If the input is of type "file", then it has these additional methods:

	   This is just an alias for the value() method.  It sets the filename
	   to read data from.

       $filename = $input->filename
       $input->filename( $new_filename )
	   This get/sets the filename reported to the server during file
	   upload.  This attribute defaults to the value reported by the
	   file() method.

       $content = $input->content
       $input->content( $new_content )
	   This get/sets the file content provided to the server during file
	   upload.  This method can be used if you do not want the content to
	   be read from an actual file.

       @headers = $input->headers
       input->headers($key => $value, .... )
	   This get/set additional header fields describing the file uploaded.
	   This can for instance be used to set the "Content-Type" reported
	   for the file.

       LWP, LWP::UserAgent, HTML::Parser

       Copyright 1998-2008 Gisle Aas.

       This library is free software; you can redistribute it and/or modify it
       under the same terms as Perl itself.

perl v5.8.8			  2008-09-24			 HTML::Form(3)

List of man pages available for HP-UX

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net