Free sale form software for linux

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.

PloneFormGen provides a generic Plone form generator using fields, widgets and validators from Archetypes.

Actions like mailing or saving form input are incorporated by included plug-in adapters.

This product provides a generic Plone form generator using fields, widgets and validators from Archetypes. It makes it possible to build simple contact, information-gathering or data-entry forms through Plones interface.

To use it, create a form folder, then add form fields as contents. Individual fields can display and validate themselves for testing purposes. The form folder creates a form from all the contained field content objects.

Final disposition of form input is handled via plug in action products. Action adapters included with this release include a mailer and a save-data adapter that saves input in tab-separated format for later download. When you first add a form folder, its configured as simple response form with input mailed to the owner.

Since PloneFormGenerator uses Archetypes fields, widgets and validators, its also a good tool for rapidly prototyping forms intended for use with Archetypes-derived content types.

Tie::FormA is a Perl module that can access a machine readable database file that minics a hardcopy form.

SYNOPSIS

require Tie::FormA;

#####
# Using support methods and file handle with
# the file subroutines such as open(), readline()
# print(), close()
#
tie *FORM_FILEHANDLE, Tie::FormA, @options
$form = tied *FORM_FILEHANDLE;

#####
# Using support methods only, no file subroutines
#
$form = Tie::Form->new(@options);

$encoded_fields = $form->decode_record($record);
@fields = $form->decode_field($encoded_fields);

$encoded_fields = $form->encode_field (@fields);
$record = $form->encode_record($encoded_fields);

$record = $form->get_record();

####
# Subroutine interface
#
$encoded_fields = decode_record($record);
@fields = decode_field($encoded_fields);

$encoded_fields = encode_field (@fields);
$record = encode_record($encoded_fields);
If a subroutine or method will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}.

The Tie::FormA module provides a text database file suitable for local data such as private mailing lists. The Tie::FormA cannot provide a data warehouse shared by mulitple users.

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.

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.

jsVal is a JavaScript form validation framework.
jsVal is a JavaScript program used for validating HTML Forms on the client side. This allows HTML forms to be validated in the browser without having to send a request to a sever (PHP, ASP, Perl...).
jsVals saves you from having to write complicated validations on server side as well as helping you avoid having to rebuild and repopulate the form when validation fails.
The advantage versus other client side HTML form validators is the ease of use and flexibility youll gain. jsVal fits the needs for most HTML Forms, and can be also easily be integrated with existing HTML Forms.
jsVal was originaly written by Karl Seguin and is now maintained by Timo Haberkern.
Enhancements:
- A bug in which the last character in a regular expression is consumed was fixed.
- The email regular expression was improved so German umlaut-domains now work.

Web Form Factory is a simple application that binds HTML forms to a database. It analyzes the HTML file you supply and identifies all the common input types it contains, including text fields, drop down lists, checkboxes, radio buttons, and text areas.
Once all the input types have been detected, it then performs some validation tests that ensures that enough information is contained within the HTML form to allow the program to bind the inputs properly. It then generates the required backend PHP code and returns the form back to the you in a zip file.
Enhancements:
- Form Validation Capabilities were added.
- The user can easily specify which fields are mandatory, and the location and appearance of error messages can be configured.
- A new Tag engine was added.
- Tags can be used to make form generation even simpler and faster by eliminating repetitive form coding tasks.