1HTML::FormFu(3) User Contributed Perl Documentation HTML::FormFu(3)
2
6 HTML::FormFu - HTML Form Creation, Rendering and Validation Framework
7
9 version 2.07
10
12 Note: These examples make use of HTML::FormFu::Model::DBIC. As of
13 "HTML::FormFu" v02.005, the HTML::FormFu::Model::DBIC module is not
14 bundled with "HTML::FormFu" and is available in a stand-alone
15 distribution.
16 use HTML::FormFu;
18 my $form = HTML::FormFu->new;
20 $form->load_config_file('form.yml');
22 $form->process( $cgi_query );
24 if ( $form->submitted_and_valid ) {
26 # do something with $form->params
27 }
28 else {
29 # display the form
30 $template->param( form => $form );
31 }
32 If you're using Catalyst, a more suitable example might be:
34 package MyApp::Controller::User;
36 use Moose;
37 extends 'Catalyst::Controller::HTML::FormFu';
38 sub user : Chained CaptureArgs(1) {
40 my ( $self, $c, $id ) = @_;
41 my $rs = $c->model('Schema')->resultset('User');
43 $c->stash->{user} = $rs->find( $id );
45 return;
47 }
48 sub edit : Chained('user') Args(0) FormConfig {
50 my ( $self, $c ) = @_;
51 my $form = $c->stash->{form};
53 my $user = $c->stash->{user};
54 if ( $form->submitted_and_valid ) {
56 $form->model->update( $user );
58 $c->res->redirect( $c->uri_for( "/user/$id" ) );
60 return;
61 }
62 $form->model->default_values( $user )
64 if ! $form->submitted;
65 }
67 Note: Because "process" is automatically called for you by the Catalyst
69 controller; if you make any modifications to the form within your
70 action method, such as adding or changing elements, adding constraints,
71 etc; you must call "process" again yourself before using
72 "submitted_and_valid", any of the methods listed under "SUBMITTED FORM
73 VALUES AND ERRORS" or "MODIFYING A SUBMITTED FORM", or rendering the
74 form.
75 Here's an example of a config file to create a basic login form (all
77 examples here are YAML, but you can use any format supported by
78 Config::Any), you can also create forms directly in your perl code,
79 rather than using an external config file.
80 ---
82 action: /login
83 indicator: submit
84 auto_fieldset: 1
85 elements:
87 - type: Text
88 name: user
89 constraints:
90 - Required
91 - type: Password
93 name: pass
94 constraints:
95 - Required
96 - type: Submit
98 name: submit
99 constraints:
101 - SingleValue
102
104 HTML::FormFu is a HTML form framework which aims to be as easy as
105 possible to use for basic web forms, but with the power and flexibility
106 to do anything else you might want to do (as long as it involves
107 forms).
108 You can configure almost any part of formfu's behaviour and output. By
110 default formfu renders "XHTML 1.0 Strict" compliant markup, with as
111 little extra markup as possible, but with sufficient CSS class names to
112 allow for a wide-range of output styles to be generated by changing
113 only the CSS.
114 All methods listed below (except "new") can either be called as a
116 normal method on your $form object, or as an option in your config
117 file. Examples will mainly be shown in YAML config syntax.
118 This documentation follows the convention that method arguments
120 surrounded by square brackets "[]" are optional, and all other
121 arguments are required.
122
124 new
125 Arguments: [\%options]
126 Return Value: $form
128 Create a new HTML::FormFu object.
130 Any method which can be called on the HTML::FormFu object may instead
132 be passed as an argument to "new".
133 my $form = HTML::FormFu->new({
135 action => '/search',
136 method => 'GET',
137 auto_fieldset => 1,
138 });
139 load_config_file
141 Arguments: $filename
142 Arguments: \@filenames
144 Return Value: $form
146 Accepts a filename or list of file names, whose filetypes should be of
148 any format recognized by Config::Any.
149 The content of each config file is passed to "populate", and so are
151 added to the form.
152 "load_config_file" may be called in a config file itself, so as to
154 allow common settings to be kept in a single config file which may be
155 loaded by any form.
156 ---
158 load_config_file:
159 - file1
160 - file2
161 YAML multiple documents within a single file. The document start marker
163 is a line containing 3 dashes. Multiple documents will be applied in
164 order, just as if multiple filenames had been given.
165 In the following example, multiple documents are taken advantage of to
167 load another config file after the elements are added. (If this were a
168 single document, the "load_config_file" would be called before
169 "elements", regardless of its position in the file).
170 ---
172 elements:
173 - name: one
174 - name: two
175 ---
177 load_config_file: ext.yml
178 Relative paths are resolved from the "config_file_path" directory if it
180 is set, otherwise from the current working directory.
181 See "BEST PRACTICES" for advice on organising config files.
183 config_callback
185 Arguments: \%options
186 If defined, the arguments are used to create a Data::Visitor::Callback
188 object during "load_config_file" which may be used to pre-process the
189 config before it is sent to "populate".
190 For example, the code below adds a callback to a form that will
192 dynamically alter any config value ending in ".yml" to end in ".yaml"
193 when you call "load_config_file":
194 $form->config_callback({
196 plain_value => sub {
197 my( $visitor, $data ) = @_;
198 s/\.yml/.yaml/;
199 }
200 });
201 Default Value: not defined
203 This method is a special 'inherited accessor', which means it can be
205 set on the form, a block element or a single element. When the value is
206 read, if no value is defined it automatically traverses the element's
207 hierarchy of parents, through any block elements and up to the form,
208 searching for a defined value.
209 populate
211 Arguments: \%options
212 Return Value: $form
214 Each option key/value passed may be any HTML::FormFu method-name and
216 arguments.
217 Provides a simple way to set multiple values, or add multiple elements
219 to a form with a single method-call.
220 Attempts to call the method-names in a semi-intelligent order (see the
222 source of populate() in "HTML::FormFu::ObjectUtil" for details).
223 default_values
225 Arguments: \%defaults
226 Return Value: $form
228 Set multiple field's default values from a single hash-ref.
230 The hash-ref's keys correspond to a form field's name, and the value is
232 passed to the field's default method.
233 This should be called after all fields have been added to the form, and
235 before "process" is called (otherwise, call "process" again before
236 rendering the form).
237 config_file_path
239 Arguments: $directory_name
240 "config_file_path" defines where configuration files will be searched
242 for, if an absolute path is not given to "load_config_file".
243 Default Value: not defined
245 This method is a special 'inherited accessor', which means it can be
247 set on the form, a block element or a single element. When the value is
248 read, if no value is defined it automatically traverses the element's
249 hierarchy of parents, through any block elements and up to the form,
250 searching for a defined value.
251 Is an inheriting accessor.
253 indicator
255 Arguments: $field_name
256 Arguments: \&coderef
258 If "indicator" is set to a fieldname, "submitted" will return true if a
260 value for that fieldname was submitted.
261 If "indicator" is set to a code-ref, it will be called as a subroutine
263 with the two arguments $form and $query, and its return value will be
264 used as the return value for "submitted".
265 If "indicator" is not set, "submitted" will return true if a value for
267 any known fieldname was submitted.
268 auto_fieldset
270 Arguments: 1
271 Arguments: \%options
273 Return Value: $fieldset
275 This setting is suitable for most basic forms, and means you can
277 generally ignore adding fieldsets yourself.
278 Calling "$form->auto_fieldset(1)" immediately adds a fieldset element
280 to the form. Thereafter, "$form->elements()" will add all elements
281 (except fieldsets) to that fieldset, rather than directly to the form.
282 To be specific, the elements are added to the last fieldset on the
284 form, so if you add another fieldset, any further elements will be
285 added to that fieldset.
286 Also, you may pass a hashref to auto_fieldset(), and this will be used
288 to set defaults for the first fieldset created.
289 A few examples and their output, to demonstrate:
291 2 elements with no fieldset.
293 ---
295 elements:
296 - type: Text
297 name: foo
298 - type: Text
299 name: bar
300 <form action="" method="post">
302 <div class="text">
303 <input name="foo" type="text" />
304 </div>
305 <div class="text">
306 <input name="bar" type="text" />
307 </div>
308 </form>
309 2 elements with an "auto_fieldset".
311 ---
313 auto_fieldset: 1
314 elements:
315 - type: Text
316 name: foo
317 - type: Text
318 name: bar
319 <form action="" method="post">
321 <fieldset>
322 <div class="text">
323 <input name="foo" type="text" />
324 </div>
325 <div class="text">
326 <input name="bar" type="text" />
327 </div>
328 </fieldset>
329 </form>
330 The 3rd element is within a new fieldset
332 ---
334 auto_fieldset: { id: fs }
335 elements:
336 - type: Text
337 name: foo
338 - type: Text
339 name: bar
340 - type: Fieldset
341 - type: Text
342 name: baz
343 <form action="" method="post">
345 <fieldset id="fs">
346 <div class="text">
347 <input name="foo" type="text" />
348 </div>
349 <div class="text">
350 <input name="bar" type="text" />
351 </div>
352 </fieldset>
353 <fieldset>
354 <div class="text">
355 <input name="baz" type="text" />
356 </div>
357 </fieldset>
358 </form>
359 Because of this behaviour, if you want nested fieldsets you will have
361 to add each nested fieldset directly to its intended parent.
362 my $parent = $form->get_element({ type => 'Fieldset' });
364 $parent->element('fieldset');
366 form_error_message
368 Arguments: $string
369 Normally, input errors cause an error message to be displayed alongside
371 the appropriate form field. If you'd also like a general error message
372 to be displayed at the top of the form, you can set the message with
373 "form_error_message".
374 To set the CSS class for the message, see "form_error_message_class".
376 To change the markup used to display the message, edit the
378 "form_error_message" template file. See "render_method".
379 Is an output accessor.
381 force_error_message
383 If true, forces the "form_error_message" to be displayed even if there
384 are no field errors.
385 default_args
387 Arguments: \%defaults
388 Set defaults which will be added to every element, constraint, etc. of
390 the given type which is subsequently added to the form.
391 For example, to make every "Text" element automatically have a size of
393 10, and make every "Strftime" deflator automatically get its strftime
394 set to "%d/%m/%Y":
395 default_args:
397 elements:
398 Text:
399 size: 10
400 deflators:
401 Strftime:
402 strftime: '%d/%m/%Y'
403 An example to make all DateTime elements automatically get an
405 appropriate Strftime deflator and a DateTime inflator:
406 default_args:
408 elements:
409 DateTime:
410 deflators:
411 type: Strftime
412 strftime: '%d-%m-%Y'
413 inflators:
414 type: DateTime
415 parser:
416 strptime: '%d-%m-%Y'
417 Pseudo types
419 As a special case, you can also use the "elements" keys "Block",
421 "Field" and "Input" to match any element which inherits from
422 HTML::FormFu::Element::Block or which "does"
423 HTML::FormFu::Role::Element::Field or
424 HTML::FormFu::Role::Element::Input.
425 Alternatives
427 Each "elements" key can contain an "any" list using the "|" divider:
429 e.g.
430 # apply the given class to any Element of type Password or Button
432 default_args:
433 elements:
434 'Password|Button':
435 attrs:
436 class: novalidate
437 Match ancestor
439 Each "elements" key list can contain a type starting with "+" to only
441 match elements with an ancestor of the given type: e.g.
442 # only apple the given class to an Input field within a Multi block
444 default_args:
445 elements:
446 'Input|+Multi':
447 attrs:
448 class: novalidate
449 Don't match ancestor
451 Each "elements" key list can contain a type starting with "-" to only
453 match elements who do not have an ancestor of the given type: e.g.
454 # apply the given class only to Input fields that are not in a Multi block
456 default_args:
457 elements:
458 'Input|-Multi':
459 attrs:
460 clasS: validate
461 Order
463 The arguments are applied in least- to most-specific order: "Block",
465 "Field", "Input", $type. Within each of these, arguments are applied in
466 order of shortest-first to longest-last.
467 The "type" key must match the value returned by "type", e.g. "type" in
469 HTML::FormFu::Element. If, for example, you have a custom element
470 outside of the "HTML::FormFu::Element::*" namespace, which you load via
471 "$form->element({ type => '+My::Custom::Element' })", the key given to
472 "default_args" should not include the leading "+", as that is stripped-
473 out of the returned "type()" value. Example:
474 # don't include the leading '+' here
476 default_args:
477 elements:
478 'My::Custom::Element':
479 attrs:
480 class: whatever
481 # do include the leading '+' here
483 elements:
484 - type: +My::Custom::Element
485 Clashes
487 "default_args" generates a single hashref to pass to "populate",
489 merging arguments for each type in turn - meaning "populate" is only
490 called once in total - not once for each type. Because scalar values
491 are not merged - this means later values will override earlier values:
492 e.g.
493 # Normally, calling $field->add_attrs({ class => 'input' })
495 # then calling $field->add_attrs({ class => 'not-in-multi' })
496 # would result in both values being retained:
497 # class="input not-in-multi"
498 #
499 # However, default_args() creates a single data-structure to pass once
500 # to populate(), so any scalar values will overwrite earlier ones
501 # before they reach populate().
502 #
503 # The below example would result in the longest-matching key
504 # overwriting any others:
505 # class="not-in-multi"
506 #
507 default_args:
508 elements:
509 Input:
510 add_attrs:
511 class: input
512 'Input:-Multi':
513 add_attrs:
514 class: not-in-multi
515 Strictness
517 Note: Unlike the proper methods which have aliases, for example
519 "elements" which is an alias for "element" - the keys given to
520 "default_args" must be of the plural form, e.g.:
521 default_args:
523 elements: {}
524 deflators: {}
525 filters: {}
526 constraints: {}
527 inflators: {}
528 validators: {}
529 transformers: {}
530 output_processors: {}
531 javascript
533 If set, the contents will be rendered within a "script" tag, inside the
534 top of the form.
535 javascript_src
537 Arguments: $url
538 Arguments: \@urls
540 Adds a "script" tag for each URL, immediately before any "javascript"
542 section.
543 stash
545 Arguments: [\%private_stash]
546 Return Value: \%stash
548 Provides a hash-ref in which you can store any data you might want to
550 associate with the form.
551 ---
553 stash:
554 foo: value
555 bar: value
556 elements
558 element
559 Arguments: $type
560 Arguments: \%options
562 Return Value: $element
564 Arguments: \@arrayref_of_types_or_options
566 Return Value: @elements
568 Adds a new element to the form. See "CORE FORM FIELDS" in
570 HTML::FormFu::Element and "OTHER CORE ELEMENTS" in
571 HTML::FormFu::Element for a list of core elements.
572 If you want to load an element from a namespace other than
574 "HTML::FormFu::Element::", you can use a fully qualified package-name
575 by prefixing it with "+".
576 ---
578 elements:
579 - type: +MyApp::CustomElement
580 name: foo
581 If a "type" is not provided in the "\%options", the default "Text" will
583 be used.
584 "element" is an alias for "elements".
586 deflators
588 deflator
589 Arguments: $type
590 Arguments: \%options
592 Return Value: $deflator
594 Arguments: \@arrayref_of_types_or_options
596 Return Value: @deflators
598 A deflator may be associated with any form field, and allows you to
600 provide $field->default with a value which may be an object.
601 If an object doesn't stringify to a suitable value for display, the
603 deflator can ensure that the form field receives a suitable string
604 value instead.
605 See "CORE DEFLATORS" in HTML::FormFu::Deflator for a list of core
607 deflators.
608 If a "name" attribute isn't provided, a new deflator is created for and
610 added to every field on the form.
611 If you want to load a deflator in a namespace other than
613 "HTML::FormFu::Deflator::", you can use a fully qualified package-name
614 by prefixing it with "+".
615 "deflator" is an alias for "deflators".
617 insert_before
619 Arguments: $new_element, $existing_element
620 Return Value: $new_element
622 The 1st argument must be the element you want added, the 2nd argument
624 must be the existing element that the new element should be placed
625 before.
626 my $new = $form->element(\%specs);
628 my $position = $form->get_element({ type => $type, name => $name });
630 $form->insert_before( $new, $position );
632 In the first line of the above example, the $new element is initially
634 added to the end of the form. However, the "insert_before" method
635 reparents the $new element, so it will no longer be on the end of the
636 form. Because of this, if you try to copy an element from one form to
637 another, it will 'steal' the element, instead of copying it. In this
638 case, you must use "clone":
639 my $new = $form1->get_element({ type => $type1, name => $name1 })
641 ->clone;
642 my $position = $form2->get_element({ type => $type2, name => $name2 });
644 $form2->insert_before( $new, $position );
646 insert_after
648 Arguments: $new_element, $existing_element
649 Return Value: $new_element
651 The 1st argument must be the element you want added, the 2nd argument
653 must be the existing element that the new element should be placed
654 after.
655 my $new = $form->element(\%specs);
657 my $position = $form->get_element({ type => $type, name => $name });
659 $form->insert_after( $new, $position );
661 In the first line of the above example, the $new element is initially
663 added to the end of the form. However, the "insert_after" method
664 reparents the $new element, so it will no longer be on the end of the
665 form. Because of this, if you try to copy an element from one form to
666 another, it will 'steal' the element, instead of copying it. In this
667 case, you must use "clone":
668 my $new = $form1->get_element({ type => $type1, name => $name1 })
670 ->clone;
671 my $position = $form2->get_element({ type => $type2, name => $name2 });
673 $form2->insert_after( $new, $position );
675 remove_element
677 Arguments: $element
678 Return Value: $element
680 Removes the $element from the form or block's array of children.
682 $form->remove_element( $element );
684 The orphaned element cannot be usefully used for anything until it is
686 re-attached to a form or block with "insert_before" or "insert_after".
687
689 HTML::FormFu provides several stages for what is traditionally
690 described as validation. These are:
691 HTML::FormFu::Filter
693 HTML::FormFu::Constraint
694 HTML::FormFu::Inflator
695 HTML::FormFu::Validator
696 HTML::FormFu::Transformer
697 The first stage, the filters, allow for cleanup of user-input, such as
699 encoding, or removing leading/trailing whitespace, or removing non-
700 digit characters from a creditcard number.
701 All of the following stages allow for more complex processing, and each
703 of them have a mechanism to allow exceptions to be thrown, to represent
704 input errors. In each stage, all form fields must be processed without
705 error for the next stage to proceed. If there were any errors, the form
706 should be re-displayed to the user, to allow them to input correct
707 values.
708 Constraints are intended for low-level validation of values, such as
710 "is this an integer?", "is this value within bounds?" or "is this a
711 valid email address?".
712 Inflators are intended to allow a value to be turned into an
714 appropriate object. The resulting object will be passed to subsequent
715 Validators and Transformers, and will also be returned by "params" and
716 "param".
717 Validators are intended for higher-level validation, such as business-
719 logic and database constraints such as "is this username unique?".
720 Validators are only run if all Constraints and Inflators have run
721 without errors. It is expected that most Validators will be
722 application-specific, and so each will be implemented as a separate
723 class written by the HTML::FormFu user.
724 filters
726 filter
727 Arguments: $type
728 Arguments: \%options
730 Return Value: $filter
732 Arguments: \@arrayref_of_types_or_options
734 Return Value: @filters
736 If you provide a "name" or "names" value, the filter will be added to
738 just that named field. If you do not provide a "name" or "names"
739 value, the filter will be added to all fields already attached to the
740 form.
741 See "CORE FILTERS" in HTML::FormFu::Filter for a list of core filters.
743 If you want to load a filter in a namespace other than
745 "HTML::FormFu::Filter::", you can use a fully qualified package-name by
746 prefixing it with "+".
747 "filter" is an alias for "filters".
749 constraints
751 constraint
752 Arguments: $type
753 Arguments: \%options
755 Return Value: $constraint
757 Arguments: \@arrayref_of_types_or_options
759 Return Value: @constraints
761 See "CORE CONSTRAINTS" in HTML::FormFu::Constraint for a list of core
763 constraints.
764 If a "name" attribute isn't provided, a new constraint is created for
766 and added to every field on the form.
767 If you want to load a constraint in a namespace other than
769 "HTML::FormFu::Constraint::", you can use a fully qualified package-
770 name by prefixing it with "+".
771 "constraint" is an alias for "constraints".
773 inflators
775 inflator
776 Arguments: $type
777 Arguments: \%options
779 Return Value: $inflator
781 Arguments: \@arrayref_of_types_or_options
783 Return Value: @inflators
785 See "CORE INFLATORS" in HTML::FormFu::Inflator for a list of core
787 inflators.
788 If a "name" attribute isn't provided, a new inflator is created for and
790 added to every field on the form.
791 If you want to load an inflator in a namespace other than
793 "HTML::FormFu::Inflator::", you can use a fully qualified package-name
794 by prefixing it with "+".
795 "inflator" is an alias for "inflators".
797 validators
799 validator
800 Arguments: $type
801 Arguments: \%options
803 Return Value: $validator
805 Arguments: \@arrayref_of_types_or_options
807 Return Value: @validators
809 See "CORE VALIDATORS" in HTML::FormFu::Validator for a list of core
811 validators.
812 If a "name" attribute isn't provided, a new validator is created for
814 and added to every field on the form.
815 If you want to load a validator in a namespace other than
817 "HTML::FormFu::Validator::", you can use a fully qualified package-name
818 by prefixing it with "+".
819 "validator" is an alias for "validators".
821 transformers
823 transformer
824 Arguments: $type
825 Arguments: \%options
827 Return Value: $transformer
829 Arguments: \@arrayref_of_types_or_options
831 Return Value: @transformers
833 See "CORE TRANSFORMERS" in HTML::FormFu::Transformer for a list of core
835 transformers.
836 If a "name" attribute isn't provided, a new transformer is created for
838 and added to every field on the form.
839 If you want to load a transformer in a namespace other than
841 "HTML::FormFu::Transformer::", you can use a fully qualified package-
842 name by prefixing it with "+".
843 "transformer" is an alias for "transformers".
845
847 render_processed_value
848 The default behaviour when re-displaying a form after a submission, is
849 that the field contains the original unchanged user-submitted value.
850 If "render_processed_value" is true, the field value will be the final
852 result after all Filters, Inflators and Transformers have been run.
853 Deflators will also be run on the value.
854 If you set this on a field with an Inflator, but without an equivalent
856 Deflator, you should ensure that the Inflators stringify back to a
857 usable value, so as not to confuse / annoy the user.
858 Default Value: false
860 This method is a special 'inherited accessor', which means it can be
862 set on the form, a block element or a single element. When the value is
863 read, if no value is defined it automatically traverses the element's
864 hierarchy of parents, through any block elements and up to the form,
865 searching for a defined value.
866 Is an inheriting accessor.
868 force_errors
870 Force a constraint to fail, regardless of user input.
871 If this is called at runtime, after the form has already been
873 processed, you must called "process" in HTML::FormFu again before
874 redisplaying the form to the user.
875 Default Value: false
877 This method is a special 'inherited accessor', which means it can be
879 set on the form, a block element, an element or a single constraint.
880 When the value is read, if no value is defined it automatically
881 traverses the element's hierarchy of parents, through any block
882 elements and up to the form, searching for a defined value.
883 Is an inheriting accessor.
885 params_ignore_underscore
887 If true, causes "params", "param" and "valid" to ignore any fields
888 whose name starts with an underscore "_".
889 The field is still processed as normal, and errors will cause
891 "submitted_and_valid" to return false.
892 Default Value: false
894
896 All attributes are added to the rendered form's start tag.
897 attributes
899 # Example
900 ---
901 attributes:
902 id: form
903 class: fancy_form
904 Is an attribute accessor.
906 id
908 Is an attribute short-cut.
909 action
911 Default Value: ""
912 Get or set the action associated with the form. The default is no
914 action, which causes most browsers to submit to the current URI.
915 Is an attribute short-cut.
917 enctype
919 Get or set the encoding type of the form. Valid values are
920 "application/x-www-form-urlencoded" and "multipart/form-data".
921 If the form contains a File element, the enctype is automatically set
923 to "multipart/form-data".
924 Is an attribute short-cut.
926 method
928 Default Value: "post"
929 Get or set the method used to submit the form. Can be set to either
931 "post" or "get".
932 Is an attribute short-cut.
934 title
936 Get or set the form's title attribute.
937 Is an attribute short-cut.
939
941 form_error_message_class
942 Class attribute for the error message displayed at the top of the form.
943 See "form_error_message"
945
947 languages
948 Arguments: [\@languages]
949 A list of languages which will be passed to the localization object.
951 Default Value: ['en']
953 localize_class
955 Arguments: [$class_name]
956 Classname to be used for the default localization object.
958 Default Value: 'HTML::FormFu::I18N'
960 localize
962 loc
963 Arguments: [$key, @arguments]
964 Compatible with the "maketext" method in Locale::Maketext.
966 locale
968 Arguments: $locale
969 Currently only used by HTML::FormFu::Deflator::FormatNumber and
971 HTML::FormFu::Filter::FormatNumber.
972 This method is a special 'inherited accessor', which means it can be
974 set on the form, a block element or a single element. When the value is
975 read, if no value is defined it automatically traverses the element's
976 hierarchy of parents, through any block elements and up to the form,
977 searching for a defined value.
978 Is an inheriting accessor.
980
982 query
983 Arguments: [$query_object]
984 Arguments: \%params
986 Provide a CGI compatible query object or a hash-ref of submitted
988 names/values. Alternatively, the query object can be passed directly to
989 the "process" object.
990 query_type
992 Arguments: [$query_type]
993 Set which module is being used to provide the "query".
995 The Catalyst::Controller::HTML::FormFu automatically sets this to
997 "Catalyst".
998 Valid values are "CGI", "Catalyst" and "CGI::Simple".
1000 Default Value: 'CGI'
1002 process
1004 Arguments: [$query_object]
1005 Arguments: [\%params]
1007 Process the provided query object or input values. "process" must be
1009 called before calling any of the methods listed under "SUBMITTED FORM
1010 VALUES AND ERRORS" and "MODIFYING A SUBMITTED FORM".
1011 "process" must also be called at least once before printing the form or
1013 calling "render" or "render_data".
1014 Note to users of Catalyst::Controller::HTML::FormFu: Because "process"
1016 is automatically called for you by the Catalyst controller; if you make
1017 any modifications to the form within your action method, such as adding
1018 or changing elements, adding constraints, etc; you must call "process"
1019 again yourself before using "submitted_and_valid", any of the methods
1020 listed under "SUBMITTED FORM VALUES AND ERRORS" or "MODIFYING A
1021 SUBMITTED FORM", or rendering the form.
1022
1024 submitted
1025 Returns true if the form has been submitted. See "indicator" for
1026 details on how this is computed.
1027 submitted_and_valid
1029 Shorthand for "$form->submitted && !$form->has_errors"
1030 params
1032 Return Value: \%params
1033 Returns a hash-ref of all valid input for which there were no errors.
1035 param_value
1037 Arguments: $field_name
1038 A more reliable, recommended version of "param". Guaranteed to always
1040 return a single value, regardless of whether it's called in list
1041 context or not. If multiple values were submitted, this only returns
1042 the first value. If the value is invalid or the form was not submitted,
1043 it returns "undef". This makes it suitable for use in list context,
1044 where a single value is required.
1045 $db->update({
1047 name => $form->param_value('name'),
1048 address => $form->param_value('address),
1049 });
1050 param_array
1052 Arguments: $field_name
1053 Guaranteed to always return an array-ref of values, regardless of
1055 context and regardless of whether multiple values were submitted or
1056 not. If the value is invalid or the form was not submitted, it returns
1057 an empty array-ref.
1058 param_list
1060 Arguments: $field_name
1061 Guaranteed to always return a list of values, regardless of context. If
1063 the value is invalid or the form was not submitted, it returns an empty
1064 list.
1065 param
1067 Arguments: [$field_name]
1068 Return Value: $input_value
1070 Return Value: @valid_names
1072 No longer recommended for use, as its behaviour is hard to predict. Use
1074 "param_value", "param_array" or "param_list" instead.
1075 A (readonly) method similar to that of CGI's.
1077 If a field name is given, in list-context returns any valid values
1079 submitted for that field, and in scalar-context returns only the first
1080 of any valid values submitted for that field.
1081 If no argument is given, returns a list of all valid input field names
1083 without errors.
1084 Passing more than 1 argument is a fatal error.
1086 valid
1088 Arguments: [$field_name]
1089 Return Value: @valid_names
1091 Return Value: $bool
1093 If a field name if given, returns "true" if that field had no errors
1095 and "false" if there were errors.
1096 If no argument is given, returns a list of all valid input field names
1098 without errors.
1099 has_errors
1101 Arguments: [$field_name]
1102 Return Value: @names
1104 Return Value: $bool
1106 If a field name if given, returns "true" if that field had errors and
1108 "false" if there were no errors.
1109 If no argument is given, returns a list of all input field names with
1111 errors.
1112 get_errors
1114 Arguments: [%options]
1115 Arguments: [\%options]
1117 Return Value: \@errors
1119 Returns an array-ref of exception objects from all fields in the form.
1121 Accepts both "name", "type" and "stage" arguments to narrow the
1123 returned results.
1124 $form->get_errors({
1126 name => 'foo',
1127 type => 'Regex',
1128 stage => 'constraint'
1129 });
1130 get_error
1132 Arguments: [%options]
1133 Arguments: [\%options]
1135 Return Value: $error
1137 Accepts the same arguments as "get_errors", but only returns the first
1139 error found.
1140
1142 See HTML::FormFu::Model for further details and available models.
1143 default_model
1145 Arguments: $model_name
1146 Default Value: 'DBIC'
1148 model
1150 Arguments: [$model_name]
1151 Return Value: $model
1153 model_config
1155 Arguments: \%config
1156
1158 add_valid
1159 Arguments: $name, $value
1160 Return Value: $value
1162 The provided value replaces any current value for the named field. This
1164 value will be returned in subsequent calls to "params" and "param" and
1165 the named field will be included in calculations for "valid".
1166 clear_errors
1168 Deletes all errors from a submitted form.
1169
1171 render
1172 Return Value: $string
1173 You must call "process" once after building the form, and before
1175 calling "render".
1176 start
1178 Return Value: $string
1179 Returns the form start tag, and any output of "form_error_message" and
1181 "javascript".
1182 end
1184 Return Value: $string
1185 Returns the form end tag.
1187 hidden_fields
1189 Return Value: $string
1190 Returns all hidden form fields.
1192
1194 "HTML::FormFu" provides a plugin-system that allows plugins to be
1195 easily added to a form or element, to change the default behaviour or
1196 output.
1197 See HTML::FormFu::Plugin for details.
1199
1201 By default, formfu renders "XHTML 1.0 Strict" compliant markup, with as
1202 little extra markup as possible. Many hooks are provided to add
1203 programatically-generated CSS class names, to allow for a wide-range of
1204 output styles to be generated by changing only the CSS.
1205 Basic customisation of the markup is possible via the layout and
1207 multi_layout methods. This allows you to reorder the position of
1208 various parts of each field - such as the label, comment, error
1209 messages and the input tag - as well as inserting any other arbitrary
1210 tags you may wish.
1211 If this is not sufficient, you can make completely personalise the
1213 markup by telling HTML::FormFu to use an external rendering engine,
1214 such as Template Toolkit or Template::Alloy. See "render_method" and
1215 "tt_module" for details.
1216 Even if you set HTML::FormFu to use Template::Toolkit to render, the
1218 forms, HTML::FormFu can still be used in conjunction with whichever
1219 other templating system you prefer to use for your own page layouts,
1220 whether it's HTML::Template: "<TMPL_VAR form>", Petal: "<form
1221 tal:replace="form"></form>" or Template::Magic: "<!-- {form} -->".
1222 As of "HTML::FormFu v1.00", TT is no longer listed a required
1224 prerequisite - so you'll need to install it manually if you with to use
1225 the template files.
1226 render_method
1228 Default Value: "string"
1229 Can be set to "tt" to generate the form with external template files.
1231 To customise the markup, you'll need a copy of the template files,
1233 local to your application. See "Installing the TT templates" in
1234 HTML::FormFu::Manual::Cookbook for further details.
1235 You can customise the markup for a single element by setting that
1237 element's "render_method" to "tt", while the rest of the form uses the
1238 default "string" render-method. Note though, that if you try setting
1239 the form or a Block's "render_method" to "tt", and then set a child
1240 element's "render_method" to "string", that setting will be ignored,
1241 and the child elements will still use the "tt" render-method.
1242 ---
1244 elements:
1245 - name: foo
1246 render_method: tt
1247 filename: custom_field
1248 - name: bar
1250 # in this example, 'foo' will use a custom template,
1252 # while bar will use the default 'string' rendering method
1253 This method is a special 'inherited accessor', which means it can be
1255 set on the form, a block element or a single element. When the value is
1256 read, if no value is defined it automatically traverses the element's
1257 hierarchy of parents, through any block elements and up to the form,
1258 searching for a defined value.
1259 Is an inheriting accessor.
1261 filename
1263 Change the template filename used for the form.
1264 Default Value: "form"
1266 tt_args
1268 Arguments: [\%constructor_arguments]
1269 Accepts a hash-ref of arguments passed to "render_method", which is
1271 called internally by "render".
1272 Within tt_args, the keys "RELATIVE" and "RECURSION" are overridden to
1274 always be true, as these are a basic requirement for the Template
1275 engine.
1276 The system directory containing HTML::FormFu's template files is always
1278 added to the end of "INCLUDE_PATH", so that the core template files
1279 will be found. You only need to set this yourself if you have your own
1280 copy of the template files for customisation purposes.
1281 This method is a special 'inherited accessor', which means it can be
1283 set on the form, a block element or a single element. When the value is
1284 read, if no value is defined it automatically traverses the element's
1285 hierarchy of parents, through any block elements and up to the form,
1286 searching for a defined value.
1287 add_tt_args
1289 Arguments: [\%constructor_arguments]
1290 Ensures that the hash-ref argument is merged with any existing hash-ref
1292 value of "tt_args".
1293 tt_module
1295 Default Value: Template
1296 The module used when "render_method" is set to "tt". Should provide an
1298 interface compatible with Template.
1299 This method is a special 'inherited accessor', which means it can be
1301 set on the form, a block element or a single element. When the value is
1302 read, if no value is defined it automatically traverses the element's
1303 hierarchy of parents, through any block elements and up to the form,
1304 searching for a defined value.
1305 render_data
1307 Usually called implicitly by "render". Returns the data structure that
1308 would normally be passed onto the "string" or "tt" render-methods.
1309 As with "render", you must call "process" once after building the form,
1311 and before calling "render_data".
1312 render_data_non_recursive
1314 Like "render_data", but doesn't include the data for any child-
1315 elements.
1316
1318 get_fields
1319 Arguments: [%options]
1320 Arguments: [\%options]
1322 Return Value: \@elements
1324 Returns all fields in the form (specifically, all elements which have a
1326 true "is_field" in HTML::FormFu::Element value).
1327 Accepts both "name" and "type" arguments to narrow the returned
1329 results.
1330 $form->get_fields({
1332 name => 'foo',
1333 type => 'Radio',
1334 });
1335 Accepts also an Regexp to search for results.
1337 $form->get_elements({
1339 name => qr/oo/,
1340 });
1341 get_field
1343 Arguments: [%options]
1344 Arguments: [\%options]
1346 Return Value: $element
1348 Accepts the same arguments as "get_fields", but only returns the first
1350 field found.
1351 get_elements
1353 Arguments: [%options]
1354 Arguments: [\%options]
1356 Return Value: \@elements
1358 Returns all top-level elements in the form (not recursive). See
1360 "get_all_elements" for a recursive version.
1361 Accepts both "name" and "type" arguments to narrow the returned
1363 results.
1364 $form->get_elements({
1366 name => 'foo',
1367 type => 'Radio',
1368 });
1369 Accepts also an Regexp to search for results.
1371 $form->get_elements({
1373 name => qr/oo/,
1374 });
1375 get_element
1377 Arguments: [%options]
1378 Arguments: [\%options]
1380 Return Value: $element
1382 Accepts the same arguments as "get_elements", but only returns the
1384 first element found.
1385 See "get_all_element" for a recursive version.
1387 get_all_elements
1389 Arguments: [%options]
1390 Arguments: [\%options]
1392 Return Value: \@elements
1394 Returns all elements in the form recursively.
1396 Optionally accepts both "name" and "type" arguments to narrow the
1398 returned results.
1399 # return all Text elements
1401 $form->get_all_elements({
1403 type => 'Text',
1404 });
1405 Accepts also an Regexp to search for results.
1407 $form->get_elements({
1409 name => qr/oo/,
1410 });
1411 See "get_elements" for a non-recursive version.
1413 get_all_element
1415 Arguments: [%options]
1416 Arguments: [\%options]
1418 Return Value: $element
1420 Accepts the same arguments as "get_all_elements", but only returns the
1422 first element found.
1423 # return the first Text field found, regardless of whether it's
1425 # within a fieldset or not
1426 $form->get_all_element({
1428 type => 'Text',
1429 });
1430 Accepts also an Regexp to search for results.
1432 $form->get_elements({
1434 name => qr/oo/,
1435 });
1436 See "get_all_elements" for a non-recursive version.
1438 get_deflators
1440 Arguments: [%options]
1441 Arguments: [\%options]
1443 Return Value: \@deflators
1445 Returns all top-level deflators from all fields.
1447 Accepts both "name" and "type" arguments to narrow the returned
1449 results.
1450 $form->get_deflators({
1452 name => 'foo',
1453 type => 'Strftime',
1454 });
1455 get_deflator
1457 Arguments: [%options]
1458 Arguments: [\%options]
1460 Return Value: $element
1462 Accepts the same arguments as "get_deflators", but only returns the
1464 first deflator found.
1465 get_filters
1467 Arguments: [%options]
1468 Arguments: [\%options]
1470 Return Value: \@filters
1472 Returns all top-level filters from all fields.
1474 Accepts both "name" and "type" arguments to narrow the returned
1476 results.
1477 $form->get_filters({
1479 name => 'foo',
1480 type => 'LowerCase',
1481 });
1482 get_filter
1484 Arguments: [%options]
1485 Arguments: [\%options]
1487 Return Value: $filter
1489 Accepts the same arguments as "get_filters", but only returns the first
1491 filter found.
1492 get_constraints
1494 Arguments: [%options]
1495 Arguments: [\%options]
1497 Return Value: \@constraints
1499 Returns all constraints from all fields.
1501 Accepts both "name" and "type" arguments to narrow the returned
1503 results.
1504 $form->get_constraints({
1506 name => 'foo',
1507 type => 'Equal',
1508 });
1509 get_constraint
1511 Arguments: [%options]
1512 Arguments: [\%options]
1514 Return Value: $constraint
1516 Accepts the same arguments as "get_constraints", but only returns the
1518 first constraint found.
1519 get_inflators
1521 Arguments: [%options]
1522 Arguments: [\%options]
1524 Return Value: \@inflators
1526 Returns all inflators from all fields.
1528 Accepts both "name" and "type" arguments to narrow the returned
1530 results.
1531 $form->get_inflators({
1533 name => 'foo',
1534 type => 'DateTime',
1535 });
1536 get_inflator
1538 Arguments: [%options]
1539 Arguments: [\%options]
1541 Return Value: $inflator
1543 Accepts the same arguments as "get_inflators", but only returns the
1545 first inflator found.
1546 get_validators
1548 Arguments: [%options]
1549 Arguments: [\%options]
1551 Return Value: \@validators
1553 Returns all validators from all fields.
1555 Accepts both "name" and "type" arguments to narrow the returned
1557 results.
1558 $form->get_validators({
1560 name => 'foo',
1561 type => 'Callback',
1562 });
1563 get_validator
1565 Arguments: [%options]
1566 Arguments: [\%options]
1568 Return Value: $validator
1570 Accepts the same arguments as "get_validators", but only returns the
1572 first validator found.
1573 get_transformers
1575 Arguments: [%options]
1576 Arguments: [\%options]
1578 Return Value: \@transformers
1580 Returns all transformers from all fields.
1582 Accepts both "name" and "type" arguments to narrow the returned
1584 results.
1585 $form->get_transformers({
1587 name => 'foo',
1588 type => 'Callback',
1589 });
1590 get_transformer
1592 Arguments: [%options]
1593 Arguments: [\%options]
1595 Return Value: $transformer
1597 Accepts the same arguments as "get_transformers", but only returns the
1599 first transformer found.
1600 clone
1602 Returns a deep clone of the <$form> object.
1603 Because of scoping issues, code references (such as in Callback
1605 constraints) are copied instead of cloned.
1606
1608 For the basic method, e.g. "/attributes":
1609 Arguments: [%attributes]
1611 Arguments: [\%attributes]
1613 Return Value: $form
1615 As a special case, if no arguments are passed, the attributes hash-ref
1617 is returned. This allows the following idioms.
1618 # set a value
1620 $form->attributes->{id} = 'form';
1621 # delete all attributes
1623 %{ $form->attributes } = ();
1624 All methods documented as 'attribute accessors' also have the following
1626 variants generated:
1627 *_xml can be used as a setter, and ensures that its argument is not
1629 XML-escaped in the rendered form.
1630 *_loc can he used as a setter, and passes the arguments through
1632 "localize".
1633 "add_*" can be used to append a word to an attribute without
1635 overwriting any already-existing value.
1636 # Example
1638 $form->attributes({ class => 'fancy' });
1639 $form->add_attributes({ class => 'pants' });
1640 # class="fancy pants"
1641 "add_*_xml", like "add_*", but ensures it doesn't get XML-escaped.
1643 "add_*_loc", like "add_*", but passing the arguments through
1645 "localize".
1646 "del_*" can be used to remove a word from an attribute value.
1648 # Example
1650 $form->attributes({ class => 'fancy pants' });
1651 $form->del_attributes({ class => 'pants' });
1652 # class="fancy"
1653 "del_*_xml", like "del_*", but ensures it doesn't get XML-escaped.
1655 "del_*_loc", like "del_*", but passing the arguments through
1657 "localize".
1658 Also, any attribute method-name which contains the word "attributes"
1660 also has aliases created for all these variants, with the word
1661 "attributes" replaced by "attrs".
1662 # For example, the attributes() method would have all these variant
1664 # methods available
1665 $form->attributes({ class => 'fancy' });
1667 $form->attributes_xml({ title => '<b>fancy</b>' });
1668 $form->attributes_loc({ title => 'fancy' });
1669 $form->add_attributes({ class => 'fancy' });
1670 $form->add_attributes_xml({ title => '<b>fancy</b>' });
1671 $form->add_attributes_loc({ title => 'fancy' });
1672 $form->del_attributes({ class => 'fancy' });
1673 $form->del_attributes_xml({ title => '<b>fancy</b>' });
1674 $form->del_attributes_loc({ title => 'fancy' });
1675 # Because the method contains the word 'attributes', it also gets the
1677 # following short-forms
1678 $form->attrs({ class => 'fancy' });
1680 $form->attrs_xml({ title => '<b>fancy</b>' });
1681 $form->attrs_loc({ title => 'fancy' });
1682 $form->add_attrs({ class => 'fancy' });
1683 $form->add_attrs_xml({ title => '<b>fancy</b>' });
1684 $form->add_attrs_loc({ title => 'fancy' });
1685 $form->del_attrs({ class => 'fancy' });
1686 $form->del_attrs_xml({ title => '<b>fancy</b>' });
1687 $form->del_attrs_loc({ title => 'fancy' });
1688
1690 All methods documented as 'attribute short-cuts' are short-cuts to
1691 directly access individual attribute key/values.
1692 # Example
1694 $form->id( 'login' );
1695 $id = $form->id;
1696 # is equivalent to:
1698 $form->attributes({ id => 'login' });
1699 $id = $form->attributes->{id};
1700 All attribute short-cuts also have a *_xml variant.
1702 # Example
1704 $form->id_xml( $xml );
1705 # is equivalent to:
1707 $form->attributes_xml({ id => $xml });
1708 All attribute short-cuts also have a *_loc variant.
1710 # Example
1712 $form->title_loc( $key );
1713 # is equivalent to:
1715 $form->attributes_loc({ title => $key });
1716
1718 All methods documented as 'inheriting accessors' can be set on the
1719 form, a block element or a single field element. When the value is
1720 read, if no value is defined it automatically traverses the element's
1721 hierarchy of parents, searching for a defined value.
1722 All inherited accessors also have a *_no_inherit variant, which can be
1724 used as a getter to fetch any defined value, without traversing the
1725 hierarchy of parents. This variant cannot be used as a setter.
1726 E.g., the "auto_id" has a variant named "auto_id_no_inherit".
1728
1730 All methods documented as 'output accessors' also have *_xml and *_loc
1731 variants.
1732 The *_xml variant can be used as a setter, and ensures that its
1734 argument is not XML-escaped in the rendered form.
1735 The *_loc variant can be used as a setter, and passes the arguments
1737 through "localize".
1738 E.g., the label method has variants named "label_xml" and "label_loc".
1740
1742 To support boolean attributes, whose value should either be equal to
1743 the attribute name, or empty. Any true value will switch the attribute
1744 'on', any false value will remove the attribute.
1745 # Example
1747 $field->autofocus(1);
1749 # equivalent to:
1750 $field->attributes({ autofocus => 'autofocus' });
1751 $field->autofocus(0);;
1753 # equivalent to:
1754 delete $field->attributes->{autofocus};
1755
1757 Some attributes support character substitutions: the following
1758 substitutions are possible:
1759 %f # $form->id
1761 %n # $field->name
1762 %t # lc( $field->type )
1763 %r # $block->repeatable_count
1764 %s # $error->stage
1765 These allow each field to have consistent attributes, while remaining
1767 unique.
1768
1770 We try our best to not make incompatible changes, but if they're
1771 required we'll make every effort possible to provide backwards
1772 compatibility for several release-cycles, issuing a warnings about the
1773 changes, before removing the legacy features.
1774
1776 "v1.00" dropped most of the default HTML class-names, with the
1777 intention that each application should define just what it needs,
1778 without needing to reset unwanted options first. We also gain the
1779 benefit of less markup being generated, speeding up both render and
1780 HTTP transfers.
1781 To restore the previous behaviour, set the following options.
1783 If you're using best practices, you'll only need to set these once per-
1785 application in your app-wide config file.
1786 ---
1788 auto_container_class: '%t'
1789 auto_container_label_class: 'label'
1790 auto_container_comment_class: 'comment'
1791 auto_comment_class: 'comment'
1792 auto_container_error_class: 'error'
1793 auto_container_per_error_class: 'error_%s_%t'
1794 auto_error_class: 'error_message error_%s_%t'
1795
1797 See "DEPRECATED METHODS" in HTML::FormFu::Role::Element::Field.
1798
1800 See also "REMOVED METHODS" in HTML::FormFu::Element.
1801 element_defaults
1803 Has been removed; see "default_args" instead.
1804 model_class
1806 Has been removed; use "default_model" instead.
1807 defaults_from_model
1809 Has been removed; use "default_values" in HTML::FormFu::Model instead.
1810 save_to_model
1812 Has been removed; use "update" in HTML::FormFu::Model instead.
1813
1815 It is advisable to keep application-wide (or global) settings in a
1816 single config file, which should be loaded by each form.
1817 See "load_config_file".
1819
1821 HTML::FormFu::Manual::Cookbook
1822 UNICODE
1824 HTML::FormFu::Manual::Unicode
1825
1827 vertically-aligned CSS
1828 The distribution directory "examples/vertically-aligned" contains a
1829 form with example CSS for a "vertically aligned" theme.
1830 This can be viewed by opening the file "vertically-aligned.html" in a
1832 web-browser.
1833 If you wish to experiment with making changes, the form is defined in
1835 file "vertically-aligned.yml", and the HTML file can be updated with
1836 any changes by running the following command (while in the distribution
1837 root directory).
1838 perl examples/vertically-aligned/vertically-aligned.pl
1840 This uses the Template Toolkit file "vertically-aligned.tt", and the
1842 CSS is defined in files "vertically-aligned.css" and
1843 "vertically-aligned-ie.css".
1844
1846 Project Page:
1847 <http://code.google.com/p/html-formfu/>
1849 Mailing list:
1851 <http://lists.scsys.co.uk/cgi-bin/mailman/listinfo/html-formfu>
1853 Mailing list archives:
1855 <http://lists.scsys.co.uk/pipermail/html-formfu/>
1857 IRC:
1859 "irc.perl.org", channel "#formfu"
1861 The HTML::Widget archives
1863 <http://lists.scsys.co.uk/pipermail/html-widget/> between January and
1864 May 2007 also contain discussion regarding HTML::FormFu.
1865
1867 Please submit bugs / feature requests to
1868 <https://github.com/FormFu/HTML-FormFu/issues> (preferred) or
1869 <http://rt.perl.org>.
1870
1872 To help patches be applied quickly, please send them to the mailing
1873 list; attached, rather than inline; against subversion, rather than a
1874 cpan version (run "svn diff > patchfile"); mention which svn version
1875 it's against. Mailing list messages are limited to 256KB, so gzip the
1876 patch if necessary.
1877
1879 This module's sourcecode is maintained in a git repository at
1880 <git://github.com/FormFu/HTML-FormFu.git>
1881 The project page is <https://github.com/FormFu/HTML-FormFu>
1883
1885 HTML::FormFu::Imager
1886 Catalyst::Controller::HTML::FormFu
1888 HTML::FormFu::Model::DBIC
1890
1892 Brian Cassidy
1893 Ozum Eldogan
1895 Ruben Fonseca
1897 Ronald Kimball
1899 Daisuke Maki
1901 Andreas Marienborg
1903 Mario Minati
1905 Steve Nolte
1907 Moritz Onken
1909 Doug Orleans
1911 Matthias Dietrich
1913 Dean Hamstead
1915 Karen Etheridge
1917 Nigel Metheringham
1919 Based on the original source code of HTML::Widget, by Sebastian Riedel,
1921 "sri@oook.de".
1922
1924 Carl Franks <cpan@fireartist.com>
1925
1927 This software is copyright (c) 2018 by Carl Franks.
1928 This is free software; you can redistribute it and/or modify it under
1930 the same terms as the Perl 5 programming language system itself.
1931perl v5.32.0 2020-07-28 HTML::FormFu(3)