Free target software for linux

Target project is an AJAX-enabled application that allows users to create and track one or more target areas.

The target area can then be resized and moved to new locations on the image. With a right-click, the movement and resize history can be replayed with DHTML animation and AJAX.

Stargun project is a 2D space shooter game.
Stargun is a space shooter, vertical scroller game. Its platform independent (or at least it is the objetive). The target OS are Windows and Linux. There are plans to port Stargun to BeOs, FreeBSD and Amiga.
Stargun is written in C++ and uses SDL library.
This project is under GPL lisence.
Enhancements:
- Music & sound added
- Joystick support
- Levels support
- some bugs fixed

VK Tafe is a program that parses and analyzes MPEG-2 transport streams (e.g., DVB, ATSC, etc.).
Enhancements:
vk_tafe
- UI changes to PCR Analysis screen
- New PTS/DTS graph (graphs PTS/DTS values against current PCR)
- UI log for STD buffer analysis
- Updated HTML documentation
- Target build platform updated to a "modern" distro -- SuSE 10. The older Mandrake version is frozen at version 0.8f which is still included in the VK-Tools packets
- Updated win32 port
view_knot_dump
- UI no longer depends on icons subdirectory to properly display
- If local .view_knot_view config does not specify the location of vk_tafe we assume its somewhere in the PATH and try to launc it
- Updated HTML documentation
- Target build platform updated to a "modern" distro -- SuSE 10. The older Mandrake version is frozen at version 0.8f which is still included in the VK-Tools packets
- Updated win32 port
- Removed Plugins. Theyve only been broken for 5 years now :)
view_knot_viewer
- No changes

reflect is a symlink-style package management tool similar to depot, stow, graft, epkg, etc. Unlike these, it has much less prerequisites, in that it only requires bash and coreutils. Configuration is per-package, and multiple target directories are permitted.
Main features:
- reflect is written in bash. Currently it depends on the following to be installed: cd, mkdir, ls, ln, cmp, rm, md5sum, and, well, bash.
- reflect will only delete symbolic links, and only those which belong to the package reflect is currently working on.
- All configuration is per-package, in a file /pack/ /reflect.conf.
- It is possible to configure (in reflect.conf) multiple target directories for a package.

Link Alert is a Firefox extension that changes the cursor to indicate the target of a link.

Highlights links to the following:
-New Windows
-Secure Sites
-Email Links
-Javascript
-Word Documents
-Excel Spreadsheets
-PDF Files
-Zip Files
-Applications
-Text Files
-Images
-RSS Feeds
-AIM: Links
-and more...

Make is a Perl module for processing makefiles.

SYNOPSIS

require Make;
my $make = Make->new(...);
$make->parse($file);
$make->Script(@ARGV)
$make->Make(@ARGV)
$make->Print(@ARGV)

my $targ = $make->Target($name);
$targ->colon([dependancy...],[command...]);
$targ->dolon([dependancy...],[command...]);
my @depends = $targ->colon->depend;
my @commands = $targ->colon->command;

Make->new creates an object if new(Makefile => $file) is specified then it is parsed. If not the usual makefile Makefile sequence is used. (If GNU => 1 is passed to new then GNUmakefile is looked for first.)

$make->Make(target...) makes the target(s) specified (or the first real target in the makefile).

$make->Print can be used to print to current selected stream a form of the makefile with all variables expanded.

$make->Script(target...) can be used to print to current selected stream the equivalent bourne shell script that a make would perform i.e. the output of make -n.

There are other methods (used by parse) which can be used to add and manipulate targets and their dependants. There is a hierarchy of classes which is still evolving. These classes and their methods will be documented when they are a little more stable.

The syntax of makefile accepted is reasonably generic, but I have not re-read any documentation yet, rather I have implemented my own mental model of how make works (then fixed it...).

In addition to traditional

.c.o :
$(CC) -c ...

GNU makes pattern rules e.g.

%.o : %.c
$(CC) -c ...

Likewise a subset of GNU makes $(function arg...) syntax is supported.
Via pmake Make has built perl/Tk from the MakeMaker generated Makefiles...

Event is an Event loop processing.

SYNOPSIS

use Event qw(loop unloop);

# initialize application
Event->flavor(attribute => value, ...);

my $ret = loop();

# and some callback will call
unloop(ok);

The Event module provide a central facility to watch for various types of events and invoke a callback when these events occur. The idea is to delay the handling of events so that they may be dispatched in priority order when it is safe for callbacks to execute.

Events (in the ordinary sense of the word) are detected by watchers, which reify them as events (in the special Event module sense). For clarity, the former type of events may be called "source events", and the latter "target events". Source events, such as signals arriving, happen whether or not they are being watched. If a source event occurs which a watcher is actively watching then the watcher generates a corresponding target event. Target events are only created by watchers. If several watchers are interested in the same source event then each will generate their own target event. Hence, any particular source event may result in zero, one, two, or any number of target events: the same as the number of watchers which were actively watching for it.

Target events are queued to be processed in priority order (priority being determined by the creating watcher) and in FIFO order among events of the same priority. Queued ("pending") events can, in some cases, be cancelled before being processed. A queued event is processed by being passed to the callback function (or method on a particular object or class) which was specified to the watcher.

A watcher, once created, operates autonomously without the Event user having to retain any reference to it. However, keeping a reference makes it possible to modify most of the watchers characteristics. A watcher can be switched between active and inactive states. When inactive, it does not generate target events.

Some types of source event are not reified as target events immediately. Signals received, for example, are counted initially. The counted signals are reified at certain execution points. Hence, signal events may be processed out of order, and if handled carelessly, on the wrong side of a state change in event handling. A useful way to view this is that occurrence of the source event is not actually the arrival of the signal but is triggered by the counting of the signal.
Reification can be forced when necessary. The schedule on which some other events are created is non-obvious. This is especially the case with watchers that watch for a condition rather than an event. In some cases, target events are generated on a schedule that depends on the operation of the event loop.

SouRCe PacKaGer (srcpkg) is a program for managing separate software packages under the same directory hierarchy. It is especially useful for packages distributed as source code.

srcpkg is similar to GNU Stow, Depot, etc., but is designed to be able to handle large, complex, interdependent packages such as those of KDE and GNOME.

srcpkg works by creating packages from new files found in the target directory tree. This allows packages to be installed as they were intended, into a specific prefix (eg. /usr/local), and srcpkg takes care of moving the new files to a separate package directory and creating symlinks into the target tree.

srcpkg is a Perl script, so it requires Perl 5.6 or above. srcpkg may be ported to C in a future version; if this would be beneficial to you, please contact the author.

srcpkg project has successfully been used to manage a large number of software packages, notably Gnome and KDE.