Free children software for linux

Childsplay is a suite of educational games for young children, like gcompris, but without the overkill of c/c++ and the gnome environ.

Also the use of the SDL libraries makes smooth animation and the playing of sound very easy. Childsplay uses a plugin system for the games, so you might want to check the childsplay-plugins page. (There are two built-in games; Memory and a typing game)

Childsplay and the games are GNU-GPL licensed and are tested on GNU/Linux, FreeBSD.

SMILGen is a SMIL (and XML) authoring tool designed to ease the process of XML content creation. SMILGen understands XML syntax and handles the nesting and formatting XML.
This allows authors to worry about the content that they are trying to author with out having to remember each quote and closing brace. SMILGen also understands the languages it authors, it knows what attributes a specific element uses or what child elements a given element may contain.
Both of these features help eliminate a number of common XML syntax errors as well as making it easier to edit with out having a reference to the language right by your side.
Internally SMILGen uses objects to represent each known element. The element objects know what children they may contain or what attributes they have. SMILGen uses this information to assist content authors by letting them know what children an element may contain or by displaying the attributes for a given element when it is edited.
SMILGen also has namespace support both for known namespaces and unknown namespaces. Known namespaces can be imported into any document at which point all of their attributes and elements become available to the document. Unknown namespaces can be parsed as well.
Although SMILGen is not psychic and will not know about elements or attributes that are NOT in the document, it will generate a namespace representation of the imported namespace and it will deduce what elements and attributes are available in the namespace based upon the data in the document.
SMILGen currently supports SMIL 1, SMIL 2 and RealPix. It is designed to be modular. Any xml language that does not use #PCDATA can have a class representation created with out a great deal of effort. Future versions (1.5-2.0 time frame) will also have support for xml languages that allow #PCDATA and inline attributes.
Version restrictions:
- Active element highlight doesnt stretch to full window width if the window is widened past the width of the widest element. Need to find a way to get the window width if its larger and update to that.
- Line wrapping isnt doing a great job, doesnt seem to take into account the indent and line number width on lines after the first (except with in comments).
- Windows versions have a focus issue with tear off menus where the last selected menu stays selected and you need to select a diferent menu in order to be able to re select the first one.
- Does not happen on PPC Linux sys. Tkinter issue?
- Test document functionality uses temp files in a temp directory. This doesnt work well if valid relitive paths are used cause they wont actualy be relitive. Test doc only works for fully qualified paths. Need to write temp docs to temp file in same location as saved doc and then remember them to clean them up when done.
- Documents containing qualified namespace attributes that are child attributes of an element of the current namespace will fail. ( This work is in development right now and will be fixed by 1.0 ).
- Pop-up menus on Windows platforms seem to "drop through" some times when they are clicked, causeing the underlying window to recieve the click.
- Does not happen on Linux sys. Win Tkinter issue?

Texplore is a type explorer for GObject based libraries. You can see what signals, properties, and other things are present in each type, its parents, and its children.

Its similar to System.Reflection.Emit from Mono, only it uses the GObject librarys API and introspection capabilites.

Installation:

./autogen.sh
./configure --prefix=/tmp
make
make install
$/tmp/bin/texplore & #yove done it

IVS Milter provides a virus, spam, and content filtering milter.
IVS Milter is a virus, spam, and content milter. It makes use of the antivirus package ClamAV, and can also seamlessly integrate SpamAssassin (either spamc or libspamc).
IVS Milter is also plugin based and currently supports virus scanning, spam scanning, content-type matching, attachment type matching, and attachment filename matching.
Whats New in 1.0.7 Stable Release:
- Pointer NULL reference fixed
- Fixed bug where glib was generating CRITICAL messages
- Documentation update
- Implemented SIGUSR1 to dynamically reload configuration file
- Added support to reload directories of configuration files
- Fixed possible segfault when no configuration file
Whats New in 2.0.0 Pre7 Development Release:
- Spamassassin 3.0 support added, although there have been reports of memory leaks when using the ENHANCED libspamc method, best to specify to have the scan forked and run instead of library call for now
- Added thresholds so we can learn about spam, especially if you add your own rules you can force say everything over 100 to be learnt as spam
- Fixed support for limiting how many children we can spawn, this now works!
- Various bug fixes and small changes
- Fixed a bug where clamav only checked first file of attachment for virus

libredblack is a library to provide the RedBlack balanced tree searching and sorting algorithm.

