Free html forms software for linux

Rose::HTML::Form is a HTML form base class.

SYNOPSIS

package PersonForm;

use Rose::HTML::Form;
our @ISA = qw(Rose::HTML::Form);

use Person;

sub build_form
{
my($self) = shift;

$self->add_fields
(
name => { type => text, size => 25, required => 1 },
email => { type => email, size => 50, required => 1 },
phone => { type => phone },
);
}

sub validate
{
my($self) = shift;

# Base class will validate individual fields in isolation,
# confirming that all required fields are filled in, and that
# the email address and phone number are formatted correctly.
my $ok = $self->SUPER::validate(@_);
return $ok unless($ok);

# Inter-field validation goes here
if($self->field(name)->internal_value ne John Doe &&
$self->field(phone)->internal_value =~ /^555/)
{
$self->error(Only John Doe can have a 555 phone number.);
return 0;
}

return 1;
}

sub init_with_person # give a friendlier name to a base-class method
{
my($self, $person) = @_;
$self->init_with_object($person);
}

sub person_from_form
{
my($self) = shift;

# Base class method does most of the work
my $person = $self->object_from_form(class => Person);

# Now fill in the non-obvious details...
# e.g., set alt phone to be the same as the regular phone
$person->alt_phone($self->field(phone)->internal_value);

return $person;
}

...

#
# Sample usage in a hypothetical web application
#

$form = PersonForm->new;

if(...)
{
# Get query parameters in a hash ref and pass to the form
my $params = MyWebServer->get_query_params();
$form->params($params);

# ...or initialize form params from a CGI object
# $form->params_from_cgi($cgi); # $cgi "isa" CGI

# ...or initialize params from an Apache request object
# (mod_perl 1 and 2 both supported)
# $form->params_from_apache($r);

# Initialize the fields based on params
$form->init_fields();

unless($form->validate)
{
return error_page(error => $form->error);
}

$person = $form->person_from_form; # $person is a Person object

do_something_with($person);
...
}
else
{
$person = ...; # Get or create a Person object somehow

# Initialize the form with the Person object
$form->init_with_person($person);

# Pass the initialized form object to the template
display_page(form => $form);
}
...

Rose::HTML::Form is more than just an object representation of the HTML tag. It is meant to be a base class for custom form classes that can be initialized with and return "rich" values such as objects, or collections of objects.

Building up a reusable library of form classes is extremely helpful when building large web applications with forms that may appear in many different places. Similar forms can inherit from a common subclass, and forms may be nested.

This class inherits from, and follows the conventions of, Rose::HTML::Object. Inherited methods that are not overridden will not be documented a second time here. See the Rose::HTML::Object documentation for more information.

HTML Objects is a Perl module library for turning HTML tags into Perl objects. HTML Objects allows Web pages to be manipulated as a data structure rather than text.

Once manipulation is done, the entire page is generated via depth-first recursion.

HTML::FromText is a Perl module that can convert plain text to HTML.

SYNOPSIS

use HTML::FromText;
text2html( $text, %options );

# or

use HTML::FromText ();
my $t2h = HTML::FromText->new( %options );
my $html = $t2h->parse( $html );

HTML::FromText converts plain text to HTML. There are a handfull of options that shape the conversion. There is a utility function, text2html, thats exported by default. This function is simply a short- cut to the Object Oriented interface described in detail below.

HTML Code Convert helps speed up the conversion of HTML code into different format including Java Script, JavaServer Pages, Microsoft ASP, PHP, Perl, Python, and the UNIX Shell. It is particularly useful in CGI scripting.
Enhancements:
- Colors and font selected in prefeferences box.
- Fixe bug with Quit button. First try to support accessibility.
- Updated schemas.

IPv4 form provides a tool for making RIPE IPv4 request forms.

IPv4 form is a utility for checking the #ADDRESSING PLAN# part of a RIPE IPv4 PA request form. It makes a "totals:" row for this form and produces readable output with spaces between columns. This output can be directly copied to a RIPE form.

Pieforms project provides a simple, unified way to create, validate and process forms all with a common look and feel, with support for pluggable elements, renderers and validation rules.

Huh? What does all that mean?

In simple terms, Pieforms provides a library for building HTML forms. So rather than writing all that HTML yourself for building forms, handling the validation and processing of them in whatever messy, inconsistent way youre doing it currently, you simply define a big hash in your script that describes your form. Pieforms does all of the legwork involved with building the form HTML from this hash (using elements and renderers), and also handles the validation of input using rules. In the general case, after youve defined you form, all you need to do is write a callback function that gets called when the form has been submitted with the data valid according to the rules.

Sounds interesting! Show me an example...

Okay, so youre writing a simple form that has a standard < input type="text" > and a textarea on it, with a submit button. Youd write a script similar to the following:

require_once(pieform.php);
$form = array(
name => myform,
method => get,
elements => array(
text => array(
type => text,
title => Text Element,
description => A little text box for you
rules => array(
required => true
)
),
textarea => array(
type => textarea,
title => Textarea,
defaultvalue => Some default text for the textarea,
rows => 7,
cols => 50
),
submit => array(
type => submit,
value => Submit form!
)
)
);

echo pieform($form);

function myform_submit($values) {
echo "Your submitted values:< br >";
foreach ($values as $key => $value) {
echo "$key: $value< br> ";
}
}

You see how easy that is? You didnt have to write any HTML - in fact, the entire definition is in PHP, which means if you make mistakes theyll show up as parse errors, rather than HTML validity errors (which are generally less often checked for). You only called one function to have everything done for you. And you can write a function to handle submission, full well knowing that the text element will always have a value that isnt the empty string.

After that, the submnit function is almost academic. You just save whatever you want to the database or whatever, and then the last thing you should do is redirect the user somewhere, perhaps to the same page or perhaps elsewhere.

For AJAX forms, all you have to do is add ajaxpost => true in the $form array, and then make your submit function output JSON in the form {error: [false or true], message: some message}, and then exit. Pieforms includes an implementation of json_encode for your convenience.

Okay, that looks easy! What else can it do?

The best part is that the elements, renderers and rules for your forms are pluggable. For example, you could write a wysiwyg element which behaves like the textarea one, but also includes javascript necessary to turn the textarea into a full WYSIWYG editor. Or you could write an element with two select boxes, arrows to move items left and right, and AJAX searching of the boxes. The possibilities are limitless! You can also write your own rules for reuse later (and change how elements respond to those rules if necessary), and write your own renderers (which handle the HTML surrounding the elements), so you can do things like add a little help icon next to each element with a link to a page explaining how the element works.

Pod::Html is a Perl module to convert pod files to HTML.

SYNOPSIS

use Pod::Html;
pod2html([options]);

Converts files from pod format (see perlpod) to HTML format. It can automatically generate indexes and cross-references, and it keeps a cache of things it knows how to cross-reference.

NeverForms is a collection of functions that helps with HTML form manipulation. The project interfaces MySQL tables to an HTML form.

The purpose is to provide abstraction of the database schema from the PHP code. Some inspiration came from Ruby Scaffold.