Free publishers clearing house software for linux

Panda Publisher provides a lightweight, standards-compliant content management system.
Panda Publisher is a lightweight content management system. It aims to be fast, scalable, standards-compliant and meta-data rich in order to serve page viewers better and allow Web masters to concentrate on writing content rather than all the little things that make visiting Web sites easier for users.
Meta-data is created on the fly to ensure that it is up-to-date. Menus, Site Maps, Searches, etc. are all generated automatically to give consistent navigation to the end user.
Enhancements:
- Shiny new installer
- Standards Compliance improvements
- Fixed style sheet selector in admin
- New Offline-mode
- Code clean-ups
- Security Fixes

Podcast::Publisher is a Perl module for creating and managing podcasts.

SYNOPSIS

use Podcast::Publisher;

my $podcast = Podcast::Publisher->new;
$podcast->set_logger( sub { my $msg = shift; print $msg; } );
$podcast->set_error_logger( sub { my $msg = shift; print STDERR $msg; } );
my $xml = "./podcast.xml";
$podcast->set_file( $xml );
$podcast->set_remote_root( "http://localhost.localdomain/podcast/publishing/" );
$podcast->set_db_connection( { driver => "mysql",
username => foo,
password => bar,
host => localhost,
database => podcast } );

# If we change podcast information, synchronize this information in the MP3 file itself
$podcast->set_synchronize( 1 );

$podcast->set_metadata( { title => "Chris Podcast",
description => "All About Chris",
"docs" => "http://localhost",
"editor" => "podcastmanager@localhost",
"webmaster" => "podcastmanager@localhost",
} );

# This adds an item to the database, and synchronizes the
# MP3 Tag information in the file with the database
$podcast->add_new_episode( { title => Some title,
author => Chris of course
category => Jazz
description => First in a series of many
mp3 => /home/foobar/mp3s/episode1.mp3 } );

