Free your uninstaller 08 software for linux

Vocabulary Trainer project is a flashcard vocabulary training system.
You can use language modules to change the language of its interface and can choose one of three learning modes (Random, Often-unknown words, and Seldom-asked words).
Main features:
- Inquiry after foreign word or meaning
- Optional Attention of upper- and lowercase
- Limitation of time to simulate tests (optional)
- Saving of right, wrong and prompted vocabularies
- Inquiry after: Random order, as given, often unknown vocabularies, seldom asked vocabularies
- Multilingual Interface, changeable with languagefiles
- This program is Open Source, the Delphi-sourcecode kann be downloaded under "Downloads"
- Free of charge
- No further restrictions

UI::Dialog project supports priority ordering of the backend detection process.

SYNOPSIS

use UI::Dialog;
my $d = new UI::Dialog ( backtitle => Demo, title => Default,
height => 20, width => 65 , listheight => 5,
order => [ zenity, xdialog ] );

# Either a Zenity or Xdialog msgbox widget should popup,
# with a preference for Zenity.
$d->msgbox( title => Welcome!, text => Welcome one and all! );

ABSTRACT

UI::Dialog is a OOPerl wrapper for the various dialog applications. These dialog backends are currently supported: Zenity, XDialog, GDialog, KDialog, CDialog, and Whiptail. There is also an ASCII backend provided as a last resort interface for the console based dialog variants. UI::Dialog is a class that provides a strict interface to these various backend modules. By using UI:Dialog (with its imposed limitations on the widgets) you can ensure that your Perl program will function with any available interfaces.

So if youd prefer that Xdialog should be used first if available, simply designate the desired order when creating the new object. The default order for detecting and utilization of the backends are as follows: (with DISPLAY env): Zenity, GDialog, XDialog, KDialog (without DISPLAY): CDialog, Whiptail, ASCII

UI::Dialog is the result of a complete re-write of the UDPM CPAN module. This was done to break away from the bad choice of name (UserDialogPerlModule) and to implement a cleaner, more detached, OOPerl interface.

ModPerl::ParamBuilder is a Perl module that makes building custom Apache directives easy.

SYNOPSIS

package MyApp::Parameters;

use ModPerl::ParamBuilder;

use base qw( ModPerl::ParamBuilder );

my $builder = ModPerl::ParamBuilder->new( __PACKAGE__ );

# Build simple one argument parameter
$builder->param( Template );
$builder->param( PageTitle );
$builder->param( ItemsPerPage );

# Build an On/Off parameter
$builder->on_off( Caching );

# Build a Yes/No parameter
$builder->yes_no( AutoCommit );

# Build a no argument/flag parameter
$builder->no_arg( Active );

# Build a one argument parameter with a custom error message
# and special configuration hash key
$builder->param( {
name => SMTPServer,
err => SMTPServer xx.xx.xx.xx,
key => smtp_server,
});

# Load the configuration into Apache
$builder->load;

################################################
# And elsewhere in your application
################################################
package MyApp::Main;

# Retrieve the configuration like so
my $params = MyApp::Parameters->new;
my $conf_ref = $params->get_config( $r );

# Or if you have PerlOptions +GlobalRequest on then you can just
# call
my $conf_ref = $params->get_config;

One of the neatest features of mod_perl 2.0 is the ability to easily create your own custom Apache directives. Not only are they more efficient to use compared to PerlSetEnv, PerlPassEnv, PerlAddVar, and PerlSetVar, but they give your application a more polished and professional look and feel..

Not to mention theyre just plain cool. This module aims to make the already easy, even easier.
Note that you MUST load your parameter module with PerlLoadModule in your httpd.conf and not PerlModule. This is necessary because Apache needs to load your module earlier than usual in the startup to be able to read its own configuration now.

LIMITATIONS

The biggest limitation is that this module ONLY works with mod_perl 2.0 and above. There are no plans to support mod_perl 1.x for this module, trust me you want to upgrade to mod_perl 2 as soon as you can.

This modules intent is not to replace the underlying mod_perl APIs nor is it intended to be used for complicated cases where special processing is needed. It is intended to make the simple things simple.

Some things to keep in mind when using ModPerl::ParamBuilder

This module does not restrict where the directives can be used in Apaches httpd.conf. To restrict directives to particular area ( only in main server conf, a VirtualHost, or a Location, etc ) you will need to use the mod_perl APIs to build your directives.

This also does not do, by default, any error checking or validation on the arguments passed to directives. If you create a directive NumberOfItemsPerPage and then put:

NumberOfItemsPerPage rhubarb

Apache will not see this as an error and your configuration hash for the key NumberOfItemsPerPage will contain the string rhubarb. You can validate this data in three different ways:

1) Validate the configuration data in your application prior to
using it.

2) Instruct ModPerl::ParamBuilder to use a special function for
processing the arguments by passing the func option.

