Cairo-Dock is a light and eye-candy dock to launch your programs easily. It uses
Cairo / OpenGL to render nice graphics (many in correlation with Compiz) with
hardware acceleration. It's fully configurable and customizable and can be a
taskbar too. You can easily plug applets into it or in a desklet mode.
This perl routine will take a prompt, a default response and a list
of possible responses and deal with the user interface, (and the
user!), by displaying the prompt, showing the default, and checking
to be sure that the response is one of the legal choices.
Test::Bits provides a single subroutine, bits_is(), for testing binary data.
This module is quite similar to Test::BinaryData and Test::HexString in concept.
The difference is that this module shows failure diagnostics in a different way,
and has a slightly different calling style. Depending on the nature of the data
you're working with, this module may be easier to work with.
File::ShareDir::Install allows you to install read-only data files from a
distribution. It is a companion module to File::ShareDir, which allows you to
locate these files after installation.
It is a port Module::Install::Share to ExtUtils::MakeMaker with the improvement
of only installing the files you want; .svn and other source-control junk will
be ignored.
This library implements a system by which 2 image files can be
compared, using a variety of comparison methods. In general, those
methods operate on the images on a pixel-by-pixel basis and reporting
statistics or data based on color value comparisons.
Math::Expr parses mathematical expressions into a tree structure.
The expressions may contain integers, real numbers, alphanumeric
variable names, alphanumeric function names and most other characters
might be used as operators. The operators can consist of multiple
characters. The only limitation is that a variable or function
name may not start on a digit, and not all chars are accepted in
operation names.
XML::Twig - Tree interface to XML documents allowing chunk by chunk
processing of huge documents.
From the website:
XML-Twig is a Perl module that subclasses XML-Parser to allow easy
processing of XML documents of all sizes. A flush method allows dumping of
a completely processed sub-document to be printed, thus allowing processing
of documents of any size.
treewm is a window manager that tries to implement a new concept. In
addition to the client windows the user can create desktops which can
themselves contain windows and desktops. By arranging the windows in
such a tree the user is able to manage his tasks efficiently treewm is
feature-rich, flexible and provides a powerful concept. However,
treewm's look is is rather puristic, and its feel is not always
intuitive, but with a bit of practise it should be very effective to
use.
Short feature list (some of them are quite unique among window managers):
- Allows to create desktops and to arbitrarily move windows between
desktops
- Many options (such as sticky, autoresize, always on top, or the
focus or raise policy) can be set for any desktop or window
- Can be fully customized using the configuration file
- Has a very powerful (somewhat vi-like) command mode, and can be
controlled from shell scripts via a FIFO
- Icons can be placed on desktops that can execute arbitrary commands
- Only uses very common libraries, in particular it doesn't require
GTK, Qt, or anything like that
The `exhaust' project is a redcode simulator that is (hopefully)
easy to embed into your applications, as an alternative to pMARS.
The documentation contains the following:
README - Instructions to embed exhaust in a program.
test.pl - Perl script to check for differences between exhaust
and pMARS.
src/ - The C source code of exhaust (highly commented).
warriors/ - Test warriors.
The "warriors" subdirectory contains Redcode assembly files (.red)
and parsed Redcode assembly files (.rc). The last ones can be loaded
into exhaust, the others have to be parsed, for example with pMARS.
NOTE: this documentation is only useful for developers.
A library that performs fast, accurate conversion between double
precision floating point and text. This library is implemented as
bindings to the C++ double-conversion library written by Florian Loitsch
at Google: http://code.google.com/p/double-conversion/.
The Text versions of these functions are about 30 times faster than the
default show implementation for the Double type. The ByteString versions
are slower than the Text versions; roughly half the speed. (This seems
to be due to the cost of allocating ByteString values via malloc.)
As a final note, be aware that the bytestring-show package is about 50%
slower than simply using show.