Free glass jars software for linux

libGlass is a library for distributed computing that makes its programming easy.
The Glass framework is a scalable set of components that can be used by applications to perform distributed computing. Applications are built reusing the available components as needed.
One of the major goals of libGlass is to be a user-friendly framework, not only suitable for new applications, but also for legacy code.
This is an important feature, as most available solutions for distributed computing require a substantial amount of rewrite of legacy code; some of them require a complete change of the application design.
libGlass was designed to achieve the following goals:
- User transparency: the library must be as transparent as possible. Any tasks that are repetitive or that can be done automatically should be done by the library, without user intervention.
The API (Application Programmers Interface) should be simple and intuitive, with a smooth learning curve and provide high level primitives that can be easily used to solve any problems. Legacy code should be easy to port.
- Extensibility: the library must be easily extensible, requiring no recompilation or any other modification to support new features; they must work as plug-ins.
- Performance and efficiency: since the library is for distributed computing, it has to be efficient, consuming as little processing time as possible.
- Network protocol independence: an abstraction layer makes it possible to change the underlying network protocols easily. The application can use the network protocol most efficient for its needs.
- Portability and interoperability: heterogeneous clusters and grid computing being every day more common, the library must be not only portable, but allow different architectures to interoperate seamlessly, something that is not true for most implementations of distributed computing solutions.
- Scalability: there is no use for a distributed solution that does not scale well. Glass has to work well in all sorts of environments, from small clusters to huge grids, and be able to adapt itself to achieve best results.
- Reconfigurable network architecture: most existing solutions are based on a fixed network architecture, usually Master/Slave or Client/Server.
Given the requirements of scalability and performance, and the fact that peer-to-peer applications are everyday more common, its unreasonable to fix the network architecture: the developer should be free to define how nodes will connect with each other.
- Reliability and fault tolerance: distributed computing often requires reliability. Its not acceptable that the misbehavior or crash of a single node crashes the entire computation.
As clusters grow in size and grid computing becomes more common, the MTBF (Mean Time Between Failures) shrinks to a point that it cannot be ignored.
libGlass must be able to handle node crashes gracefully, keeping the application running and avoiding deadlocks and other problems that could arise from the node crash. Nodes should be allowed to join or leave at anytime.
- Thread support: the library must be completely thread-safe.
With clusters of symmetric multiprocessors (SMP) computers becoming more common and new technologies such as HyperThreadingTM, its unacceptable for a distributed computing framework to have thread issues.
Main features:
Plugins:
- Synchronous shared memory
- Distributed asynchronous events
- Synchronization barriers
- Remote aliases
Protocols:
- TCP/IP
- UDP/IP (unfinished)
Architectures:
- Client/Server
- Pure peer to peer (planned)
- Hierarchical (planned)
- Anonymous peer to peer (planned)
Bindings for:
- Java (mostly finished)
Enhancements:
- Fixed packaging problems that could abort compilation

Aurora-Glass 0.1 provides you with another nice Aurora-based theme for GNOME users. It is actually a GTK theme that requires the Aurora engine and the patched pixbuf engine.

Enhancements:

• Added transparent glass scrollbars

Requirements:

• Aurora Gtk Engine
• Patched pixbuf engine

Dark Glass Icons 2.72 is yet another great addition for everyone's computer. It is actually a KDE theme based on OS-K icons. Part of this set is a derivative of OS-K set, part is of the developers 3d stuff. The theme package is 126MB large. The png source file is 5MB.

• Installation - full pack
• • Download the archive, uncompress and copy to /usr/share/icons
  • then choose Dark-Glass icons from the KDE control center.
• Installation - script version
• • Download the zip file
  • Extract the zip file
  • cd into the Dark-Glass-scripted folder
  • Open a terminal there
  • Run ./buildset
  • Install the icon theme in KDE Control Panel
    

Enhancements:

• Some correction on open folder
• Folder locked, favorites.
• Added aMule icon and other actions.
• Changed Firefox, Opera, Konqueror icons and some color retouch in apps icons.

Glossy-Glass provides an icon theme inspired by glass itself.
I have got the exact look that I wanted for this icon set, each icon has been payed special attention to its look.
If I was not happy with a icon then it was redesigned until I was perfectly happy, and this will containue. All going well I will release this icon set on Monday.
Enhancements:
- Added icons for gnome menu cataguries
- Added lots of mimetypes, over 40.
- Added extras directory for some alternative folder colours and some cool misc icons.
- Added emblems
- Added gtk icons

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

Jar::Signer Perl module ease the process of creating a signed Jar file.

SYNOPSIS

# using FindBin is just a suggestion.
use FindBin qw( $RealBin );
use Jar::Signer;
my $signer = Jar::Signer->new;
# location of the keystore, created if needed.
$signer->keystore("$RealBin/MyKeyStore");
# dname properties of the certificate.
$signer->dname("CN=Mark Southern, O=My Corporation, L=My State, C=USA");
# name for .fingerprint and ..cert files, created if needed.
$signer->alias("$RealBin/MyCert");
# the Jar file that we want to sign.
$signer->jar(shift);
# if signed_jar is undefined then the default is basename.signed.jar where basename is the basename of the Jar file.
$signer->signed_jar(shift);
# create the signed Jar.
$signer->process;

This module, and the script that uses it make it a lot simpler to generate signed Jar files for use in Java applets etc. It steps through all the needed jar, jarsigner and keytool command lines.

ASE (Allegro Sprite Editor) is a program specially designed with facilities to create animated sprites that can be used in some video game.
This program let you create from static images, to characters with movement, textures, patterns, backgrounds, logos, color palettes, and any other thing that you think.
Main features:
- Edit sprites with layers and animation frames.
- Edit RGB (with Alpha), Grayscale (with Alpha also) and Indexed images.
- Control 256 color palettes completely.
- Apply filters for different color effects (convolution matrix, color curve, etc.).
- Load and save sprites in these formats: .BMP, .PCX, .TGA, .JPG, .FLC, .FLI, and .ASE (ASEs special format).
- Use bitmaps sequences (ani00.pcx, ani01.pcx, etc.) to save animations.
- Drawing tools (dots, pencil, real-brush, floodfill, line, rectangle, ellipse), drawing modes (opaque, glass), and brushes types (circle, square, line).
- Mask (selections) support.
- Undo/Redo support for every operation.
- Multiple editor support.
- Draw with a customizable grid.
- Unique tiled drawing mode to draw patterns and textures in seconds.
- Save and load entire works sessions (in `.ses files).
- Scripting capabilities with Lua language.