The algorithm was taken from the book "Introduction to Algorithms" by Cormen, Leiserson & Rivest. Frankly I never entirely understood it, but it most definately works!

What is the problem with normal binary trees?: A standard binary tree only works well if the original data is provided in a random order (random in terms of the key being sorted on). If however the data is provided in order, then the tree becomes very un-balanced and searches degrade into nothing more than a linked list.

How is the RedBlack tree different?: The RedBlack tree acts in a way to keep the overall tree fairly balanced as new data is loaded in.

How does it work?: The tree is always organised such that it has the following properties:

Every node is either Red or Black.

A leaf node (a dummy empty node at the end of the tree) is always Black.
If a node is Red then its children are Black.

Every path from the root to a leaf contains the same number of Black nodes.
So from 3 & 4 above, we can see that the longest path (alternating Red and Black nodes) is only twice as long as the shortest path (all Black nodes). Thus the tree remains fairly balanced.

Great! How does it maintain those properties?: Ah, well, thats where I get a bit hazy. I know that it does this by adding Red nodes and then rotating the tree elements and changing the colours to sort out times when two Red nodes become parent-child (breaking rule 3).

HTML::ElementSuper is a Perl extension for HTML::Element(3).

SYNOPSIS

use HTML::ElementSuper;

### Positional extension
$e = new HTML::ElementSuper font;
$sibling_number = $e->addr();
$e2 = new HTML::ElementSuper p;
$e2->push_content($e);
#
@coords = $e->position();
$depth_in_pos_tree = $e->depth();

### Replacer extension
$er = new HTML::ElementSuper font;
# Tree beneath $er, if present, is dropped.
$er->replace_content(new HTML::Element p);

### Wrapper extension
$ew = new HTML::ElementSuper;
$ew->push_content("Tickle me, baby");
$ew->wrap_content(new HTML::Element font, color => pink);
print $ew->as_HTML();

### Maskable extension
$em = new HTML::ElementSuper td;
$em->mask(1);
print $em->as_HTML; # nada
$em->mask(0);
print $em->as_HTML; # $e and its children are visible

### Cloning of own tree or another elements tree
### (is this the correct clomenature? :-)
$a = new HTML::ElementSuper font, size => 2;
$b = new HTML::ElementSuper font, color => red;
$a_clone = $a->clone;
$b_clone = $a->clone($b);
# Multiple elements can be cloned
@clone_clones = $a_clone->clone($a_clone, $b_clone);

The KLogo-Turtle is an interpreter of the LOGO language for KDE desktops.
The KLogo-Turtle is a useful tool for teaching geometry and the basic principles of the programming of computer. Children can study the mathematics of geometry in an interactive and constructive way.
KLogo-Turtle has syntax a little different than the LOGO language developed at MIT. Look at the documents link. Comments, doubts and suggestions, please use the e-mail link.
KLogo-Turtle supports commands in the languages english, portuguese, german, italian and french.
KLogo-Turtle is under the GPL license and is developed in KDevelop by Euclides Chuma.
Enhancements:
- Release version stable (0.6) with support for commands in english, portuguese, german, italian and french.

IMAPFilter is a mail filtering utility. It connects to remote mail servers using the Internet Message Access Protocol (IMAP), sends searching queries to the server and processes mailboxes based on the results.
IMAPFilter can be used to delete, copy, flag, move, etc. messages residing in mailboxes at the same or different mail servers. The 4rev1 and 4 versions of the IMAP protocol are supported.
IMAPFilter uses the Lua programming language as a configuration and extension language.
Main features:
- Definition of filters using many searching criteria available in the IMAP protocol, such as:
- Matching of a string in the headers or the body of a message.
- Size of a message.
- Date of a message.
- Status (recent, unread, etc.) of a message.
- Ability to use logical operators (and/or/not) while defining filters.
- Different actions when a filter matches a message, including:
- Deleting of a message.
- Moving of a message to a mailbox in the same of different servers
- Copying of a message to a mailbox in the same or different servers.
- Changing of a messages flags.
- Listing of the available and/or subscribed mailboxes, along with support for the IMAP CHILDREN extension.
- Internationalisation (I18N) support.
- Server namespace support using the IMAP NAMESPACE extension.
- Secure Socket Layer (SSL) or Transport Layer Security (TLS) encrypted imaps (port 993) connections.
- Encrypted connections using the IMAP STARTTLS extension.
- User authentication with the Challenge-Response Authentication Mechanism (CRAM), specifically CRAM-MD5.