Free well to software for linux

eL DAPo is a PHP-based application for managing and querying LDAP servers. It can rename, modify, and delete LDAP entries, as well as modify, add, and delete attributes associated with an entry.
Search filters can be changed while a session is open, so users only have to bind with the LDAP server once.
eL DAPo also includes a configuration file to make it fit well to your current schema.
Enhancements:
- Fixed security bug where looking at index.phps source from the browser revealed the users password.
- Session code has been changed so that eL DAPo no longer relies on register_globals to be enabled.
- Fixed a intermittent bug where eL DAPo complains you have not selected a server or base dn.
- Set index.php to redirect to the login page if you have not logged in.
- Added a check to let the user know if they have not enabled the LDAP module for php.
- Code Cleanup

OO Text To Speech is a text-to speech macro for OpenOffice.org.

Its a syllable analyzer: using a reading motor, it reads a document and translates it into a vocal message.

About OpenOffice

OpenOffice.org is a multiplatform and multilingual office suite and an open-source project. Compatible with all other major office suites, the product is free to download, use, and distribute.

It is an international office suite that will run on all major platforms and provide access to all functionality and data through open-component based APIs and an XML- based file format.

EZ Improver works well to improve dull, dingy images.

Leaving the Merge Layers option un-checked allows you to tweak the layer opacities if desired.

OBEX Send to Phone service menu allows for sending any file(s) to a mobile phone equipped with OBEX stack.

It is made for Nokia S60 (6630 to be precise) phone with USB connection. There are no settings, no progress indicator. Files are copied to the memory card (E: drive)

Requires openobex and obexftp.

Hope this script might be useful for someone. Please post fixes, comments and suggestions.

Kye is a clone of the classic puzzle game Kye to Linux (well, to Python and pygtk, so it should run on most platforms where those are available). If you want to know what Kye is about, read here.

Python Kye is written and maintained by me, Colin Phipps. News of new Python Kye releases will be posted here.

Kye is an unusual little puzzle game, with a variety of different types of objects. It takes a little time to figure out all the objects and their normal behaviour; so I have included 6 starter levels to introduce the different objects and different types of level you see them in. Once you have a feel for the game, there are plenty of extra levels to choose from. I have put together a levels page, which picks out some of the easier level sets for people getting started. The levels vary enormously in difficulty, so once you are finding the levels easy, look for a harder set.

See the other pages on this site for more information about the game, and suggestions for levels to play. The site on classicgaming also has lots of good information. I have also started a mailing list as a discussion forum to allow people to discuss levels and level design ideas.

This is a clone of the original Kye, but it is a good one. I have done my best to make it as authentic to the original game as possible (and when I say my best, people who have seen PrBoom will know I take this seriously). It mimics the original, including some of the unusual/buggy things which occur in the original game. It should be compatible with all levels for v1.0 and v2.0 of the original Windows version of Kye. Let me know if you find a level which seem not to work right (*).

Gem to rpm converter creates an RPM spec file from a Ruby gem. The project uses the gem metadata to fill out most of the information needed for building an RPM containing the gem.

Usage:

Run gem2rpm --help for options

At its simplest, download a gem (lets call that file GEM) and run

gem2rpm $GEM

This will print an rpm spec file based on the information contained in the gems spec file. In general, it is necessary to edit the generated spec file because the gem is missing some important information that is customarily provided in rpms, most notably the license and the changelog.

Rather than editing the generated specfile, edit the template from which the specfile is generated. This will make it easier to update the RPM when a new version of the Gem becomes available.

To support this process, it is recommended to first save the default template somewhere:

gem2rpm -T > rubygem-GEM.spec.template

Now, edit the template and then run gem2rpm to generate the spec file using the edited template:

gem2rpm -t rubygem-GEM.spec.template > rubygem-GEM.spec

With that, you can now build your RPM as ususal. When a new version of the gem becomes available, you should edit the saved template and rerun gem2rpm over it.

Template Details:

The template is a standard erb file; there are three main variables available in the template file:

format - The Gem::Format for the gem
spec - The Gem::Specification for the gem (the same as format.spec)

Conventions:

A typical source RPM for a gem should consist of three files: the gem file itself, the template for the spec file and the spec file. To ensure that the template will be included in the source RPM, it must be listed as one of the sources in the spec file.

The resulting rpms should follow the naming convention rubygem-$GEM where GEM is the name of the packaged gem. The default template also makes sure that the resulting package provides ruby($GEM), according to general packaging conventions for scripting languages

Time::Elapse is a Perl extension for monitoring time conveniently during tasks.

Time::Elapse is a very simple class with one method: lapse.

Basically, the lapse method eats the brains of the variable, squirrels away whatever value it may have held internally, (much like space aliens are known to do in the movies), and also stores the current time within it. Then, whenever you access the value of the variable, the alien within formats the time differential between when you initialized the variable, and when you printed it, and returns that (along with any value the variable may hold, as well). :-) Every time you print it, you get the updated differential, returned by the method hidden inside the variable itself. The output will be formatted as HH:MM:SS.000000 [in Microseconds].

Frankly it doesnt do much more than time(), but then again the simplest things rarely do.

All it really does is hides the calculations that anyone else would have had to set up manually in a clever way and then produce a reasonably formatted output which lends itself equally well to single-line output or inlining with other text.

SYNOPSIS

Usage

To use Elapse is simplicity itself:

use Time::Elapse;

# somewhere in your program...
Time::Elapse->lapse(my $now);
# or you can do:
# Time::Elapse->lapse(my $now = "processing");

#...rest of program execution

print "Time Wasted: $nown";

To update the description and reset the time counter mid-stream, simply assign to the variable

$now = "parsing";

somewhere in the middle of the program. The new value is stored, while the original time is replaced with the current time.

Sample Output

Output looks something like this, using above code:

Time Wasted: 00:00:05.565763
or
Time Wasted: 00:00:03.016700 [processing]
(more output)
Time Wasted: 00:00:02.003764 [parsing]

Additional example code

You can also use this during a Net::FTP download loop of files to show elapsed time for each files download.

foreach my $file (@files_to_download)
{
# extract localfile name from $file
# ...
Time::Elapse->lapse(my $now = "Downloading $localfile.");
$ftp->get($file, $localfile) or carp("### Could not download $file! $!") and next;
print "Done. Elapsed : $nown";
# ...
}

This can also be a useful trick when youre processing a lot of data from multiple sources.