Free sparco steering wheel hub 01502099 software for linux

SpacePong is an innovative game that is controlled with the mouse. The gameplay involves steering your spacecraft ball around the screen and picking up speed by bouncing off the walls. The goal is to collect a certain amount of space boxes in a short time.
Enhancements:
- New sounds and music were added.
- A moving stars effect in the background was implemented.
- Packages for Debian and Mandriva were added.

Class::Container is a Perl module with Glues object frameworks together transparently.

SYNOPSIS

package Car;
use Class::Container;
@ISA = qw(Class::Container);

__PACKAGE__->valid_params
(
paint => {default => burgundy},
style => {default => coupe},
windshield => {isa => Glass},
radio => {isa => Audio::Device},
);

__PACKAGE__->contained_objects
(
windshield => Glass::Shatterproof,
wheel => { class => Vehicle::Wheel,
delayed => 1 },
radio => Audio::MP3,
);

sub new {
my $package = shift;

# windshield and radio objects are created automatically by
# SUPER::new()
my $self = $package->SUPER::new(@_);

$self->{right_wheel} = $self->create_delayed_object(wheel);
... do any more initialization here ...
return $self;
}

This class facilitates building frameworks of several classes that inter-operate. It was first designed and built for HTML::Mason, in which the Compiler, Lexer, Interpreter, Resolver, Component, Buffer, and several other objects must create each other transparently, passing the appropriate parameters to the right class, possibly substituting other subclasses for any of these objects.

The main features of Class::Container are:

Explicit declaration of containment relationships (aggregation, factory creation, etc.)
Declaration of constructor parameters accepted by each member in a class framework
Transparent passing of constructor parameters to the class that needs them
Ability to create one (automatic) or many (manual) contained objects automatically and transparently

IMWheel is a daemon for X11, which watches for mouse wheel actions and outputs them as keypresses.

This is a not so short little ditty that does the simple conversion of mouse button presses into key presses. By grabbing only the 4th and 5th mouse buttons the program is able to receive input from the Intellimouse series mice.

There is also a modified version of gpm included that has, already, support for the Intellimouse, and I added a wheel fifo. The user library may also be used, although this may need to be debugged. See the gpm section below for more.

The wheel button can always be used as middle button, this program does not affect how the XServer, nor GPM, react towards it. A mouse with a wheel button is a 3 button mouse, and should be configured as such!

Installation:

