Free can perform software for linux

AxKit::XSP::PerForm is an XSP Taglib for making complex forms easy.

SYNOPSIS

AxAddXSPTaglib AxKit::XSP::PerForm

PerForm is a large and complex taglib for AxKit XSP that facilitates creating large and complex HTML, WML, or other types of data-entry forms. PerForm tends to make life easier for you if your form data is coming from different data sources, such as DBI, or even XML.

PerForm works as an XSP taglib, meaning you simply add some custom XML tags to your XSP page, and PerForm does the rest. Well, almost... PerForm works mainly by callbacks, as you will see below.

EXAMPLE FORM

Ignoring the outside XSP and namespace declarations, assuming the prefix "f" is bound to the PerForm namespace:

< f:form name="add_user" >
First name: < f:textfield name="firstname" width="30" maxlength="50"/ >
< br / >
Last name: < f:textfield name="lastname" width="30" maxlength="50"/ >
< br / >
< f:submit name="save" value="Save" goto="users.xsp" / >
< f:cancel name="cancel" value="Cancel" goto="home.html" / >
< /f:form >

Now it is important to bear in mind that this is just the form, and alone it is fairly useless. You also need to add callbacks. Youll notice with each of these callbacks you recieve a $ctxt object. This is simply an empty hash-ref that you can use in the callbacks to maintain state. Actually "empty" is an exhageration - it contains two entries always: Form and Apache. "Form" is a simply a hashref of the entries in the form (actually it is an Apache::Table object, which allows for supporting multi-valued parameters). So for example, the firstname below is in $ctxt-{Form}{firstname} >. "Apache" is the $r apache request object for the current request, which is useful for access to the URI or headers.

sub validate_firstname {
my ($ctxt, $value) = @_;
$value =~ s/^s*//;
$value =~ s/s*$//;
die "No value" unless $value;
die "Invalid firstname - non word character not allowed"
if $value =~ /W/;
}

sub validate_lastname {
return validate_firstname(@_);
}

sub submit_save {
my ($ctxt) = @_;
# save values to a database
warn("User: ", $ctxt->{Form}{firstname}, " ", $ctxt->{Form}{lastname}, "n");
}

Now these methods need to be global to your XSP page, rather than "closures" within the XSP pages main handler routine. How do you do that? Well its simple. Just put them within a < xsp:logic > section before any user defined tags. For example, if your XSP page happens to use XHTML as its basic format (something I do a lot), your page might be constructed as follows (namespace declarations omitted for brevity):

< xsp:page >
< xsp:logic >
... form logic here ...
< /xsp:logic >

< html >
< head >< title >An Example Form< /title >< /head >
< body >
< h1 >An Example Form< /h1 >
< f:form >
... form definition here ...
< /f:form >
< /body >
< /html >
< /xsp:page >

[Note that the page-global methods is a useful technique in other situations, because unlike Apache::Registry scripts, this wont create a closure from methods defined there].

PacKommander is a GUI wrapper for the pacman package manager of Arch Linux.
It is my very first Kommander script; but it does the job pretty well. Use it to install, upgrade, search, remove, query packages (local or repository) as well as synchronize database, upgrade system and clear file cache.
Main features:
- Quite light-weight and fast.
- Can perform almost all the tasks that CLI pacman can do. This includes install /upgrade /remove /query /view details /search packages both from server repositories as well as local packages in hard disk.
- Can be (in fact, must be) started as normal user to perform non-admin tasks like search/query pacakges. Root privilege is sought for automatically (using gksudo) as and when required (e.g. to install/remove packages).
- Can handle multiple packages at a time using a Package Queue system. Essentially, a list of queued packages is shown (packages can be added/removed from queue), from where you can select and manipulate multiple packages.
- Certain tasks like Upgrading entire system, syncing database with server, clearing cache, optimizing pacman, etc can be done by a click of a button.
- Hand-editing of certain configuration files is also supported using nano editor in xterm.
- Every task is actually carried out by pacman. The progress can be seen in the external xterm window and the user has to interact with it limitedly (for confirmations, etc.)
- The UI is fully configurable using Kommander-editor.

THC-LEAPcracker suite contains tools to break the NTChallengeResponse encryption technique e.g. used by Cisco Wireless LEAP Authentication.

Also tools for spoofing challenge-packets from Access Points are included, so you are able to perform dictionary attacks against all users.

ManyEars project makes use of an array of microphones to perform sound source localization, tracking, and separation.

It is designed to provide auditory capabilities to mobile robots, but it can equally be used for video conferencing or other applications. The project is based on the FlowDesigner development environment.

crops project helps with previewing and printing non-Latin1 characters in PostScript files.
Main features:
- perform arbitrary font remappings (substitutions) in a PostScript document
- help you print non-latin1 encoded documents, by downloading and recoding fonts

Balder2D is a 2D shooter in Zero gravity.

Balder2D uses SDL, with the SDL_image, SDL_mixer, Guichan, GNE, and Boost Filesystem libraries.

You will need to install these to build/run the program. Balder2D also requires Python for the AI to work. The source for Balder 2D is available in the "balder2d" module in cvs.

In Balder2D, players control small probes which shoot tiny projectiles with which they try to destroy each other. It features a 2D overhead view of the playing field. Probes may be human or computer controlled.

A probe can perform the following actions:

rotate
fire projectiles
"stick" to a wall
push off of a wall

If a probe is not in "stick" mode (ie, the stick/push key is not being held down), it will bounce off of walls.

If a probe is in "stick" mode, when it hits a wall it will stop. The player may then turn the probe to point in a new direction and "push off" of the wall (by holding, and then releasing the stick/push key), propelling the probe in that new direction.

Players may rotate their probes while in flight, but the only way to change the direction or speed of flight is by firing projectiles (which gives a small kick in the opposite direction)or by running into walls or other probes.

Probes have a limited number of projectiles that can be fired in a given time; there is a maximum ammo capacity, which has a finite recharge rate.

Atlantis Installer is an installation wizard built to simplify installing PHP-GTK2 applications on multiple platforms as an alternate solution to using PEAR. Atlantis Installer allows you to build your application with the structure you want and drop it nicely as one package.

However not limited to installing PHP-GTK2 applications, this installer does require that PHP and GTK2 libraries be installed. To use this for non PHP-GTK2 apps, the end user would have first install the Gnope package (Windows) or install PHP, GTK2, and the PHP module manually (Linux). This is something someone looking to run PHP-GTK2 apps has probably already done, and hopefully in the future Linux distributions will come prepared for PHP like most do with Perl and/or Python.

The standard setup of the installer works like this. Upon launch it greets the user, prompts them to click next. Then it asks for the location the user would like to install, and then click next. It then installs the package and outputs the status live in the output box. Though configuration you can set default paths and change the look of the installer.

With scripting you can perform additional tasks during the actual install step (like if you need to chmod or rename a file). The installer automaticly checks if it can install to the directory the user specified, and if it can then it creates the necessary directory structure.