Free brittany snow software for linux

Xsnow application is the X-windows application that will let it snow on the root, in between and on windows.
Santa and his reindeer will complete your festive-season feeling.
How to compile:
To build:
xmkmf
make depend
make
To run:
./xsnow
or:
./xsnow& (in the background)
To install (be root):
make install
make install.man
If xmkmf does not work and you cannot get a working Makefile that way then try compiling yourself, eh, xsnow this way:
cc -o xsnow snow.c -lXext -lX11 -lXpm -lm -lsocket -lnsl
gcc, SUN Solaris users without a C-compiler, but with gcc installed, try the following two commands. The first compiles Xsnow, the second links Xsnow.
gcc -c -O2 -I/usr/openwin/include -DSVR4 -DSYSV xsnow.c
gcc -o xsnow xsnow.o -O2 -L/usr/openwin/lib -lXext -lX11 -lXpm -lm -lsocket -lnsl
Note: Xsnow-1.41 needs the Xpm library. It is available from:
ftp://ftp.x.org/contrib/libraries/
The current Xpm version is xpm3.4k
Enhancements:
- All you KDE-users can now be even happier with a KDE-enabled Xsnow 1.42!
- The snow will magnificently wipe out your icons, but not to worry, theyre not really gone.
- By wiping with a window or something you can make them reappear.
- Car owners are used to this for years. Thanks to Robin Hogan who figured this out for xpenguin.

blueMarine project is about an open source workflow for digital photography.

What does it mean?

Start thinking of an opensource application like Aperture or Lightroom that enables you to organize, develop, print and publish your photos. Pretty standard stuff nowadays. Opensource, at first sight, means that the application is free. Now think of an application written with the Java™ language: the application runs everywhere, Mac OS X, Linux, Windows. Now think of a community of people that adds code, plugins, crazy ideas, integrating some of the latest, cool technologies around, such as GPS positioning or geo-mapping.

Well, this is just the core concept of the blueMarine project.

Lets go on and lets think of the workflow. For the existing commercial applications the workflow starts just after shooting the photo and ends with a print on paper, the photo archived and maybe a web gallery published.

Just for a starter, we could do these things in innovative ways. For instance, trip reports could take advantage of GPS positioning data and Google Maps. Galleries could be presented in form of a virtual 3d gallery with walls and pictures hang on them.

Thinking of it twice, there are holes in workflows supported by current commercial applications. For instance, if you want to filter your images with a sophisticated noise reduction algorithm or if you want to create a bigger composite photo out of several shots, you likely have to use an external application. Some communities, such as amateur astrophotographers, need some very special processing that is usually performed by means of specific software. Wouldnt be better to have all of these facilities integrated in a single front end?

Now, lets broaden our workflow horizon. It can extend well beyond the print or the archival. For instance, an ornithologist usually manages field notes about the bird observed and photographed: directly binding them to photos and maybe GPS positioning data is much better than keeping a separate Excel sheet. It can also start much before shooting the photo. Think of trip planning: maybe you travel to nice places and spot interesting subjects, but not all the conditions are favorable: the weather, the light, the sun position, or the season (snow, blossomed flowers, foliage colors). Maybe you take some photos but at home you decide: hey, Im going to return there next Fall when the trees are reddish. Wouldnt be cool if a software application could allow you to easily manage all of these wanna-shoot-again photos, maybe providing assistance to guess which will be the sun position in a certain day and hour and integrating weather forecasts? And synthetising a trip program that can be uploaded on your palm gear?

Theres a further point with opensource photo workflow. Its related to the world of camera raw formats, that is the way professional DSLR cameras work. They provide you with the raw bits from the sensor that need to be extensively cooked, or developed, for getting a good image. This approach gives a tremendous amount of control to the photographers - too bad that most formats are proprietary and not documented. blueMarine supports the OpenRAW initiative and provide an opensource implementation of developing tools for camera raw formats from an ever increasing number of vendors.

Well, all of this and more is the aim of the blueMarine project.

PiX Bros software is a game which mixes three arcade classics: Bubble Bobble, Snow Bros and Tumble Pop.
Your objective in this game is to destroy every enemy with your characters abilities in order to demonstrate that your character is the best hero in the world.
Main features:
- 3 players at the same time, in the same computer
- 3 different characters
- 6 levels (this is just a demo..)
- 3 different enemies
- Save game
- 3 difficulty levels

Debt Payoff Calculator is a simple set of PHP (5) scripts that will allow users of a web site to enter their monthly income, monthly budget, and outstanding debts.
The system can then generate a debt payoff report predicting how long it will take to pay off the debts.
The algorithm is:
1. Get total monthly income.
2. Get total monthly expenses.
3. Amount available for debt service is income - expenses;
4. Compute the "kicker" as %20 of Available, reduce available by this amount.
5. Compute the ratio of each debt to total debts.
6. Multiply Available by each ratio to get the potential payment.
7. For the smallest debt, add the kicker.
8. Test if any debts would be paid off
8a. If a debt could be paid off, make the payment, adjust the last debt pointer.
8b. Add any excess funds to the other potentials, using ratio2 which excludes the debt to be paid off.
8b. Repeat 8.
9. Make the remaining payments for debts not paid off.
Repeat 5-9 until all debts paid off.
Print the table of payments.
Enhancements:
- This release has been tested with Internet Explorer and Mozilla as clients.

Imager::Color is a Perl module with color handling for Imager.

SYNOPSIS

$color = Imager::Color->new($red, $green, $blue);
$color = Imager::Color->new($red, $green, $blue, $alpha);
$color = Imager::Color->new("#C0C0FF"); # html color specification