3) Revert to using the mod_perl API where you have more control.

See the appropriate mod_perl 2.0 API modules for how to accomplish more in depth processing of directives and their data.

POE::Component::SubWrapper is an event based wrapper for subs.
SYNOPSIS
use POE::Component::SubWrapper;
POE::Component::SubWrapper->spawn(main);
$kernel->post(main, my_sub, [ $arg1, $arg2, $arg3 ], callback_state);
This is a module which provides an event based wrapper for subroutines.
SubWrapper components are not normal objects, but are instead spawned as separate sessions. This is done with with PoCo::SubWrappers spawn method, which takes one required and one optional argument. The first argument is the package name to wrap. This is required. The second argument is optional and contains an alias to give to the session created. If no alias is supplied, the package name is used as an alias.
Another way to create SubWrapper components is to use the poeize method, which is included in the default export list of the package. You can simply do:
poeize Data::Dumper;
and Data::Dumper will be wrapped into a session with the alias Data::Dumper.
When a SubWrapper component is created, it scans the package named for subroutines, and creates one state in the session created with the same name of the subroutine.
The states each accept 3 arguments:
- An arrayref to a list of arguments to give the subroutine.
- A state to callback with the results.
- A string, either SCALAR, or ARRAY, allowing you to decide which context the function handled by this state will be called in.
The states all call the function with the name matching the state, and give it the supplied arguments. They then postback the results to the named callback state. The results are contained in ARG0 and are either a scalar if the function was called in scalar context, or an arrayref of results if the function was called in list context.

DBIx::DBStag is a Perl module for Relational Database to Hierarchical (Stag/XML) Mapping.

SYNOPSIS

use DBIx::DBStag;
my $dbh = DBIx::DBStag->connect("dbi:Pg:dbname=moviedb");
my $sql = q[
SELECT
studio.*,
movie.*,
star.*
FROM
studio NATURAL JOIN
movie NATURAL JOIN
movie_to_star NATURAL JOIN
star
WHERE
movie.genre = sci-fi AND star.lastname = Fisher
USE NESTING
(set(studio(movie(star))))
];
my $dataset = $dbh->selectall_stag($sql);
my @studios = $dataset->get_studio;

# returns nested data that looks like this -
#
# (studio
# (name "20th C Fox")
# (movie
# (name "star wars") (genre "sci-fi")
# (star
# (firstname "Carrie")(lastname "Fisher")))))

# iterate through result tree -
foreach my $studio (@studios) {
printf "STUDIO: %sn", $studio->get_name;
my @movies = $studio->get_movie;

foreach my $movie (@movies) {
printf " MOVIE: %s (genre:%s)n",
$movie->get_name, $movie->get_genre;
my @stars = $movie->get_star;

foreach my $star (@stars) {
printf " STARRING: %s:%sn",
$star->get_firstname, $star->get_lastname;
}
}
}

# manipulate data then store it back in the database
my @allstars = $dataset->get("movie/studio/star");
$_->set_fullname($_->get_firstname. .$_->get_lastname)
foreach(@allstars);

$dbh->storenode($dataset);
exit 0;

Or from the command line:

unix> selectall_xml.pl -d dbi:Pg:dbname=moviebase
SELECT * FROM studio NATURAL JOIN movie NATURAL
JOIN movie_to_star NATURAL JOIN star
USE NESTING (set(studio(movie(star))))

Or using a predefined template:

unix> selectall_xml.pl -d moviebase /mdb-movie genre=sci-fi

KVideoEncoder is a GUI for the mencoder; the goal of this application is to be a clone of TMPGEnc for Linux with additional features.

KVideoEncoder supports joining of two or more videos and dvd-ripping.

Bundle::KohaSupport is a Perl bundle of the modules required by Koha.

SYNOPSIS

perl -MCPAN -e install Bundle::KohaSupport

CONTENTS

Test::Harness
Test::Simple
Date::Manip
DBD::mysql
DBI
Digest::MD5
Event
File::Spec
HTML::Template
MARC::Record
Event
Net::Z3950
Set::Scalar
Mail::Sendmail

This bundle gathers together all installs all of the prerequisite modules for Koha, the open source integrated library system.

Test::Harness Run perl standard test scripts with statistics

Test::Simple A framework for test scriptss

Date::Manip Date manipulation routines

DBD::mysql This module is used to connect to the database that Koha uses to store its information

DBI A Database interface

Digest::MD5 Perl interface to the MD5 algorithm

File::Spec Performs portability operations on file names

HTML::Template For templates in the Koha web based interface

MARC::Record Module for handling MARC records as objects

Event Fast, generic event loop

Net:Z3950 OO Interface to to Yaz 39.50 toolkit

Set::Scalar Basic Set operations

Mail::Sendmail Simple platform independant mailler