Free defined benefit software for linux

Speegle Define is a Firefox extension that gives a spoken definition of a word using Speegle Speech Technology. You highlight the word you would like explained with highlight left click on any internet page you are reading.

Right click and choose "Audio Definition" from the pop up menu and its definition will be read back to you in English through your speakers or headphones.

DirHandle is a Perl module created to supply object methods for directory handles.

SYNOPSIS

use DirHandle;
$d = new DirHandle ".";
if (defined $d) {
while (defined($_ = $d->read)) { something($_); }
$d->rewind;
while (defined($_ = $d->read)) { something_else($_); }
undef $d;
}

The DirHandle method provide an alternative interface to the opendir(), closedir(), readdir(), and rewinddir() functions.

The only objective benefit to using DirHandle is that it avoids namespace pollution by creating globs to hold directory handles.

NOTES

On Mac OS (Classic), the path separator is :, not /, and the current directory is denoted as :, not .. You should be careful about specifying relative pathnames. While a full path always begins with a volume name, a relative pathname should always begin with a :. If specifying a volume name only, a trailing : is required.

Filesys::Df is a Perl extension for filesystem disk space information.

SYNOPSIS

use Filesys::Df;

#### Get information by passing a scalar directory/filename value
my $ref = df("/tmp"); # Default output is 1K blocks
if(defined($ref)) {
print "Total 1k blocks: $ref->{blocks}n";
print "Total 1k blocks free: $ref->{bfree}n";
print "Total 1k blocks avail to me: $ref->{bavail}n";
print "Total 1k blocks used: $ref->{used}n";
print "Percent full: $ref->{per}n";

if(exists($ref->{files})) {
print "Total inodes: $ref->{files}n";
print "Total inodes free: $ref->{ffree}n";
print "Inode percent full: $ref->{fper}n";
}
}

#### Get information by passing a filehandle
open(FILE, "some_file"); # Get information for filesystem at "some_file"
my $ref = df(*FILE);
#### or
my $ref = df(*FILE);
#### or
my $fhref = *FILE;
my $ref = df($fhref);

#### Get information in other than 1k blocks
my $ref = df("/tmp", 8192); # output is 8K blocks
my $ref = df("/tmp", 1); # output is bytes

This module provides a way to obtain filesystem disk space information. This is a Unix only distribution. If you want to gather this information for Unix and Windows, use Filesys::DfPortable. The only major benefit of using Filesys::Df over Filesys::DfPortable, is that Filesys::Df supports the use of open filehandles as arguments.

The module should work with all flavors of Unix that implement the statvfs() and fstatvfs() calls, or the statfs() and fstatfs() calls. This would include Linux, *BSD, HP-UX, AIX, Solaris, Mac OS X, Irix, Cygwin, etc ...

df() requires a argument that represents the filesystem you want to query. The argument can be either a scalar directory/file name or a open filehandle. There is also an optional block size argument so you can tailor the size of the values returned. The default block size is 1024. This will cause the function to return the values in 1k blocks. If you want bytes, set the block size to 1.

df() returns a reference to a hash. The keys available in the hash are as follows:
{blocks} = Total blocks on the filesystem.
{bfree} = Total blocks free on the filesystem.
{bavail} = Total blocks available to the user executing the Perl application. This can be different than {bfree} if you have per-user quotas on the filesystem, or if the super user has a reserved amount. {bavail} can also be a negative value because of this. For instance if there is more space being used then you have available to you.
{used} = Total blocks used on the filesystem.
{per} = Percent of disk space used. This is based on the disk space available to the user executing the application. In other words, if the filesystem has 10% of its space reserved for the superuser, then the percent used can go up to 110%.
You can obtain inode information through the module as well, but you must call exists() on the {files} key first, to make sure the information is available. Some filesystems may not return inode information, for example some NFS filesystems.
Here are the available inode keys:
{files} = Total inodes on the filesystem.
{ffree} = Total inodes free on the filesystem.
{favail} = Total inodes available to the user executing the application. See the rules for the {bavail} key.
{fused} = Total inodes used on the filesystem.
{fper} = Percent of inodes used on the filesystem. See rules for the {per} key.

There are some undocumented keys that are defined to maintain backwards compatibilty: {su_blocks}, {user_blocks}, etc ...

If the df() call fails for any reason, it will return undef. This will probably happen if you do anything crazy like try to get information for /proc, or if you pass an invalid filesystem name, or if there is an internal error. df() will croak() if you pass it a undefined value.

