Free luke software for linux

LuBu OpenMagic is an enhancement of the Solaris OpenStep 1.1-sparc desktop enviroment.

It is not a rewrite, nor is it a re-release, but is a package that enhances and improves (and includes) Solaris OpenStep 1.1.

LuBu OpenMagic is only available for the SPARC architecture.

LuBu OpenMagic 1.0 is a heavily modified version of the Lighthouse OpenStep 1.1
release for the Sparc platform. It is not a theme, nor a reconfiguration, but
an almost pure rewrite of non-binary files (runtime configurations, application
definitions, enviroment variables, and many functions). In some parts entire functions
have been replaced features have been added. This applies primarily to the Wrapper
function which has been entirely rewritten to use the LuBu OpenMagic Alert System
(aka: LOAS). This is a completely new feature which among many other things also
produces error messages in human readable form, with the actual cause of the error.
This makes taking countermeasures and avoiding future errors easier. The default
application definitions provided with OpenStep 1.1 were the cause of countless bugs,
and I have spendt a great amount of time optimizing the default defs. There are still
a few bugs for which I have found no workaround, but non are critical.

OpenMagic 1.0 will only run on Sparc CPUs since it is based on Solaris OpenStep 1.1 for Sparc. There is not, nor will there ever be, a release for any other CPU. Since
LuBu OpenMagic 1.0 is based on the binary Solaris OpenStep release, it remains a
Solaris Sparc product. There are no known binaries for other CPUs or operating
systems. It does however fully integrate the Solaris Operating Enviroment, Common
Desktop Enviroment, and any other enviroments that run on Solaris Sparc. This makes it alot easier to integrate applications into the OpenStep enviroment without the need of porting.

LuBu OpenMagic 1.0 is packaged as a pure gzipped tar file, intended for unpacking
from the root directory (ie: / ). This means that the default installation directory for OpenStep should be /usr/openstep - it is importent that this rule is followed, else the installation will fail and the distribution will not function at all. It is however possible to extract to a different directory and create a symlink to /usr/openstep. Just remember to copy the etc/dt/config files to their desired location (/etc/dt/config). This is needed as there are some additional files included in order for LuBu OpenMagic 1.0 to function correctly:

