Free paper pilots screensaver 1.011 software for linux

Pause on screensaver script will pause playback every time the screensaver activates. Pause on screensaver is useful to stop music when you lock your desktop.

Simple terminal screensaver (or tss for short) is an attempt to clone and enhance FreeBSDs daemon saver.
Although intended for GNU/Linux, it works fine under FreeBSD and probably a lot of other Unix-based Operating Systems.
Main features:
- VT Locking (Shadow and BSD DB)
- ASCII Mirroring
- Multiple colors in ASCII
- Scrollbox showing uptime
- Random ASCII file selection
- Dynamic object speeds
Enhancements:
- Failed login attempts are now reported to syslogd.

Paper Harbour is a software based system which allows you to securely organise and distribute your electronic documentation.
Paper Harbour runs over a network and allows clients to access a central document archive. Paper Harbour is compatible with both Windows and Linux platforms and is designed to work with MySQL open source database, although it is compatible with other databases.
Paper Harbour can provide a central point for information exchange in the form of shared documents.
Whether the organisation is project based, product based or service based Paper Harbour can provide structure and tools to aid business development.
Paper Harbour doesnt only store documents, it stores information about the documents. It also includes functionality which supports distribution of documents, unique document ids, document reviews, searching and more.
Paper Harbour is designed to be simple so that users do not need a high degree of technical knowledge to be able to use it. This simplicity is defined in the concept which Paper Harbour is built on.
Paper Harbour is also designed as a platform for document management. It can be installed and run with the standard functions or it can be modified to include customer specific functions. In addition, Paper Harbour is supplied with the source code so our customers are free to make their own modifications.
The Paper Harbour has been designed so that it is compatible with Open Source solutions. This means that our customers can reduce their implementation cost. Supporting Technologies Nordic are committed to ensuring that Paper Harbour is affordable for all sizes of organisations, so that smaller organisation can have access to the same technologies that large organisations use.
Main features:
- Centralised Storage
- Automatic Distribution
- Version and Change Control
- Security

PurpleView provides a paper review system.
PurpleView is a paper review system that was designed to help distributed project development. It serves as a collection of materials relevant to a field of interest, and its review capability allows users to distinguish good and relevant items from bad and irrelevant items.
Submission of papers in different Categories and Platforms aids their systematization. The sorting and searching features facilitate powerful and expedient data examination.
It incorporates discussion forums for each item, notifications and message boards, and features security logins and automated database backups that assure the systems accountability and availability.
The additional features added to PurpleView help increase its effectiveness. The systems notification and message board keeps members up-to-date with databases latest changes.
PurpleViews rank list shows users activity according to the submitted materials and reviews. Paging capabilities reduce bandwidth demands and improve clarity of big databases. Security logins and automated database backup assure respectively the systems accountability and availability.
Enhancements:
- dded the register_globals off kludge (Eric Titolo)
- put some comments in (Eric Titolo)
- added a db_prefix "pv_" in the table entries(Eric Titolo)
- added $server_name var(Eric Titolo)
- replace obsolete mysql_db_query with mysql_query(Lyudmil Antonov)

