Free daisy software for linux

Daisy project consists of a CMS framework.
Daisy is a content management application framework. It provides a standalone, HTTP/XML-accessible repository server and an Apache Cocoon-based, Wiki-like Web-based client application.
Daisy is a comprehensive content management application framework, consisting of a standalone repository server accessible through HTTP/XML (using the ReST style of WebServices) and/or a high-level (remote) Java API, and an extensive browsing and editing DaisyWiki application running inside Apache Cocoon.
Daisy is licensed under the commercially-friendly Apache License 2.0. Outerthought provides commercial services around Daisy.
Enhancements:
- Added characterEncoding=UTF-8 parameter to the MySQL JDBC URL, which is needed for correct UTF-8 support when UTF-8 is not the default character set of the MySQL server.
- Fixed a "NullPointerException" that occured when using a field with a static selection list with labels for the list items, but not for the language of the active user.
- Fixed the remaining issues that prevented installing Daisy in a directory containing spaces (such as c:Program Files)

Freedaisy is a free implementation of Daisy book standard for allowing MP3 files to be indexed using (X)HTML and SMIL.

Daisy is frequently used by visually impaired users, so they can listen to audio books with chapters.

Kamaelia is a toy box, a toolkit, a library of components you can take and bolt together, customise and create your own.
This includes components for TCP/multicast clients and servers, backplanes, chassis, Dirac video encoding & decoding, Vorbis decoding, pygame & Tk based user interfaces and Tk, visualisation tools, presentation tools, games tools.
A networked unix pipe for the 21st century - a way of making general concurrency easy to work with, and fun.
A framework providing the nuts and bolts for building components. A library of components built using that framework. Components are implemented at the lowest level as python generators, and communicate by message passing. Components are composed into systems in a manner similar to Unix pipelines, but with some twists that are relevent to modern computer systems rather than just file-like systems.
To enable programmers of all skill levels with playing with components in a networked environment. Network systems are naturally concurrent, and concurrency is often hard. Kamaelia is trying to make concurrency natural and easy to work with, because we are trying to solve some specific challenges regarding putting (some or all of) the BBC Archive online. Lego, KNex and building blocks are great metaphors for systems like unix pipelines that have made concurrency easy (in a constrained way) for 30 years.
Axon - the core concurrency framework - is considered API stable (current version 1.1.2). Kamaelia - the library of components - is considered still in development stage, since we recognise theres a lot more to do (current version 0.3.0). However generally this is regarding adding features rather than removing or changing. Components that exist today, for building systems:
- Components for TCP servers, multicast servers, backplanes, chassis, video encoding & decoding (using the BBCs Dirac codec), decoding and playback of audio & music encoded using ogg vorbis, creating user interfaces using pythons favourite API for SDL (ie pygame, and Tk based user interfaces. Theres also tools for visualisation[*], presentations, and a host of other random things. (including some tools for building games. The layout tools for this actually come from an old lava lamp simulator, so theyve based on a physics/emergent model which I find nice to look at and seems to fascinate geeks and small children alike.
Finally in terms of tools, we have:
- An "axon shell", which is an Axon/Kamaelia aware IPython/unix shell.
- A visualiser
- A visual pipeline builder (which creates code for you based on your point, click and dragging).
This allows you to build systems ranging from viewing network topologies and interactive systems through to networked personal autocues.
Enhancements:
- Key highlights of this release are BitTorrent support, OpenGL support, massively enhanced DVB support, collaborative whiteboarding with audio and support for daisy-chaining whiteboards, a nascent seaside-style Web server, and enhanced visual system composition (i.e. the ability to compose arbitrary graphs).
- All of these include examples, including an OpenGL interface to BitTorrent, a BitTorrent-based simple (non-robust) streaming system, and a "record for me" scriptable PVR based on programme name.

Javascript::Menu is a NumberedTree that generates HTML and Javascript code for
a menu.

SYNOPSIS

use Javascript::Menu;

# Give it something to do (example changes the menus caption):

my $action = sub {
my $self = shift;
my ($level, $unique) = @_;

my $value = $self->getValue;
return "getElementById(caption_$unique).innerHTML=$value";
};


# Build the tree:

my $menu = Javascript::Menu->convert(tree => $otherTree, action => $action);

my $menu = Javascript::Menu->readDB(source_name => $table, source => $dbh,
action => $action);

my $menu = Javascript::Menu->new(value => Please select a parrot,
action => $action);

my $blue = $menu->append(value => Norwegian Blue);
$blue->append(value => Pushing up the daisies);
$menu->append(value => A Snail);

# Or maybe you just want a navigational menu?

my $menu = Javascript::Menu->new(value => Please select a prime minister);
$menu->append(value => Ariel Sharon,
URL => www.corruption.org/ariel_sharon.htm);

$menu->append(value => Benjamin Netanyahu,
URL => www.corruption.org/bibi.htm);

$menu->append(value => Shaul Mofaz, URL => www.martial_law.org);


# Print it out as a right-to-left menu:

my $css = $menu->buildCSS($menu->reasonableCSS);
print $cgi->start_html(-script => $menu->baseJS(rtl),
-style => $css); #CSS plays an important role.
print $tree->getHTML;

Javascript::Menu is an object that helps in creating the HTML, Javascript, and some of the CSS required for a table-based menu. There are a few other modules that deal with menus, But as I browsed through them, I found that none of them exactly fitted my needs. So I designed this module, with the following goals in mind:

Flexibility

The main feature of this module is the ability to supply all nodes or any specific node with a subroutine that is activated in time of the code generation to help decide what the item will do when it is clicked. This allows customisation far beyond associating a link with every item. Multy-level selection menus become very easy to do (and this is, in fact, what I needed when I started writing this).

I18n

Working with i18n (internationalization) can be a big headache. Working with Hebrew (or Arabic) forces you not only to change your charachters, but also to change your direction of writing. I incorporated into this module the ability to produce right-to-left menus and tested it using a legacy ASCII-based encoding (iso-8859-8).

Object Hierarchy

I designed the module to work with two other modules of mine, Tree::Numbered and Tree::Numbered::DB, which simplify the task of building the menu and allow for construction of a menu from database information.

The current version adds support for highlighting the item thats hovered over. Youll find that having made some preliminary steps, like tweaking the CSS to look the way you like it to, the rest is fairly easy.