FSP Client is single executable client for the FSP protocol. Client uses an FTP-like user interface. People usually find this program easier to use that multiple client programs in FSP protocol suite. If you are at least somewhat familiar with command line FTP and want to try FSP, this program is a good choice for you.
There is a help command; not a very good one, but it does tell you the commands. Type `help to get a list of all commands; to get a brief description of a command, type `help name (`name being the command); to get brief help on all commands type `help all (warning: there are 46 commands).
See the manual page fsp(1) for a somewhat longer description...
Note for versions since 0.0-g: the command `cat, `get, `du, and `tar can all take a `-r flag -- this causes the commands to process subdirectories as well as files. e.g., `du will give the disk usage of the current directory; `du -r will give the disk usage of the current directory and _all_ subdirectories (resursively). The `timeout command causes communications to return an error code if the timeout occurs; this means that:
timeout 30
pro
iferror exit
is a good way of determining whether a remote site is alive or not when writing scripts. The `ver should only return an error if the timeout occurs -- however, pre-2.6.3 servers return version strings as an error which messes up that usage...
Macros are, for want of a better word, stupid. Until parameter variables are allowed, they can not do very much. Common ones (and user set up options) should be defined in the file ~/.fsprc (i.e., .fsprc in your home directory). This filename can be changed by setting the environment variable FSPRC. An example .fsprc is supplied in the file `fsprc in this directory.
It is also now possible to have commands like:
ls -l | less
Anything after the first `| symbol is fed the output of the builtin command...
rehash may need a little explanation -- when you do an ls, the directory information is fetched to the local end and stays there (thanks to the original authors stuff); if you want to check if anything has been updated since you did an ls of a directory, then you must rehash first. The client is now a bit more intelligent than it used to be (i.e., pre `d release); it will automatically mark directories as out-of-date if it knows that it has modified them (e.g., by put, or mkdir or whatever). Its the wrong command name, but it brings back fond memories of csh... It may sound like a disadvantage -- in fact it is an enormous benefit having it work this way... *much* faster.
All the commands which have a f equivalent in the original distribution behave as before; well, pretty much.
Oh, one last thing -- command lines cant have continuations... yet.
-------------------------------------------------------------------------------
If you use it and like it, mail me. I need the encouragement If you use it and dont like it, mail me. I need bringing back down to earth...
Basically, even though it is pre-alpha, I would still like to know whether people like it or not... just dont complain too loud when it doesnt work right :-)
Enhancements:
- fsprc: wrack removed, decss added
- fixed statistics printing in stat command
- client/util.c add static prototype declaration
- avoid hammering of down sites
- fsprc: another FSP site added

Apache Xindice is a database designed from the ground up to store XML data or what is more commonly referred to as a native XML database. The name is pronounced zeen-dee-chay in your best faux Italian accent. Dont worry if you get it wrong though, we wont mind. We just care that you spell it correctly.
You might be wondering what a native XML database is good for? Well it pretty much has one purpose, storing XML data. If you dont have any XML data, dont want any XML data or think XML is the most over-hyped technology of the new millennium, then Xindice is not for you. Were not out to change the way data in general is stored, only to provide a good solution for storing XML data. If you survey your projects and see XML popping out of every corner, then Xindice might be a real help for storing that XML.
The benefit of a native solution is that you dont have to worry about mapping your XML to some other data structure. You just insert the data as XML and retrieve it as XML. You also gain a lot of flexibility through the semi-structured nature of XML and the schema independent model used by Xindice. This is especially valuable when you have very complex XML structures that would be difficult or impossible to map to a more structured database.
At the present time Xindice uses XPath for its query language and XML:DB XUpdate for its update language. We provide an implementation of the XML:DB API for Java development and it is possible to access Xindice from other languages using built in XML-RPC API. As standards in the XML database area mature Xindice will include support for those that are most important.
Xindice is the continuation of the project that used to be called the dbXML Core. The dbXML source code was donated to the Apache Software Foundation in December of 2001.
Native XML database technology is a very new area and Xindice is very much a project still in development. The server currently supports storing well formed XML documents. This means it does not have any schema that constrains what can be placed into a document collection. This makes Xindice a semi-structured database and provides tremendous flexiblity in how you store your data, but, also means you give up some common database functionality such as data types. In its current state Xindice is already a powerful tool for managing XML data. However, there is still much that needs to be done. Feedback and contributions are actively encouraged.
This document attempts to describe those features that are working and can be used today. You should review the README file that is part of the Xindice distribution for the most current status on the project.
Main features:
- Document Collections: Documents are stored in collections that can be queried as a whole. You can create collections that contain just documents of the same type or you can create a collection to store all your documents together. The database doesnt care.
- XPath Query Engine: To query the Document Collections you use XPath as defined by the W3C. This provides a reasonably flexible mechanism for querying documents by navigating and restricting the result tree that is returned.
- XML Indexing: In order to improve the performance of queries over large numbers of documents you can define indexes on element and attribute values. This can dramatically speed up query response time.
- XML:DB XUpdate Implementation: When you store XML in the database you may want to be able to change that data without retrieving the entire document. XUpdate is the mechanism to use when you want to do server side updates of the data. It is an XML based language for specifying XML modifications and allows those modifications to be applied to entire document collections as well as single documents.
- Java XML:DB API Implementation: For Java programmers Xindice provides an implementation of the XML:DB API. This API is intended to bring portability to XML database applications just as JDBC has done for relational databases. Most applications developed for Xindice will use the XML:DB API.
- Command Line Management Tools: To aid the administrator Xindice provides a full suite of command line driven management tools. Just about everything you can do through the XML:DB API can also be done from the command line.
- Modular Architecture: The Xindice server is constructed in a very modular manner. This makes it easy to add and remove components to tailor the server to a particular environment or to embed it into another application.
- Database Structure
- The Xindice server is designed to store collections of XML documents. Collections can be arranged in a hierarchy similar to that of a typical UNIX or Windows file system.
- In Xindice the data store is rooted in a database instance that can also be used as a document collection. This database instance can then contain any number of child collections. In a default install of Xindice the database instance is called db and all collection paths will begin with /db. It is possible to rename the database instance if desired though it is not necessary to do so.

Media Listings project aims to provide a comfortable way to see the TV listings of supported TV channels. More exactly, it displays defined number of programs, which are yet to come, based on current date and time.

Clicking one of the displayed programs will start your default browser and navigate to appropriate additional info page of the program.

The Useful Terminal I/O library is a an alternative to ncurses for working with terminfo-defined terminals.
Included are raw terminfo string access and output, an efficient buffered output system, and a keyboard driver.
Enhancements:
- This release fixes some problems when running under 2.6 kernels and some CGC crashes caused by incorrect clipping.