1. A modified /etc/dt/config/Xservers file with -dpi 72
2. Configuration files for dtlogin (in /etc/dt/config/*.os|*.xpm)
3. Icons for /cdrom and /floppy (directories will be created if missing)

For an optimal installation:

$ su -
# cd /
# gtar zxvf /path/to/lubu_openwb-1.0-sparc.tgz

Make sure that all the files are extracted, and that existing files ARE overwritten! This will NOT reduce system security or in any other way reduce system performance.

Make sure all files in /usr/openstep are owned by bin:bin else you will loose alot of functionality! There is NO NEED for ANY of the files to be owned by root (other than possibly Preferences.app/set_password which is initially broken due to a missing library - see KNOWN_BUGS).

If you must chown /usr/openstep, then it is a good idea to cd to /usr before running chown -R in case you are using a non-standard chown. Worst case scenario is that a chown -R from / chowns your entire system bin:bin! Better safe than sorry.

# cd /usr
# chown -R bin:bin openstep/

If you extracted OpenStep to a different location, then cd to that location before running chown

# cd /path/to/your/installation
# chown -R bin:bin ../openstep (provided you actually are in the openstep directory)

Make sure the following line is present in /etc/dt/config/Xservers:
:0 Local local_uid@console root /usr/openwin/bin/Xsun :0 -nobanner -dpi 72
(this is however included in the distribution files and should be installed upon
extraction). For optimal performance it is best to run your display at -depth 24 -dpi 72

This file (Xservers) should be -rwx-xr-x otherwise run
# chmod 755 /etc/dt/config/Xservers

It is vital that dtlogin is restarted after installation. Exit your windowmanager, login as root to the system console, and run the following commands (as root):

# sh /etc/init.d/dtlogin stop
# sh /etc/init.d/dtlogin start

Now log out from the console and allow the dtlogin loginwindow to reappear.
Select "LuBu OpenMagic 1.0" from the session menu. Log in and enjoy!

It is however possible to run LuBu OpenMagic 1.0 without CDE installed, or without running it through dtlogin by simply starting the file /usr/openstep/bin/openstep:

$ sh /usr/openstep/bin/openstep

though you might loose some valuable configurations using this method.
It has not as of yet been tested thouroughly.

Puppet lets you centrally manage every important aspect of your system using a cross-platform specification language that manages all the separate elements normally aggregated in different files, like users, cron jobs, and hosts, along with obviously discrete elements like packages, services, and files.

Puppets simple declarative specification language provides powerful classing abilities for drawing out the similarities between hosts while allowing them to be as specific as necessary, and it handles dependency and prerequisite relationships between objects clearly and explicitly.

Puppet is a system configuration tool. Puppet project has a library for managing the system, a language for specifying the configuration you want, and a set of clients and servers for communicating the configuration and other information.

The library is entirely responsible for all action, and the language is entirely responsible for expressing configuration choices.

Everything is developed so that the language operations can take place centrally on a single server (or bank of servers), and all library operations will take place on each individual client. Thus, there is a clear demarcation between language operations and library operations, as this document will mention.

Setup

The vast majority of Puppet architectures will look like a star, with a central server running puppetmasterd, and each client node running puppetd, contacting that central server.

Your central manifest, which contains the configuration for all of your nodes, needs to be on the central server, most likely at /etc/puppet/manifests/site.pp.

Start the puppetmasterd daemon, and then tell your clients to contact that server by specifying -s < servername > as arguments to puppetd, replacing "< servername >" with the name of the server. Alternatively, puppetd defaults to looking for a server named "puppet", so you can just create a CNAME for your server, so that it answers to "puppet".

It is a good idea to run both the server and client in verbose mode, enabled with the -v flag, until you are sure everything is working. As each new client connects, you will need to run puppetca --list to list the certificates waiting to be signed, and then puppetca --sign < name >, replacing "< name >" with the name of the client whose certificate you want to sign. You can turn on autosigning by creating /etc/puppet/autosign.conf and put the hosts, domains, or IP addresses or ranges that you want to sign in there.

KRDesktop is a GPL-ed KDE (QT3) front-end for QEMU. KQEmu project provides a GUI interface for running PC emulation (similiar in intent to Virtual PC/VMWare).
Written in Kommander, this also serves as a good example of RAD development under linux.
Main features:
- Creates script "Droplets" to automate later re-running with same settings.
- Supports all non "debug" features of QEmu.
Installation
Make sure you have QEmu and Kommander installed. Any version of QEmu should work, but KQEmu was only tested with the newest Alpha of Kommander (At this time Alpha 3).
Simply download and extract to a place of your choosing.
To run: kmdr-executor KQEmu-versionNumber.kmdr (ie: KQEmu-0.1.kmdr)

This is very a simple audio oscilloscope using OpenGL, GLUT, and ALSA. Distributed under a completely free license; this means you can do absolutely anything you want with this code. Id appreciate if you credit me where appropriate, though.

Controls are as follows:

Left mouse button: Pan
Mid mouse button: Move trigger
Right mouse button: Scale
Space bar: Start/stop recording
t: Toggle trigger mode (rising, falling, off)
p: Print data
Esc: Exit

When you print the plot data by pressing "P", two columns of text are printed to stdout. The first column is time, the second is amplitude. The easiest way to capture this data to a file is via the command line:

./glscope > data.csv

Since there is no interface to change the audio input device that is displayed, youll actually have to change some code if you want any other channel besides the default recording device. The important line in the code looks like this:

pcm_name = strdup("plughw:0,0");

I guess youll have to read about ALSA to figure out how to change that string.

Feel free to email me with any questions.

Gallipoli: The Game is a stunning recreation of Australias greatest military adventure. As a commander in the Great War (WWI), you take on the role of leading the prime of Australias armed forces as they launch an all-out assault on the Central Powers (the Germans, Austrians and the Ottomans).
Gameplay is similar to the hit PC game, Lemmings, except, instead of trying to save your soldiers, your mission, as an authentic WWI commander, is to wipe out as many diggers as possible ... the more gruesomely, the better!
Main features:
- Landing at Hell Spit (ANZAC cove)
- Russells Top
- The Sphinx
- Walkers Ridge
- The landing at Sulva Bay
- The third wave at the Nek
Enhancements:
- game much faster
- more options
- Battle of Pozyers level removed (no-one was playing it)

Class::Std::Storable is a Perl module to support for creating serializable "inside-out" classes.

SYNOPSIS

In general, use this class exactly as you would Class::Std.

package Ice::Cream;
use Class::Std::Storable;
{
my %name_of :ATTR( :get :set );
my %flavor_of :ATTR( :get :set );
}

package main;
my $object = Ice::Cream->new;
$object->set_name("Vanilla Bean");
$object->set_flavor("vanilla");
But now, you may also serialize the object with Storable.
use Storable;
my $serialized = Storable::freeze($object);
#store to a file, database, or wherever, and retrieve later.
my $clone = Storable::thaw($serialized);

Class::Std introduced the "inside-out" model for classes (perldoc Class::Std for details). Among its salient features is complete encapsulation; that is, an objects data may only be accessed via its methods, unlike the usual hashref model that permits direct access by any code whatsoever. However, the drawback of complete encapsulation is that normal mechanisms for serialization wont work, as they rely on direct access to an objects attributes.

This class provides the class-building functionality from Class::Std, and in addition provides an interface to allow Storable to freeze and thaw any declared attributes of this class and any superclasses that were built via Class::Std::Storable.

However, in order to let Storable save attributes and construct the object, it is necessary to expose the attributes of the class to the world. Thus, any code could use the same interface that Storable does to get a copy of object attributes and create new objects with arbitrary attributes without going through the constructor. While the interface CANT be used to replace the existing attributes of an object, it COULD be used to create an arbitrarily mutated clone of an object without going through its methods. Also, if attributes are themselves references, then the objects to which they refer can be obtained and modified.

As true encapsulation is one of the major features of Class::Std, this would be a good reason NOT to use this class. But this sacrifice is required to provide serialization. You must choose which is more important for your purposes, serialization or complete encapsulation. Consider also that while bypassing the class methods is possible to a limited degree with Class::Std::Storable, doing so is much more complicated than just using the methods, so use of this class still discourages casual violations of encapsulation.