Free 7.2 mini software for linux

Claros Mini is a multi-protocol (POP3/IMAP) Web mail client with a user interface that is specially designed for devices with small screens.

Claros Mini can parse HTML and extract text to reduce the size of messages. The installation process takes less than two minutes, and no database setup is needed.

Installation:

Claros Mini install instructions are very simple and straight-forward.

1. Drop mini.war into webapps directory at Tomcat
2. Start Tomcat
3. Edit the WEB-INF/config/config.xml file, follow the instructions.
4. Restart tomcat

Thats it. You can access the Claros Mini interface with your PDA/Mobile Phone
or any other Small Screen Device at :

http://your.domain.com:8080/mini/

If you want to test it before deploying to production, you can download
Opera Browser from http://www.opera.com and use the Shift + F11 shurtcut to
emulate the Small Screen Rendering functionallity.

Mini-XML is a small XML parsing library that you can use to read XML and XML-like data files in your application without requiring large non-standard libraries. The project only requires an ANSI C compatible compiler (GCC works, as do most vendors ANSI C compilers) and a make program.
Main features:
- Reading of UTF-8 and UTF-16 and writing of UTF-8 encoded XML files and strings.
- Data is stored in a linked-list tree structure, preserving the XML data hierarchy.
- Supports arbitrary element names, attributes, and attribute values with no preset limits, just available memory.
- Supports integer, real, opaque ("cdata"), and text data types in "leaf" nodes.
- Functions for creating, indexing, and managing trees of data.
- "Find" and "walk" functions for easily locating and navigating trees of data.
Enhancements:
- This version adds a SAX API, more convenience functions, a user data pointer to the mxml_node_t structure, and improved HTML and new man page output from mxmldoc.
- This release also offers relaxed LGPL licensing that allows static linking.

XML::Mini is a Perl implementation of the XML::Mini XML create/parse interface.

SYNOPSIS

use XML::Mini::Document;

use Data::Dumper;


###### PARSING XML #######

# create a new object
my $xmlDoc = XML::Mini::Document->new();

# init the doc from an XML string
$xmlDoc->parse($XMLString);

# You may use the toHash() method to automatically
# convert the XML into a hash reference
my $xmlHash = $xmlDoc->toHash();

print Dumper($xmlHash);


# You can also manipulate the elements like directly, like this:

# Fetch the ROOT element for the document
# (an instance of XML::Mini::Element)
my $xmlRoot = $xmlDoc->getRoot();

# play with the element and its children
# ...
my $topLevelChildren = $xmlRoot->getAllChildren();

foreach my $childElement (@{$topLevelChildren})
{
# ...
}


###### CREATING XML #######

# Create a new document from scratch

my $newDoc = XML::Mini::Document->new();

# This can be done easily by using a hash:
my $h = {
spy => {
id => 007,
type => SuperSpy,
name => James Bond,
email => mi5@london.uk,
address => Wherever he is needed most,
},
};

$newDoc->fromHash($h);



# Or new XML can also be created by manipulating
#elements directly:

my $newDocRoot = $newDoc->getRoot();

# create the < ? xml ?> header
my $xmlHeader = $newDocRoot->header(xml);
# add the version
$xmlHeader->attribute(version, 1.0);

my $person = $newDocRoot->createChild(person);

my $name = $person->createChild(name);
$name->createChild(first)->text(John);
$name->createChild(last)->text(Doe);

my $eyes = $person->createChild(eyes);
$eyes->attribute(color, blue);
$eyes->attribute(number, 2);

# output the document
print $newDoc->toString();
This example would output :
< ?xml version="1.0"? >
< person>
< name>
< first>
John
< /first>
< last>
Doe
< /last>
< /name>
< eyes color="blue" number="2" />
< /person>

XML::Mini is a set of Perl classes that allow you to access XML data and create valid XML output with a tree-based hierarchy of elements. The MiniXML API has both Perl and PHP implementations.

It provides an easy, object-oriented interface for manipulating XML documents and their elements. It is currently being used to send requests and understand responses from remote servers in Perl or PHP applications. An XML::Mini based parser is now being tested within the RPC::XML framework.

XML::Mini does not require any external libraries or modules and is pure Perl. If available, XML::Mini will use the Text::Balanced module in order to escape limitations of the regex-only approach (eg "cross-nested" tag parsing).
The Mini.pm module includes a number of variables you may use to tweak XML::Minis behavior. These include:

$XML::Mini::AutoEscapeEntities - when greater than 0, the values set for nodes are automatically escaped, thus $element->text(4 is > 3) will set the contents of the appended node to 4 is > 3. Default setting is 1.

$XML::Mini::IgnoreWhitespaces - when greater than 0, extraneous whitespaces will be ignored (maily useful when parsing). Thus Hello There will be parsed as containing a text node with contents Hello There instead of Hello There . Default setting is 1.

$XML::Mini::CaseSensitive - when greater than 0, element names are treated as case sensitive. Thus, $element->getElement(subelement) and $element->getElement(SubElement) will be equivalent. Defaults to 0.

The X.Org Foundation provides an open source implementation of the X Window System. The development work is being done as part of the freedesktop.org community.

mBox is program intended to help you with organizing your music files.
Main features:
- ability to reencode mp3/ogg/wma to mp3/ogg
- contains utility convertor which converts whole directories to desired format. Bitrate, etc. is automatically adjusted depending on settings and source audio. See users-guide for further information
- supports reading/writing tags in MP3 ID3v1 and ID3v2, Ogg Vorbis
- supports reading WMA tags
- supports FreeDB, treates encoded files as if it was CD, so you can simply select your files and - if found in database - write tags to them. Nifty, isnt it? =)
- supports auto tagging - reads tag information from filename
- supports batch tags editing
- supports batch files renaming (can use tags)
- supports directory renaming (can use tags)
Enhancements:
- This version brings several small improvements in tag reading, file renaming and FreeDB searching.

DelVJ is a software for realtime video 3d composition and algorithmic remixing.
Delvj uses gtk, python, glade and puredata.
It can be given indications for the objects, videos, and effects, and the computer can do the rest. It features a GTK+ interface that runs puredata in the background, controls xmms, and allows tweaking of all patch parameters, recording of videos, and streaming to an Icecast server.
It can be controlled through OSC, and has web and gtk interfaces. For Pixel fests of many kinds. Furthermore, it is licensed under GNUs GPL.
Enhancements:
- Many new options and a much better gtk interface.
- Debian packages and tar.gz have been updated.
- Ubuntu users beware as currend debian packages are too new for hoary, new packages for that distro have been created and are looking for hosting.
- Most important delvj is now multilanguage, with english, spanish and catalan supported.
- Many new translations will some day follow.

gpkcs11 provides support functions to make the development of support for new tokens easier and contains a complete software token, as well as an automated testing environment.

gpkcs serves as a testing tool in the development of new applications that contain cryptographic support.

A core of the functions have been implemented, but still need a lot of testing. The following features are lacking at this time (03/00), but will be implemented ASAP:

- propper SO/token reset support
- thread save
- multi session/multi app support

If you have need for another feature not yet implemented, give me a holler. Even though I will probably ask for your cooperation, I might bump it up on my feature list. But I consider this library only of use to the hardened crypto developer, therefore will assume that you are able to help further the development.

This code is now usable with the Netscape Communicator! I found out that it is due to a collision between symbols in the libcrypto and symbols within the Communicator. Therefore this release now does some magic to the OpenSSL code before compiling and linking it to the ceay token.