$podcast->set_upload_settings( { host => localhost.localdomain,
username => someuser,
password => somepass,
path => podcast/publishing/,
remote_root => http://localhost.localdomain/podcast/publishing/ } );
$podcast->upload();

Enhancements:

Two bugs are realized:

• If you are about to fill a row and you press the down key, the row clearing will get all messed up.
• If you press the space key the moment a new shape is created, you'll lose the game.

Requirements:

• Python
• Pygame

Dream Print Tracking System is a powerful and user-friendly system for tracking print distribution and circulation.
It uses many principles from customer relationship management (CRM) systems, but in a way specific to print publishers.
The Media Development Loan Fund commissioned Dream based on its experience in working with print publishers in more than 30 countries worldwide, where it provides support to independent media in the form of financing, training and technology.
In many of these countries, print distribution is one of the biggest difficulties independent publishers face because it is tightly controlled. Many countries have print distribution monopolies or cartels, which are either politically tied to the government, corrupt or incompetent.
Dream is a tool for tracking print circulation. In a similar way to customer relationship management (CRM) systems such as Campwares Cream software, Dream allows you to maintain a clear picture of your distribution business based on regularly entered contracts, orders, and shipment information. This is handled primarily through Dreams Report functions. Dream is designed to look and feel like an email application. Its inbox is used for tracking inbound communications such as new customer e-mails and customer phone calls.
Because Dream works with any standard SMTP mail server, it also manages outbound customer communications and keeps records of your responses.
Dream does two things: It is a database that stores all the relevant information you supply about the publications you produce, who distributes, who sells it, and how you connect with these people.
It is also a tool for retrieving and presenting this information in several different ways. It contains utilities for tracking products, promotions, and communications.
Dream handles four types of information:
1. Information about what you produce and the people to whom you provide it. This information is entered on the Options tab of the screen and appears primarily in the menus on the Main tabs screens. One example is a product category in which you describe a periodical you produce.
2. Information about specific products such as books or individual issues of what you produce, specific distributors and specific sellers, and tracking of these items from contract to order to shipment to return.
3. Communications, including records of incoming messages from various sources, outgoing emails to individuals, and newsletters.
4. User information including usernames, passwords, preferences and permissions.
Enhancements:
- Minor bugfixes were made.
- A Russian localization was added.

PoJoe Component Libraries project is a set of Java POJO components, originally developed for OSMQ. Developers have found these components useful in building robust enterprise applications.
Of note are: a FIFO queue that utilizes memory until a size threshold is reached, paging overflow elements to a disk cache; a dynamic discovery mechanism for locating remote processes by name over an IP network, eliminating the need to identify a remote service with a specific host computer; and a set of peer-to-peer async message components that support n concurrent message publishers for each named subscriber.
Enhancements:
- Minor enhancements and bugfixes, and changing the license from GNU Lesser to Apache 2.0.

The Issue Dealer is an application for managing information. We currently use it in Nidelven IT to manage day-to-day tasks and information.
The Issue Dealer features issue management (information and tasks), relations (to relate issues) and different publishers; to see one of the publishers in action, go to The Blogologue.
Issue Dealer can be used as an Issue Tracker, tracking issues of various types, for example problem, goal, idea, info.
It can also be used to manage information, either as raw text, or as HTML with for example images, these information issues can then be published to websites (using WebDAV), or to weblogs (either an Issue Dealer weblog, or an external one that supports the metaWeblog API).
Enhancements:
- A bug where verification of email addresses wouldnt work was fixed.
- Small changes to the WYSIWYG editor were made.

KoverArtist is a program for the fast creation of covers for cd/dvd cases and boxes. KoverArtists main idea is to be able to create decent looking covers with some mouseclicks.
The project started from my need for some decent covers for the films I record from television and then often burn on dvd for archiving.
With series I usually start with one or two dvds, and add more as more episodes are available. So the program - KoverArtist - had to be flexible enough to handle that. This also requires changing covers on the fly to use cases that can house more discs.
Enhancements:
- Some layout tweaking to make the main window fit better on a 1024x768 screen (thanks to Agnese Bonetti for reporting).
- Bugfix: Disc #1 tab was not shown on startup when no project was opened.
- Bugfix: koverartist crashed when ~/.cddb did not exist upon audio-cd import (thanks to Audidriver for reporting).
- Corrections in German translation.
- Added support for KinoArtist projects (KinoArtist is not released yet).
- When importing a disc and the project title or snapshots are not set, the disc settings are then used (like when opening a KMediaFactory project as a project).
- Added support for automake 2.6.x

Tie::FileLRUCache is a lightweight but robust filesystem based persistent LRU cache.

SYNOPSIS

OBJECT INTERFACE

use Tie::FileLRUCache;
my $cache = Tie::FileLRUCache->new({ -cache_dir => $directory, -keep_last => 100 });

# Inserting value into LRU cache using -key
$cache->update({ -key => $key, -value => $value });


# Inserting value into LRU cache using -cache_key
my $cache_key = $cache->make_cache_key({ -key => $key });
$cache->update({ -cache_key => $cache_key, -value => $value });


# Checking LRU cache
my ($in_cache,$value) = $cache->check({ -key => $key });
if ($in_cache) {
return $value;
}
# Not in cache - do something else


# Checking LRU cache with speed up hack for objects, hashes, arrays etc used as keys
my $cache_key = $cache->make_cache_key({ -key => $something });
my ($in_cache,$value) = $cache->check({ -cache_key => $cache_key });
if ($in_cache) {
return $value;
}
# Not in cache - do something else


# Deleting a key and its value from the cache
$cache->delete({ -key => $key });


# Clearing LRU cache
$cache->clear;

TIED INTERFACE

use Tie::FileLRUCache;

[$X =] tie %hash, Tie::FileLRUCache, $cache_dir, $keep_last_n;

# Adding a key/value to the cache
$hash{$key} = $value;

# Checking the cache
if (not exists $hash{$key}) {;
# No match
.
.
.

} else {
my $value = $hash{$key};
.
.
.

}

# Removing a value from the cache;
delete $hash{$key};

# Clearing the cache
%hash = ();
Note: Iteration over the cache (each, keys, values) is _NOT_ supported.