$color->set($red, $green, $blue);
$color->set($red, $green, $blue, $alpha);
$color->set("#C0C0FF"); # html color specification

($red, $green, $blue, $alpha) = $color->rgba();
@hsv = $color->hsv(); # not implemented but proposed

$color->info();

if ($color->equals(other=>$other_color)) {
...
}

This module handles creating color objects used by imager. The idea is that in the future this module will be able to handle colorspace calculations as well.

new

This creates a color object to pass to functions that need a color argument.

set

This changes an already defined color. Note that this does not affect any places where the color has been used previously.

rgba

This returns the rgba code of the color the object contains.

info

Calling info merely dumps the relevant colorcode to the log.

equals(other=>$other_color)
equals(other=>$other_color, ignore_alpha=>1)

Compares $self and color $other_color returning true if the color components are the same.

Compares all four channels unless ignore_alpha is set. If ignore_alpha is set only the first three channels are compared.

You can specify colors in several different ways, you can just supply simple values:
simple numeric parameters - if you supply 3 or 4 numeric arguments, you get a color made up of those RGB (and possibly A) components.

a six hex digit web color, either RRGGBB or #RRGGBB
an eight hex digit web color, either RRGGBBAA or #RRGGBBAA.
a 3 hex digit web color, #RGB - a value of F becomes 255.
a color name, from whichever of the gimp Named_Colors file or X rgb.txt is found first. The same as using the name keyword.

You can supply named parameters:

red, green and blue, optionally shortened to r, g and b. The color components in the range 0 to 255.

# all of the following are equivalent
my $c1 = Imager::Color->new(red=>100, blue=>255, green=>0);
my $c2 = Imager::Color->new(r=>100, b=>255, g=>0);
my $c3 = Imager::Color->new(r=>100, blue=>255, g=>0);
hue, saturation and value, optionally shortened to h, s and v, to specify a HSV color. 0 new(hue=>120, value=>1, saturation=>0.5);
web, which can specify a 6 or 3 hex digit web color, in any of the forms #RRGGBB, #RGB, RRGGBB or RGB.
my $c1 = Imager::Color->new(web=>#FFC0C0); # pale red
gray or grey which specifies a single channel, from 0 to 255.
# exactly the same
my $c1 = Imager::Color->new(gray=>128);
my $c1 = Imager::Color->new(grey=>128);
rgb which takes a 3 member arrayref, containing each of the red, green and blue values.
# the same
my $c1 = Imager::Color->new(rgb=>[255, 100, 0]);
my $c1 = Imager::Color->new(r=>255, g=>100, b=>0);
hsv which takes a 3 member arrayref, containting each of hue, saturation and value.
# the same
my $c1 = Imager::Color->new(hsv=>[120, 0.5, 1]);
my $c1 = Imager::Color->new(hue=>120, v=>1, s=>0.5);

gimp which specifies a color from a GIMP palette file. You can specify the filename of the palette file with the palette parameter, or let Imager::Color look in various places, typically "$HOME/gimp-1.x/palettes/Named_Colors" with and without the version number, and in /usr/share/gimp/palettes/. The palette file must have color names.

my $c1 = Imager::Color->new(gimp=>snow);
my $c1 = Imager::Color->new(gimp=>snow, palette=>testimg/test_gimp_pal);

xname which specifies a color from an X11 rgb.txt file. You can specify the filename of the rgb.txt file with the palette parameter, or let Imager::Color look in various places, typically /usr/lib/X11/rgb.txt.

my $c1 = Imager::Color->new(xname=>blue) # usually RGB(0, 0, 255)

builtin which specifies a color from the built-in color table in Imager::Color::Table. The colors in this module are the same as the default X11 rgb.txt file.

my $c1 = Imager::Color->new(builtin=>black) # always RGB(0, 0, 0)

name which specifies a name from either a GIMP palette, an X rgb.txt file or the built-in color table, whichever is found first.

channel0, channel1, etc, each of which specifies a single channel. These can be abbreviated to c0, c1 etc.

channels which takes an arrayref of the channel values.

Optionally you can add an alpha channel to a color with the alpha or a parameter.

These color specifications can be used for both constructing new colors with the new() method and modifying existing colors with the set() method.

Persistent::LDAP is a persistent class implemented using a LDAP directory.

SYNOPSIS

use Persistent::LDAP;
use English; # import readable variable names like $EVAL_ERROR

eval { ### in case an exception is thrown ###

### allocate a persistent object ###
my $person =
new Persistent::LDAP(localhost, 389,
cn=Directory Manager, test1234,
ou=Engineering,o=Big Snow Org,c=US);

### declare attributes of the object ###
$person->add_attribute(uid, ID, String);
$person->add_attribute(userpassword, Persistent, String);
$person->add_attribute(objectclass, Persistent, String);
$person->add_attribute(givenname, Persistent, String);
$person->add_attribute(sn, Persistent, String);
$person->add_attribute(cn, Persistent, String);
$person->add_attribute(mail, Persistent, String);
$person->add_attribute(telephonenumber, Persistent, String);

### query the datastore for some objects ###
$person->restore_where(& (objectclass=person)(mail=*bigsnow.org),
sn, givenname);
while ($person->restore_next()) {
printf("name = %s, email = %sn",
$person->givenname . . $person->sn,
$person->mail);
}
};

if ($EVAL_ERROR) { ### catch those exceptions! ###
print "An error occurred: $EVAL_ERRORn";
}

ABSTRACT

This is a Persistent class that uses a LDAP directory to store and retrieve objects. This class can be instantiated directly or subclassed. The methods described below are unique to this class, and all other methods that are provided by this class are documented in the Persistent documentation. The Persistent documentation has a very thorough introduction to using the Persistent framework of classes.