RPilot project is an interpreter for the IEEE-standard language PILOT.
RPilot is an interpreter for the IEEE-standard programming language PILOT written in portable C.
PILOT is a language that was designed in the 1960s to support computer-aided instruction and is very simple to learn.
RPilot comes with an introduction to the language and several examples.
Enhancements:
- Fix usage of `isblank(), a GNU extension (Thanks to Patrick Eaton)
- Add some #defines to rpilot.h to replace a few hard-coded constants
- RPilot is over 4 years old. Wow.

Performance Co-Pilot (PCP) is a framework and services to support system-level performance monitoring and performance management.
The services offered by PCP are especially attractive for those tackling harder system-level performance problems. For example this may involve a transient performance degradation, or correlating end-user quality of service with platform activity, or diagnosing some complex interaction between resource demands on a single system, or management of performance on large systems with lots of "moving parts".
The distributed PCP architecture makes it especially useful for those seeking centralized monitoring of distributed processing (e.g. in a cluster or webserver farm environment), especially where a large number hosts are involved.
Main features:
- A single API for accessing the performance data that hides details of where the data comes from and how it was captured and imported into the PCP framework.
- A client-server architecture allows multiple clients to monitor the same host, and a single client to monitor multiple hosts (e.g. in a Beowulf cluster). This enables centralized monitoring of distributed processing.
- Integrated archive logging and replay so a client application can use the same API to process real-time data from a host or historical data from an archive.
- The framework supports APIs and configuration file formats that enable the scope of performance monitoring to be extended at all levels.
- An "plugin" framework (libraries, APIs, agents and daemon) to collect performance data from multiple sources on a single host, e.g. from the hardware, the kernel, the service layers, the application libraries, and the applications themselves.
- Libraries and sample implementations encourage the development of new "plugins" (or agents) to capture and export the performance data that matters in your application environment, along side the other generic performance data.
- An endian-safe transport layer for moving performance metrics between the collector and the monitoring applications over TCP/IP. This means an IRIX desktop with PCP can monitor one or more Linux systems with the Open Source release of PCP installed.
- A Linux agent that exports a broad range of performance data from most kernels circa 2.0.36 (RedHat 5.2) or later. This includes coverage of activity in the areas of: CPU, disk, memory, swapping, network, NFS, RPC, filesystems and all the per-process statistics.
- Other agents export performance data from:
- Web server activity logs
- arbitrary application-level tracing (via a PCP trace library)
- Cisco routers
- sendmail
- the mail queue
- the PCP infrastructure itself
- Assorted simple monitoring tools that use the PCP APIs to retrieve and display either arbitrary performance metrics, or specific groups of metrics (as in pmstat a cluster-aware vmstat lookalike).
- The PCP inference engine supports automated monitoring through a rule-based language and interpreter that performs user-defined actions when rule predicates are found to be true.

PostScript::Graph::Bar Perl module can draw a bar chart on a postscript file.

SYNOPSIS

Simplest

Take labels and values from a csv file and output as a bar chart on a postscript file.

use PostScript::Graph::Bar;

my $bar = new PostScript::Graph::Bar();
$bar->build_chart("survey.csv");
$bar->output("survey");

Typical

use PostScript::Graph::Bar;

my $bar = new PostScript::Graph::Bar(
file => {
paper => A4,
landscape => 1,
},
layout => {
background => [1, 1, 0.9],
heading => Test results,
},
y_axis => {
smallest => 4,
},
style => {
auto => [qw(green blue red)],
}
);

$bar->series_from_file( data.csv );
$bar->build_chart();
$bar->output( results );

The file data.csv has a row of headings followed by 4 rows of 10 items. This produces a bar chart with four groups of ten bars each. The groups are labelled with the first value in each row. The bars in each group are coloured ranging from brown through green and then shades of blue. A Key links the row of headings to each colour. In addition, the background is beige, a heading is placed above the chart and the y axis is not too crowded.

All options

use PostScript::Graph::Bar;

my $bar = new PostScript::Graph::Bar(
file => {
# Paper size, orientation etc
# See PostScript::File
},
layout => {
# General proportions, headings
# See PostScript::Graph::Paper
},
x_axis => {
# All settings for X axis
# See PostScript::Graph::Paper
},
y_axis => {
# All settings for Y axis
# See PostScript::Graph::Paper
},
style => {
# Appearance of bars
# See PostScript::Graph::Style
},
key => {
# Settings for any Key area
# See PostScript::Graph::Key
},
show_key => 1,
labels_row => 1,
);

File::VirtualPath is a portable abstraction of a file/dir/url path.

SYNOPSIS

Content of thin shell "startup.pl":

#!/usr/bin/perl
use strict;
use warnings;

my $root = "/home/johndoe/projects/aardvark";
my $separator = "/";
if( $^O =~ /Win/i ) {
$root = "c:projectsaardvark";
$separator = "";
}
if( $^O =~ /Mac/i ) {
$root = "Documents:projects:aardvark";
$separator = ":";
}

use Aardvark;
Aardvark->main( File::VirtualPath->new( $root, $separator ) );

1;

Content of fat main program "Aardvark.pm"

package Aardvark;
use strict;
use warnings;
use File::VirtualPath;

sub main {
my (undef, $project_dir) = @_;
my $prefs = ≥t_prefs( $project_dir->child_path_obj( config.pl ) );
&do_work( $prefs, $project_dir );
}

sub get_prefs {
my ($project_dir) = @_;
my $real_filename = $project_dir->physical_path_string();
my $prefs = do $real_filename;
defined( $prefs ) or do {
my $virtual_fn = $project_dir->path_string();
die "Cant get Aardvark prefs from file $virtual_fn: $!";
};
return( $prefs );
}

sub do_work {
my ($prefs, $project_dir) = @_;
my ($lbl_a, $lbl_b, $lbl_c) = ($prefs->{a}, $prefs->{b}, $prefs->{c});
my $data_source = $prefs->{sourcefile};
open( SOURCE, $project_dir->physical_child_path_string( $data_source ) );
while( my $line = ) {
my ($a, $b, $c) = split( "t", $line );
print "File contains: $lbl_a=$a, $lbl_b=$b, $lbl_c=$cn";
}
close( SOURCE );
}

1;

Content of settings file "config.pl"

$rh_prefs = {
sourcefile => mydata.txt,
a => name,
b => phone,
c => date,
};