Free list of office suites software for linux

OutOfOffice answers your email with the message you have set when you are out of your office.

OutOfOffice is like Outlooks Out of office function, but you dont need Outlook or Exchange.

GNOME Office is the premier suite of office productivity applications designed for the GNOME desktop environment.
Some of the applications also can run on Windows or Mac OS X. They provide powerful, efficient office productivity capabilities as free (GPL) software.
Main features:
- AbiWord word processor
- Gnumeric spreadsheet
- Gnome-DB data access components

Siag Office project is a free office package which consists of the spreadsheet Siag, the word processor PW, the animation program Egon, the text editor XedPlus, the file manager Xfiler and the previewer Gvu.
Siag is easy to use, yet infinitely flexible through multiple embedded interpreters and a plugin mechanism that allows other programs to run inside the main document. The supported interpreters are SIOD, Guile, Tcl, and Python.
Enhancements:
- Various fixes have been made to this release to make it buildable.
- Antiword has been unbundled.
- Formatting errors have been removed from the Italian dictionary.
- A version of o3read has been bundled.

Office Tournament project is a tool for keeping track of office tournaments, such as foosball.

You may enter data from the command line or from the CGI Web interface. It outputs all kinds of stats and even a nice chart if you use the Imager::Graph::Pie Perl library available from CPAN.

It currently requires no database to run, but there are plans to migrate the text (flat file db) to MySQL.

List::Util::Superpositions is a Perl module that provides any and all for lists.
Synopsis
This module extends the methods provided by List::Util to offer the any() and all() operators from Quantum::Superpositions as part of the List::Util feature set.
use List::Util::Superpositions;
my $foo = List::Util::Superpositions->new();
...
Exports & Inheritances
Quantum::Superpositions
- any
- all
List::Util
- first
- max
- maxstr
- min
- minstr
- reduce
- shuffle
- sum

List::RewriteElements is a Perl module that can create a new list by rewriting elements of a first list.

SYNOPSIS

use List::RewriteElements;

Constructor

Simplest case: Input from array, output to STDOUT.

$lre = List::RewriteElements->new( {
list => @source,
body_rule => sub {
my $record = shift;
$record .= q{additional field};
},
} );
Input from file, output to STDOUT:
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
body_rule => sub {
my $record = shift;
$record .= q{,additional field};
},
} );
Provide a different rule for the first element in the list:
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
header_rule => sub {
my $record = shift;
$record .= q{,ADDITIONAL HEADER};
},
body_rule => sub {
my $record = shift;
$record .= q{,additional field};
},
} );
Input from file, output to file:
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
body_rule => sub {
my $record = shift;
$record .= q{additional field};
},
output_file => "/path/to/output/file",
} );
To name output file, just provide a suffix to filename:
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
body_rule => sub {
my $record = shift;
$record .= q{additional field};
},
output_suffix => .out,
} );
Provide criteria to suppress output of header or individual record.
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
header_suppress => sub {
my $record = shift;
return if $record =~ /$somepattern/;
},
body_suppress => sub {
my $record = shift;
return if $record ne somestring;
},
body_rule => sub {
my $record = shift;
$record .= q{additional field};
},
} );

Generate Output

$lre->generate_output();

Report Output Information

$path_to_output_file = $lre->get_output_path();

$output_file_basename = $lre->get_output_basename();

$output_row_count = $lre->get_total_rows();

$output_record_count = $lre->get_total_records();

$records_changed = $lre->get_records_changed();

$records_unchanged = $lre->get_records_unchanged();

$records_deleted = $lre->get_records_deleted();

$header_status = $lre->get_header_status();

It is common in many situations for you to receive a flat data file from someone else and have to generate a new file in which each row or record in the incoming file must either (a) be transformed according to some rule before being printing to the new file; or (b) if it meets certain criteria, not output to the new file at all.

List::RewriteElements enables you to write such rules and criteria, generate the file of transformed data records, and get back some basic statistics about the transformation.

List::RewriteElements is useful when the number of records in the incoming file may be large and you do not want to hold the entire list in memory. Similarly, the newly generated records are not held in memory but are immediately printed to STDOUT or to file.

On the other hand, if for some reason you already have an array of records in memory, you can use List::RewriteElements to apply rules and criteria to each element of the array and then print the transformed records (again, without holding the output in memory).