Free fakes are never in fashion software for linux

The amaroK bindings for Python is a fairly complete amaroK remote control class. It is extremely useful for amaroK scripts and other applications. Basically, you can remote control amaroK by calling methods from an amaroKProxy instance.

In addition, it implements the Observer/Observable pattern so you can deal with events in an object-oriented, loosely coupled fashion. Even better, you can call an amaroKProxy instances collection.getSong(filename) method to get a Song object, with track, artist, album name, and elegant "Artist - Track name" strings.

Nearly all DCOP functions for communication with amaroK are implemented.

It will use KDE bindings DCOP module if available, otherwise it will default to the command-line DCOP dcop command, through python-commandsplus. If using KDE bindings, a slave process is spawned, and IPC is used to marshal and unmarshal function calls, so as to not contaminate your applications sys.modules with KDEs Python modules. This all happens automatically in the background.

To use it, you import the module in your script and instantiate an amaroKProxy instance, then call your instances startMonitoring() method, which will start reading from standard input, monitoring for amaroKs events. You can then sleep(1) until your instances .isAlive() method returns False (which means amaroK is now gone.

amaroKProxy is an Observable class, and so are its members:

- player
- contextBrowser

This means that you can implement Observer objects or Threads in your amaroK script, and have them be notified of amaroK events, instead of having to read standard input and act accordingly (plus error-prone exceptional condition handling).

C Generic Library is a generic data structure library is a bunch of data structures that are designed and created in as generic a fashion as possible.
Each data structure will contain its own basic memory management, be able to handle any object type, and hopefully constraint to strict algorithmic constraints. When the library hits version 1.0, it will contain the following data structures:
- Doubly Linked List - Done
- List-based Queue - Done
- List-based Deque - Done
- List-based Stack - Done
- Vector - Done
- Vector-based Queue - Done
- Vector-based Deque - Done
- Vector-based Stack -Done
- Binary Tree - Done(No BFS/DFS iterators)
- Hash Table - In progress
- Priority Queue - In progress
- Heap - In progress
- Memory Manager
- Object Cache w/ Garbage Collection
- AB Tree
- Split Lists
- RB Tree
- AVL Tree
Enhancements:
- Support for compilation on Windows using VS.net was added.

Chess::Game::MoveList is a specialized list class for recording the moves of a Chess::Game.

SYNOPSIS

$movelist = Chess::Game::MoveList->new("white", "black");
$wpawn = Chess::Game::Pawn->new("e2", "white");
$entry = $movelist->add_move($wpawn, "e2", "e4");
$true = $entry->get_piece() eq $entry;
$bpawn = Chess::Game::Pawn->new("e7", "black");
$entry = $movelist->add_move($bpawn, "e7", "e6");
$entry = $movelist->add_move($wpawn, "e4", "e5");
@del_entries = $movelist->delete_move(1, "white"); # delete the list
$true = $entries[0]->get_piece() eq $wpawn;
$true = $entries[0]->get_dest_square() eq "e4";
$true = $entries[1]->get_piece() eq $bpawn;
$true = $entries[1]->get_dest_square() eq "e6";

The Chess module provides a framework for writing chess programs with Perl. This class forms part of that framework, recording a log of all moves during a Chess::Game in such a fashion that the list can be used to undo moves that have been made.

Ghost In The Mail is an anonymous e-mail client for linux written in C and designed in GTK+ 2. Look at the screenshots below to have a better idea of how does it works.
This piece of software allows to send e-mails to any person over the net with a fake email address, and also a fake name. Obviously you can use your true identity. gitmail can also send attached files. Ghost In The Mail uses MIME and Base64 technologies.
Enhancements:
- Full review of the code in order to improve stability and performances.
- Rewrite of all functions that contained malloc(CONST_VAL).
- Added functions gitm_malloc & gitm_realloc that check pointers after allocating them.
- Added some commentaries to describe functions.
- New sources files: functions are distributed into files in a more logical way.
- Files cbbentries.* removed (functions in cbbentries.* are now in history.*) Better core/gui splitting.
- Created a constant GITM_VERSION to hold the version number.
- MIME boundary is now randomly generated.
- Server errors are fully displayed.

Barter is an integration of the Bazaar revision control system into Nautilus.
Barter is an extension for the Nautilus file-manager. It provides a series of context-menu items and property panels to make management of Arch archives.
One of Barters chief aims is to be as intuitive as is feasible, integrating with the file-manager in a clean and natural fashion. It doesnt attempt to be a complete interface to this notoriously complete versioning system, it just aims to cover the functionality people will be using most often.
Please remember that this is an experimental project in its early stages so it isnt intended for general use yet (although by all means use it and let me know how you find it.) It uses several new and rough technologies, not least the python Extensions API itself. As such it is very much for the bleeding edge, experimenting user.
Main features:
- Context-menu support for add, remove, get, merge, branch, commit, update, new archive and new project
- Automatic generation of changelogs
- Able to forward to mirrors on commit
- Reflection of arch information into RDF for integration with common ontologies such as Dublin Core, FOAF, DOAP and Annotea (to do)
- File, archive and working tree property panels to display metadata (to do)
- Information and metadata reflection into the Frege information store (optional)

OurNet::Query is a Perl module for scriptable queries with template extraction.

SYNOPSIS

use OurNet::Query;

# Set query parameters
my ($query, $hits) = (autrijus, 10);
my @sites = (google, google); # XXX: write more templates!
my %found;

# Generate a new Query object
my $bot = OurNet::Query->new($query, $hits, @sites);

# Perform a query
my $found = $bot->begin(&callback, 30); # Timeout after 30 seconds

print *** . ($found ? $found : No) . match(es) found.;

sub callback {
my %entry = @_;
my $entry = %entry;

unless ($found{$entry{url}}) {
print "*** [$entry->{title}]" .
" ($entry->{score})" .
" - [$entry->{id}]n" .
" URL: [$entry->{url}]n";
}

$found{$entry{url}}++;
}

This module provides an easy interface to perform multiple queries to internet services, and wraps them into your own format at once. The results are processed on-the-fly and are returned via callback functions.

Its interfaces resembles that of WWW::Searchs, but implements it in a different fashion. While WWW::Search relies on additional subclasses to parse returned results, OurNet::Query uses site descriptors for search search engine, which makes it much easier to add new backends.

Site descriptors may be written in XML, Template toolkit format, or the .fmt format from the commercial Inforia Quest product.

IrNET is a protocol allowing to carry TCP/IP traffic between two IrDA peers in an efficient fashion. It is a thin layer, passing PPP packets to IrTTP and vice versa. It uses PPP in synchronous mode, because IrTTP offer a reliable sequenced packet service (as opposed to a byte stream). In fact, you could see IrNET as carrying TCP/IP in a IrDA socket, using PPP to provide the glue.

The main difference with traditional PPP over IrCOMM is that we avoid the framing and serial emulation which are a performance bottleneck. It also allows multipoint communications in a sensible fashion.We can automatically handle incomming connections through irnetd.


The main difference with IrLAN is that we use PPP for the link management, which is more standard, interoperable and flexible than the IrLAN protocol. For example, PPP adds authentication, encryption, compression, header compression and automated routing setup. And, as IrNET let PPP do the hard work, the implementation is much simpler than IrLAN.

IrNET was first introduced by Microsoft in the IrDA stack of Windows 2000, and they decided to remove both IrCOMM and IrLAN in favor of IrNET in their new IrDA stack. IrNET is a great idea (removing IrLAN and IrCOMM, on the other hand...), however IrNET is not an IrDA specification (at least, not yet, but there are rumors of something called IrDial...).

IrNET has been included in Linux kernel 2.4.0-test11, so all subsequent version of the kernel should support it out of the box (provided everything is set up properly). The latest version is in Linux kernel 2.4.15.

Common Media Input Layer (CMIL) is an C++ OO framework designed to improve the state of cross-platform input handling in games and other similar applications.
CMIL was created out of the belief that the methods used in most media APIs perform input handling in a confusing, difficult, inflexible fashion. CMILs goal is to address this issue by establishing a flexible, easy to use, human readible, OO abstraction layer. This layer specifically allows for media and input device abstraction.
Main features:
- easiliy build complex input sequences, including timed inputs, which do not impose restrictive notions of what is and isnt a moderator on the user
- custom input device configurations, IE: Users can swap input device configurations on the fly and create their own representation of a custom device using the framework facilities