Free application software for linux

OpenPlugin::Application is a subclass of CGI::Application, meant to help you create reusable web applications.

SYNOPSIS

# Example from OpenThoughts Demo.pm

package Demo;
use base "OpenPlugin::Application";
sub setup {
my $self = shift;
$self->run_modes(
mode1 => init_demo,
mode2 => get_os_list,
mode3 => get_os_info,
);
$self->start_mode( mode1 );
$self->mode_param(run_mode);
}
sub init_demo { ... }
sub get_os_list { ... }
sub get_os_info { ... }
1;

# Example from OpenThoughts demo.pl

#!/usr/bin/perl -wT
use strict;
my $r = shift;
my $demo = Demo->new( PARAMS => {
config => { src => "/path/to/OpenPlugin.conf" },
request => { apache => $r },
});

$demo->run();

OpenPlugin::Application is built on Jesse Erlbaums popular CGI::Application module. OpenPlugin::Application is simply a subclass of CGI::Application. Jesse says the following about CGI::Application:

"CGI::Application is intended to make it easier to create sophisticated, reusable web-based applications. This module implements a methodology which, if followed, will make your web software easier to design, easier to document, easier to write, and easier to evolve."

How does it do this? Jesse goes on to say:

"The guiding philosophy behind CGI::Application is that a web-based application can be organized into a specific set of "Run-Modes." Each Run-Mode is roughly analogous to a single screen (a form, some output, etc.). All the Run-Modes are managed by a single "Application Module" which is a Perl module. In your web servers document space there is an "Instance Script" which is called by the web server"

The biggest difference between CGI::Application and OpenPlugin::Application is that query object they both use; one is designed to use CGI.pm, the other OpenPlugin. Generally speaking, everything in the still applies. Any differences will be noted in this document.
It is not necessary to use OpenPlugin::Application in order to build web applications using OpenPlugin. This plugin is meant to be for your convenience -- to help you structure your web applications in a manner which makes sense, and is reusable.

CGI::Application::Plugin::RateLimit is a plugin for CGI::Application which provides protection against a user calling a runmode too frequently. A typical use-case might be a contact form that sends email.

Youd like to allow your users to send you messages, but thousands of messages from a single user in a short period of time would be a problem.

Installation:

To install this module type the following:

perl Makefile.PL
make
make test
make install

Realtime Application Interface project allows applications with strict timing constraints to be run on Linux.
A real time system is able to guarantee the timing requirements of the processes under its control.
RTAI provides an API and the necessary kernel modifications to accommodate such requirements.
Enhancements:
- Improvements were made to netrpc.
- Context switching between hard and soft real-time, handling of TSC errors, and POSIX compatibility have been improved.
- There are numerous minor bugfixes.

CGI::Application::Plugin::ValidateRM is a Perl module to help validate CGI::Application run modes using Data::FormValidator.

SYNOPSIS

use CGI::Application::Plugin::ValidateRM;

my $results = $self->check_rm(form_display,_form_profile) || return $self->check_rm_error_page;


# Optionally, you can pass additional options to HTML::FillInForm->fill()

my $results = $self->check_rm(form_display,_form_profile, { fill_password => 0 })
|| return $self->check_rm_error_page;

CGI::Application::Plugin::ValidateRM helps to validate web forms when using the CGI::Application framework and the Data::FormValidator module.
check_rm()

Validates a form displayed in a run mode with a Data::FormValidator profile, returning the results and possibly an a version of the form page with errors marked on the page.

In scalar context, it returns simply the Data::FormValidator::Results object which conveniently evaluates to false in a boolean context if there were any missing or invalide fields. This is the recommended calling convention.

Application::Pipeline is a module designed to map methods ( referred to in this role as handlers ) to different phases of an applications life cycle. By assigning methods to different phases of this pipeline, the author can concentrate on the logic for each phase and let the framework manage the application flow. Adopting the same idea as CGI::Application, writing an application with Application::Pipeline is a matter of creating a module that is a subclass of Application::Pipeline.

To build a pipeline application, it is necessary to register methods to run during each phase. This can be done one at a time, with the addHandler method. But Application::Pipeline also looks in the subclass package for the package variable %plan. This hashs keys are the names of the phases of the pipeline. Each key points to an array reference which is a list of the methods to run for that phase. The methods are either the names of the methods to run, or references to the actual methods.

This is not the be-all end-all definition of the pipeline. It is still possible to use addHandler to modify the pipeline, and as explained later, it is possible to take into account %plans defined in superclasses.

Curses::Application provides the Curses Application Framework.

Curses::Application attempts to relieve the programmer of having to deal directly with Curses at all. Based upon Curses::Widgets and Curses::Forms, all one should have to do is define the application forms and contents in the DATA block of a script. Curses::Application will take care of the rest.

This module follows many of the conventions established by the Curses::Widgets and Curses::Forms modules, being built upon that framework. One area of special note, however, is the declaration of forms used within the application.

Curses::Application differentiates between forms and form definitions. A form is an instance of any particular form definition. Keeping that line of separation simplifies the development of MDI (Multiple Document Interface) applications.
Form definitions can be provided in two ways: as a list of definitions in the main::DATA block, or individually by using the addFormDef method. The former would normally be the simplest way to do so.

At the end of your script, declare a DATA block using Perls __DATA__ token. In that DATA block place a hash declaration (%forms) which contains a key/value pair for each form definition. The key being the name of the definition, and the value being a hash reference to the form declarations (see the Curses::Forms pod for directives available to that module). The only extra key that should be in each forms hash reference should be a TYPE directive, which would point to a module name relative to the base Curses::Forms class. If you omit this key, then it will be assumed that the form is a Curses::Forms object, or some custom derivative as specified in ALTPATH.

TiVo::HME::Application is a Perl implementation of TiVos HME protocol.

SYNOPSIS

use TiVo::HME::Application;
our @ISA(TiVo::HME::Application);

sub init {
my($self, $context) = @_;

$self->get_root_view->visible(1);
my $mpg = $T_RESOURCE->image_file(examples/myloop.jpg);
$self->get_root_view->set_resource($mpg,
$T_CONST->HALIGN_CENTER | $T_CONST->VALIGN_CENTER);
}

sub handle_event {
my($self, $resource, $key_action, $key_code, $key_rawcode) = @_;
print "You pressed the $key_code key on the remote!n";
}

Perl on your TiVo in 11 Steps!!

Step 1: Go to http://tivohme.sourceforge.net
Step 2: Go to Step 1
Step 3: Go to Step 2 (seriously)
Step 4: Congratulations on making it here!
Step 5: Really, go to http://tivohme.sourceforge.net, download the
SDK, read the PDF files (dont worry about the protocol PDF,
thats what this is for).
Step 6: Learn about Views & Resources
Step 7: Learn about the Application cycle (init then event loop)
Step 8: Learn about Events
Step 9: Learn how the Perl stuff differs from the Java stuff
(mainly only in naming)
Step 10: View & understand the perl examples - especially how they
related to the Java examples (they do the same thing!).
Step 11: Use your imagination to create a kick-arse Perl-based HME app!!