Free registered software for linux

COPYRIGHT=1]

Installation:

To install this module type the following:

perl Makefile.PL
make
make test
make install[

mod_tee serves to "clone" an document as it is served. mod_tee was hacked up as a quick-and-dirty fix when a Site Valet user complained of problems saving a Valet report: mod_tee now serves to enable registered users to request email copies of any report generated.

The current status is "works for us", but it is not of release quality. It is less-than-complete in several respects. Its probably not a good idea to use it operationally unless youre prepared to get your hands dirty fixing any problems, or pay for support.

Configuration

TeeType FILE|PIPE|SMTP [Destination]
Where to send the cloned output:

FILE - save to a destination file. For testing only!
PIPE - pipes output to a destination program with popen.
SMTP - sends cloned output directly to email at a destination mailserver. Implements SMTP handshake with no error checking - so its a dangerous option!

TeeCondition query|cookie|path|header|env|true|false [key] [val]

Defines a condition for mod_tee to be activated for a request. Values true and false are unconditional, while the others define a QUERY_STRING key, a Cookie, a PATH_INFO component, a request header or an environment variable to trigger the tee. Conditional values require a key. If val is defined then key must match it; otherwise any value of key will activate the tee.

TeeHeader key value

Defines an RFC822-style header to be inserted in front of the body of the page.

phpMyNewsLetter provides a mailing list management script written in PHP.

phpMyNewsLetter is a mailing list management script written in PHP. The subscribers info are stored in a MySQL database. Features include: Subscription checking whether the subscriber is not already registered, Sending of a welcome message at the time of subscribing and unsubscribing, and User-friendly administration allowing you to send messages, List and delete the subscribers, Supports HTML e-mail, Preview of the message before sending, Logging system, Multilanguage support (English, French, Italian, ...), and user-friendly web configuration and installation.

Menu Builder is a software that can find problems with using JavaScripts for rollovers in navigation menus and resolve them.

Menus need to be fast loading, retrievable from cache, and workable with page inserts. From the publishing point of view they need to be able to be distributed to pages efficiently.

There is no limit to how many or how large the images can be displayed on the same page. But as with any great number of images there is always the download time to consider. If it is too slow then there is a risk of the surfer getting impatient and moving on. Many of us tend to forget that we are getting our images from our own cache.

Images presented on the web are usually 72-96 dpi (dots per inch) and unless presenting a photographers professional portfolio, images larger than 100k in file size make for longer downloads and less visitors.

A link can be set for visitors to navigate by mouse clicking the image. The link can be set to a target frame for navigating within framesets. The hyperlink will only function from the registered site. If a link is not required simply leave the setting completely blank.

PPSee is a software for creating picture galleries of photos taken by the digital camera, scanner etc. It also makes possible to view pictures.
The created photo album can be used on your computer, however it is designed mainly for display on the Internet. Instead of photos attached to e-mails, youd better send a link to your own web pages!
Main features:
- the program uses national languages.
- the photo album provides automatic picture projection - slide show
- to move among the pictures in the photo album you can use navigation keys.
- each of the pictures can contain your description, which is saved for later use.
- you can rotate images without any modification of the original file
- photo album is based on a valid code XHTML 1.0 Strict
- the photo album does not need support from any server.
- the program has many attributes affecting the look of the created photo album.
- support of the scripting language BeanShell for greater latitude when creating the photo album.
- you can create their own templates of the photo album.
- registered users can use a batch mode from a command line
- the program can read EXIF information.
- the program runs on the systems such as Windows, Linux, MacOS, OS/2 and Solaris, as well as the photo album.
- registered users can also use new versions of the program.
- the author does not insert into program any form of malware, including: spyware, trojans and backdoors
The program PPSee enables to change the photo album by the help of a number of parameters, however a certain style of the photo album always remains preserved. If you have your own conceptions of the look of the photo album, lay-out of the pictures, navigational buttons, picture description and so on, you can create a template.
The template of the program PPSee is a model, based on which the program creates the real photo album. It is useful to know that templates - or more exactly their program accessories - enable to respect the parameters set in the user graphic environment of the program PPSee. To communicate with the program, templates use the program interface API.
Templates can be saved - together with other parameters - for later use; users can share the saved templates with no limits. Only registered users can work with templates. Detailed information makes part of the program documentation.
Enhancements:
- Photo album is created by a standard XHTML 1.0 Strict.
- You can rotate images without any modification of the original file.
- Bug fixing

PRES project (the Press Release System) is a simple content management system, essentially targeted at producing a news and information site. Managing a PRES system is designed to be simple.
However, presentation is sophisticated and flexible. An elementary knowledge of IT would be useful but expertise in designing and managing websites is not a requirement. PRES can be used for anything from private blogging to corporate news systems.
Main features:
Flexible Presentation
- All content is generated as XML which is styled at server side with XSL-T stylesheets to provide the final look and feel of your pages. This permits an almost infinite variety of presentations. Furthermore, different XSL-T transforms can be associated with different categories, allowing you to have different styling for different parts of your site.
Caching
- Content is generated on request, but in order to limit the computational load on busy sites all content is cached for a limited period (by default twenty minutes).
Subscription
- PRES allows users to subscribe to categories - effectively sections of the site. When new stories are posted to a section youre subscribed to, you will automatically get email with a link to the story.
Syndication
- PRES makes its headlines available as a syndication feed, using both RSS 0.91 and RSS 1.0. This allows other news sites to automatically incorporate live headlines from a PRES site into their content.
Threaded Discussion
- PRES optionally allows registered users to add comments to stories in a threaded manner, similar to sites like Slashdot.
Moderation
- PRES optionally allows registered users to moderate other users comments.

Parse::Nibbler is Perl module to parse huge files using grammars written in pure perl.

Create a parser object using the ->new method. This method is provided by the Parse::Nibbler module and should not be overridden.

The main functionality of the Parse::Nibbler module is the Register subroutine. This subroutine is used to define the rules of your grammar. The Register subroutine takes two parameters: A string and a code reference.

The string is the name of the rule (i.e. the name of the subroutine/method)

The code reference is a reference to the code to execute for this rule.

The Register subroutine will take the code reference, wrap it up in another subroutine that acts as a closure, and then installs that code reference as a subroutine with the name matching the given string.

The wrapper code (the closure) is the same for every rule. The wrapper code handles quantifiers, calls the rule, and decides what to do based on the rule passing or failing.
A rule is a code reference with a given string name that have been passed to Register. Here is an example of a rule:
Register ( Name, sub { my $p = shift; $p->AlternateValues( Jim, Scotty, Spock );
}
);

The parser object will always be passed in as the first parameter to your rule. You must pass this into any further rules or any Parse::Nibbler methods.

In the above example, the rule, "Name" is Registered. "Name" calls one of the builtin methods, AlternateValues, defined below. Once a rule is Registered, other rules can call it:
Register ( MedicalDiagnosis, sub { my $p = shift; $p->AlternateValues("Hes", "Shes"); $p->ValueIs("dead"); $p->ValueIs(","); $p->Name; $p->ValueIs("!"); } );

This code registers a rule called "MedicalDiagnosis". It uses some builtin methods, but it also calls the rule just registered, "Name".

Once a user defines a rule, they can use it in other rules by simply calling it as they would call a method.

Rules registered with the Parse::Nibbler module can be called with quantifiers. Quantifiers are passed into the Rule when you call it in your grammar by passing in a string that matches the format described here.

Quantifiers allow you to specify the quantity of rules present. Quantifiers also allow you to specify whether multiple rules have separators.

Quantifiers are specified using the following string format:

{quantifier}

This indicates that there are zero or one Name rules expected: $p->Name({?});
This indicates that there are zero or more Name rules expected: $p->Name({*});
This indicates that there are one or more Name rules expected: $p->Name({+});
This indicates that there are exactly three Name rules expected: $p->Name({3});
This indicates there are 1 to 3 Name rules expected: $p->Name({1:3});
This indicates there are at least 2 Name rules expected: $p->Name({2:);

Separators are specified using the following string format:

/separator/

This indicates 1 or more Name rules, each separated by a comma:

$p->Name({1:}/,/);

It is the job of the Register function to make sure this additional functionality is provided transparently and automagically to you.

If you call a rule with no quantifier and no separator, the rule will assume the quantifier is 1 and there is no separator.

Additional Parse::Nibbler methods are provided to simplify rule definition and to provide smart, automatic error handling, etc. You grammars should only call other rules that you defined, or these methods explained below.

(Note: these methods do not take quantifiers)
############### Method: ValueIs ###############
Parameters: One parameter, required. A string containing the expected value.
Example: $p->ValueIs( stringvalue );
Description:
This method will look at the next lexical and determine if its value matches that of the stringvalue given as a parameter. If it does not match, an exception is raised and the rule fails.
If the values do match, then the parser stores the lexical, and the rule continues.
####################### Method: AlternateValues #######################
Parameters: A list of string parameters, at least two values.
Example: $p-AlternateValues( value1, value2 );
Description:
This method behaves like the ValueIs method, except that it will recieve a list of allowed alternate expected values. The first match that succeeds causes the rule to pass and return.
If no match occurs, then an exception is raised and the rule aborts.
If a match does occur, the parser stores the lexical, and the rule continues.
############## Method: TypeIs ##############
Parameters: One parameter, required. A string containing the expected type.
Description:
This method will look at the next lexical item, and determine if the lexical type matches the type given as a parameter.
Valid type values depend on the Lexer that you use, but possible values may include "Identifier" and "Number", etc.
Use this in a case where your rule requires an identifier type, for example, but it does not care what the name of the identifier is for the rule.
If a match occurs, the parser stores the lexical and the rule continues.
If a match does not occur, an exception is raised, and the rule aborts.
###################### Method: AlternateRules ######################
Parameters: A list of string parameters, at least two.
Example: $p->AlternateRules( Rule1, Rule2 );
Description:
You can describe rule alternation in your rule by calling this method. The method takes a list of strings whose string values match the names of the valid alternate rule names.
In the above example, the McCoy rule is either a declaration of profession or a medical diagnosis. These are two rules that are defined in the same package. The AlternateRules method allows you to define multiple rules that may be valid at the same point in the text.
If a rule in the parameter list succeeds, the AlternateRule method succeeds, and returns immediately.
If no rule succeeds, an exception is thrown, and the rule aborts.
This rule expects either a "DeclareProfession" rule or a "MedicalDiagnosis" rule to be present.
Register ( McCoy, sub { my $p = shift; $p->AlternateRules( DeclareProfession, MedicalDiagnosis ); } );
You can specify quantifiers as part of the alternate rule strings.
$p->AlternateRules( DeclareProfession({+}), MedicalDiagnosis );
The above example indicates that you can have one or more DeclareProfession rules OR ALTERNATELY you can have exactly one MedicalDiagnosis rule.

EXPORT

Register, used to register the rules in your grammar.