Free selection sunday 2009 software for linux

File Selection Language (FSL) is a descriptive language for file selection. File Selection Language is used to selectively pick files from a directory structure.
FSL is useful for selective backups, for instance. FSL uses glob patterns as the basic building block.
For fine-tuning the selection, inclusion/exclusion rule combinations and conditional expressions are available. File size and modification date can be used in expressions.
Main features:
- FSL can be used with a command line tool (fsltool) or, for Python programmers, with a programmable interface. For the Python interface, see the documentation of Interpreter.py.
- Several FSL rule files can be combined in a cascading manner similar to CSS. The effect is the same as if the rule files were pasted into a single file.
- Support for both Windows-like and Unix-like paths.
- Strict parse-time type checking to catch as many errors as possible before run-time. For example, you cant say EACH f IF size(5) > 1000 because function size expects filename argument.

Inline::Select contains dynamic selection of ILSM for a package.

SYNOPSIS

use Inline::Select::Register (
PACKAGE => Calc,
Inline => [ Perl => sub {require t/Calc.pm} ]
) ;
use Inline::Select::Register (
PACKAGE => Calc,
Inline => [ CPP => t/Calc.cpp ]
) ;
use Inline::Select::Register (
PACKAGE => Calc,
Inline => [ Java => t/Calc.java ]
) ;
use Inline::Select::Register (
PACKAGE => Calc,
Inline => [ Python => t/Calc.py ]
) ;

use Inline::Select (
PACKAGE => Calc,
Inline => $ARGV[0] # one of Perl, CPP, Java, Python
) ;

my $c = new Calc() ;
ok($c->add(2, 3), 5) ;

USAGE

Usage of Inline::Select is pretty simple. For each programming language, you must speficy a use Inline::Select::Register (or Inline::Select->register() at runtime) statement to register the use of Inline for that language. All the Inline parameters are saved and that Inline block will only be evaluated if that language is selected later on.

When you are done registering Inline blocks, you then spefify a use Inline::Select (or Inline::Select->bind() at runtime) to actually load (in the caller package) the Inline block for the selected language.

Soulfind is a Soulseek server implementation for Linux, though it can probably be compiled under Mac OS X, BSD or Windows as well (if you have tried to build Soulfind under another OS than Linux, Id like to know if it worked, and what happens if it didnt). This homepage is there to provide some information about it.
Theres also a new #slsk-gpl room on Freenode (irc.freenode.net), Ill try to be there as often as possible (but 50H/month dial-up sucks).
Soulfind is coded using the D programming language and released under the GNU General Public License.
It originally started with me being bored on a sunday afternoon, and coding a basic chat-only Soulseek server... since it was easier than what I had expected, I decided to go on and implement the full protocol.
The name just comes from people ranting about how their searches on the official server do not return enough results... indeed its name is only Soulseek, while this one is Soulfind.
The server supports the Nicotine, Museek and PySoulSeek clients (actually, all clients except the official Windows one should work). The Windows client also works to some extent, but you have to trick it to make it connect to another server on another port, and it also checks for an md5sum in the server answer, which this server doesnt send.
Enhancements:
- This release compiles with DMD 0.155, and supports the new server-handled room and buddy searches.
- Several minor bugs have been fixed, as well as a more important one about privileges (giving some privileges to another user did not add to his existing privileges, but replaced them).

Yet Another V4L Application (or yava for short) is lightweight v4l framegrabber with support for TrueType fonts and ftp-upload.
Yet Another V4L Application project is written in ANSI C.
It uses Andreas Schifflers excellent SDL_bgrab library for frame grabbing, SDL for internal image manipulation, SDL_ttf for TrueType font rendering, libcurl for ftp uploads and libpng for snapshot writing.
Main features:
- Lightweight, using pretty standard libraries
- Tuner support
- FTP-upload (active and passive modes)
- TrueType font rendering
- Text color (RGB) selection
- Vertical text positioning (top, center, bottom)
- Horisontal text positioning (left, center, right)
- Font selection and number of pts
- Snapshots in png
- Live viewer or console mode

Fast Date Picker project is a calendar which is easy to integrate into pages that require the users to select a date like on travel sites.
Written in ECMAScript, it responds faster to the users clicks than most of the server-side-based or Java-applet-based date pickers often found on travel sites today.
The calendar can be added to your page any way you want (e.g. as a pop-up window or an expandable

Tk Web form Buddy project is a helper for Web forms.
The Tk Web form Buddy is a Tk script that allows one easily to make a series of strings available to the X11 PRIMARY selection, which is useful for filling in Web forms that have common/repetitive data.
How many times have you wished to have something to always fill in your name, address, email, etc.?
Its not automatic enough to fill these in for you, but you can click on each button to make it the PRIMARY selection so that you can paste these strings into a Web form, with the middle mouse button for example.
Enhancements:
- should now work under ActiveTCL by setting the Win32 clipboard

Funky is an embeddable interpreter and programming language.
When was Fnky created?
The very first version of Funky was created during my daughters nap on a snowy sunday afternoon. It was slightly refined one evening while my daughter and my wife were both sleeping and I was rocking the babys "cozy" with my foot (as I am doing now). The initial programming therefore took about 90 minutes, whereas a bit of fine-tuning and turning the original parser/interpreter into a parser/interpreter with two phases (parsing and interpreting) took another two hours or so.
Why was Funky created?
The original idea wasnt mine: at work, a colleague needed a functional, embeddable programming language and created one from scratch. It took him a few days to do so, but he wrote the parser and the scanner by hand. I heard about his little language and thought it might be a nice idea to have one of those in the free world.
Also, as a personal challenge, I decided I should be able to write one of those in much less time that a few days, but using the right tools. Hence, one sunday afternoon I took my laptop computer and started typing. I decided to use Boost.Spirit to write the parser: I had already read the documentation once while doing some research for the Jail programming language and found it a pretty good framework to build a parser one. 90 minutes later, I had the first working version of a Funky interpreter (but it wasnt embeddable yet and didnt split the parsing and interpreting phases).
So, what exactly is Funky?
As stated, Funky is a tiny, embeddable programming language with almost unlimited extending capabilities. It presents itself as a single class which contains the entire interpreter. Two versions of this class exist: Funky::Funky, which is a floating-point version, and Funky::Groovy, which is an integer version. You can install your own functions in the language as long as your functions take a vector of the built-in type of the interpreter as return an instance of that built-in type (or a vector of those).
Funky is a functional programming language. As such, it treats everything as functions and those functions handle only one type: double in the case of Funky::Funky or int in the case of Funky::Groovy.
Enhancements:
- This release adds support for GCC 4.x by fixing a small error in the declaration of a variable.
- It also comes with more documentation on how to build Funky.

Dune Legacy is a free clone of Dune2.

Updated clone of Westood Studios dune2. Uses original dune2 data files (not included) to provide original dune2 graphics and sounds.

New features include multiple unit selection/control, high resolution support, multiplayer gaming via tcp/ip, in game.