The `configure shell script attempts to guess correct values for various system-dependent variables used during compilation.

It uses those values to create a `Makefile in each directory of the package. It may also create one or more `.h files containing system-dependent definitions.

Finally, it creates a shell script `config.status that you can run in the future to recreate the current configuration, a file `config.cache that saves the results of its tests to speed up
reconfiguring, and a file `config.log containing compiler output (useful mainly for debugging `configure).

If you need to do unusual things to compile the package, please try to figure out how `configure could check whether to do them, and mail diffs or instructions to the address given in the `README so they can be considered for the next release.

If at some point `config.cache contains results you dont want to keep, you may remove or edit it.

The file `configure.in is used to create `configure by a program called `autoconf. You only need `configure.in if you want to change it or regenerate `configure using a newer version of `autoconf.

The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.

If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.

Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Optionally, type `make check to run any self-tests that come with the package.

4. Type `make install to install the programs and any data files and documentation.

5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean.

There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.

AHote is a C++ library for generating color schemes and also includes a few other classes for converting between RGB (Red, Green, Blue), YUV (Luminance and Chrominance), HSB (Hue, Saturation, Brightness) and HSL (Hue, Saturation, Lightness).
AHote is not a library for ICC color management.
A variety of functions are provided that, in general, take an input HSB color as a parameter and return a std::vector of HSB colors representing the generated color scheme. Depending on the function a number of other parameters can be passed that will vary the return size of the color scheme, etc.
The HSB colors in the returned std::vector can then be used as necessary. The HSB class can be cast to the RGB class, performing all necessary conversions along the way. Thus, it would be possible to do something like the following:
using namespace ahote;
// std::vector has been typedefed to Colors
Colors scheme = tetrads( HSB(120, 1.0, 1.0) );
RGB rgb;
for (Colors::iterator iter=scheme.begin(); iter != scheme.end(); iter++) {
rgb = *iter;
// rgb.red, rgb.green, rgb.blue contain the RGB components
// do something meaningful with them, like:
cairo_set_source_rgb(cairo, rgb.red, rgb.green, rgb.blue);
Enhancements:
- The library currently supports generation of the following color schemes: complements, split-complements, triads, tetrads, analogous colors, shades, tints, tones, and monochromatics.
- Other schemes that are in this release are related to the RGB color wheel including primary, secondary, and tertiary colors as well as the color wheel itself.
- Schemes of schemes can also be created, and classes are provided to easily convert between HSB, HSL, RGB, and YUV color spaces.

WheelOfFortune is a HIGHLY experimental but fascinating superkaramba enhancement, with an example theme to see the principle and also a work-in-progress theme.
Wheel smoothly your way through your files without having to spend all your time clicking on folders.
The enhancements: listing file and directories in Superkaramba - but its a bit more than that: KDirlister is used, which supports application:/, file:/, floppy:/ media:/ devices:/ svn:/ in fact any KIO.
I am so bowled over by how exciting and how... "wow!" this is that i just had to let people know about it.
Try the wof.theme and you will see what i mean.
If you have a mouse with a scroll-wheel, use it: its much easier to navigate. single-click on a directory to open it up on the arc below (yes, its a wheel, not a line, not a square, not a treeview!)
The download contains:
- a precompiled superkaramba binary
- a superkaramba diff (patch)
- the dirlister.cpp and .h files
- an example theme (dirlister)
- a work-in-progress theme (wof).
Enhancements:
- fixed large subdirectory crash
- added "run" capability properly

EvRouter reads events from the Linux input layer, and acts on them according to a user-specified set of rules. Currently, EvRouter can map events to X11 key and button presses, XMMS commands, and it can also run shell commands.

EvRouter is intended to help legacy applications understand modern events such as mouse wheel movement and special keys on keyboards.

EvRouter also offers hotkey-like functions, and can help existing modern applications deal with events that, for one reason or another, X11 is unaware of (as long as they are accessible through a Linux event device).

Danger from the deep (aka dangerdeep) is a Free / Open Source World War II german submarine simulation.
It is currently available for Linux/i386 and Windows, but since it uses SDL/OpenGL it should be portable to other operating systems or platforms. (If anyone whishes to port it, please contact us.)
This game is planned as tactical simulation and will be as realistic as our time and knowledge of physics allows. Its current state is ALPHA, but it is playable.
If anyone wants to contribute in development, youre welcome, just email the dangerdeep-devel mailing list. Contributing binary packages for various Linux distributions would also be much appreciated.
To get help with the game you should visit our public forum.
The game has support for multiple languages but currently only English, Italian and German are implemented. It is written in C++ with the use of the STL.
Danger from the Deep is released under the GNU General Public License. The project is hosted on SourceForge, a great supporter of the Open Source community.
Main features:
- simple main menu
- user interface (some items missing)
- basic world simulation, night and day
- realistic water and cloud simulation
- one type of destroyer, one battleship, one aircraft carrier, three subs, eight civilian ship types
- steering, firing, diving, periscope use
- free look engine for testing, periscope, UZO (aiming binoculars), bridge view
- console for logging purposes
- basic physics (acceleration, steering, firing)
- basic destroyer AI (follow, throw depth charges)
- simple vehicle preview
- mission parsing via text files, you can create your own custom missions
- tonnage recording
- log book

Nast is a packet sniffer and a LAN analyzer based on Libnet and Libpcap.
It can sniff in normal mode or in promiscuos mode the packets on a network interface and log it. It dumps the headers of packets and the payload in ascii or ascii-hex format. You can apply a filter. The sniffed data can be captured in a separate file.
Main features:
- Build LAN hosts list
- Follow a TCP-DATA stream
- Find LAN internet gateways
- Discorver promiscous nodes
- Reset an established connection
- Perform a single half-open portscanner
- Perform a multi half-open portscanner
- Find link type (hub or switch)
- Catch daemon banner of LAN nodes
- Control arp answers to discover possible arp-spoofings
- Byte couting with an optional filter
- Write reports logging