Free control object software for linux

Color::Object is a OO-Color Module.

A module for manipulation Colors within RGB, HSV and HSL color-spaces for usage within PDF-Documents especially with the Text::PDF::API modules.

SYNOPSIS

use Color::Object;

$cl = Color::Object->new;
$cl = Color::Object->newRGB($r,$g,$b);
$cl = Color::Object->newHSV($h,$s,$v);
$cl = Color::Object->newHSL($h,$s,$l);

$cl->setRGB($r,$g,$b);
$cl->addBrightness($br);
($h,$s,$l) = $cl->asHSL;

METHODS

Color::Object->new
Color::Object->newRGB $r, $g, $b
Color::Object->newHSV $h, $s, $v
Color::Object->newHSL $h, $s, $l
Color::Object->newGrey $grey
( $r, $g, $b ) = $cl->asRGB
Returns $cls rgb values. Range [0 .. 1].
( $h, $s, $v ) = $cl->asHSV
Returns $cls hsv values. Ranges h [0 .. 360], s/v [0 .. 1].
( $h, $s, $l ) = $cl->asHSL
Returns $cls hsl values. Ranges h [0 .. 360], s/l [0 .. 1].
$grey = $cl->asGrey
$grey = $cl->asGrey2
Returns $cls grey value. Range [0 .. 1]. Functions 2 returns the geometric mean of the corresponding RGB values.
( $c, $m, $y )= $cl->asCMY
Returns $cls cmy values. Range [0 .. 1].
( $c, $m, $y, $k )= $cl->asCMYK
( $c, $m, $y, $k )= $cl->asCMYK2
( $c, $m, $y, $k )= $cl->asCMYK3
Returns $cls cmyk values. Range [0 .. 1]. Function 2 returns a 25% lighter color-equivalent. Function 3 returns a 25% lighter color-equivalent.
$hex = $cl->asHex
Returns $cls rgb values as 6 hex-digits.
$cl->setRGB $r, $g, $b
Sets the $cls rgb values. Valid range [0 .. 1].
$cl->setHSV $h, $s, $v
Sets the $cls hsv values. Valid ranges: h [0..360], s/v [0..1].
$cl->setHSL $h, $s, $l
Sets the $cls hsl values. Valid ranges: h [0..360], s/l [0..1].
$cl->setGrey $grey
Sets the $cls grey value. Valid range [0 .. 1].
$cl->setHex $hex
Sets the $cls rgb values using 6 hex-nibbles.
$cl->addSaturation $saturation
Adds to the $cls saturation in the HSV model. Valid range [-1 .. 1].
$cl->setSaturation $saturation
Sets the $cls saturation in the HSV model. Valid range [0 .. 1].
$cl->rotHue $degrees
Rotates the $cls hue in the HSV/L model. Valid range [-360 .. 360].
$cl->setHue $hue
Sets the $cls hue in the HSV/L model. Valid range [0 .. 360].
$cl->addBrightness $brightness
Adds to the $cls brightness in the HSV model. Valid range [-1 .. 1].
$cl->setBrightness $brightness
Sets the $cls brightness in the HSV model. Valid range [0 .. 1].
$cl->addLightness $lightness
Adds to the $cls lightness in the HSL model. Valid range [-1 .. 1].
$cl->setLightness $lightness
Sets the $cls lightness in the HSL model. Valid range [0 .. 1].

Rose::Object is a simple object base class.

SYNOPSIS

package MyObject;

use Rose::Object;
our @ISA = qw(Rose::Object);

sub foo { ... }
sub bar { ... }
...

my $o = MyObject->new(foo => abc, bar => 5);
...

Rose::Object is a generic object base class. It provides very little functionality, but a healthy dose of convention.

METHODS

new PARAMS

Constructs a new, empty, hash-based object based on PARAMS, where PARAMS are name/value pairs, and then calls init (see below), passing PARAMS to it unmodified.

init PARAMS

Given a list of name/value pairs in PARAMS, calls the object method of each name, passing the corresponding value as an argument. The methods are called in the order that they appear in PARAMS. For example:

$o->init(foo => 1, bar => 2);

is equivalent to the sequence:

$o->foo(1);
$o->bar(2);

Bio::Root::Object is a core Perl 5 object.

SYNOPSIS

# Use this module as the root of your inheritance tree.
Object Creation
require Bio::Root::Object;

$dad = new Bio::Root::Object();
$son = new Bio::Root::Object(-name => Junior,
-parent => $dad,
-make => full);
See the new() method for a complete description of parameters. See also the USAGE section .

Bio::Root::Object attempts to encapsulate the "core" Perl5 object: What are the key data and behaviors ALL (or at least most) Perl5 objects should have?
Rationale

Use of Bio::Root::Object.pm within the Bioperl framework facilitates operational consistency across the different modules defined within the Bio:: namespace. Not all objects need to derive from Bio::Root::Object.pm. However, when generating lots of different types of potentially complex objects which should all conform to a set of basic expectations, this module may be handy.

At the very least, this module saves you from re-writing the new() method for each module you develop. It also permits consistent and robust handling of -tag => value method arguments via the Bio::Root::RootI::_rearrange() method and provides a object-oriented way handle exceptions and warnings via the Bio::Root::Root::throw() and Bio::Root::Root::warn() methods.

See the APPENDIX section for some other handy methods.

Fault-Tolerant Objects

A major motivation for this module was to promote the creation of robust, fault-tolerant Perl5 objects. The Bio::Root::Root::throw() method relies on Perls built-in eval{}/die exception mechanism to generate fatal exceptions. The data comprising an exception is managed by the Bio::Root::Err.pm module, which essentially allows the data thrown by a die() event to be wrapped into an object that can be easily examined and possibly re-thrown.

The intent here is three-fold:

1 Detailed error reporting.
Allow objects to report detailed information about the error condition (who, what, where, why, how).
2 Handle complex errors in objects.
The goal is to make it relatively painless to detect and handle the wide variety of errors possible with a complex Perl object. Perls error handling mechanism is a might clunky when it comes to handling complex errors within complex objects, but it is improving.
3 Efficient & easy exception handling.
To enable robust exception handling without incurring a significant performance penalty in the resulting code. Ideally, exception handling code should be transparent to the cpu until and unless an exception arises.

These goals may at times be at odds and we are not claiming to have achieved the perfect balance. Ultimately, we want self- sufficient object-oriented systems able to deal with their own errors. This area should improve as the module, and Perl, evolve. One possible modification might be to utilize Graham Barrs Error.pm module or Torsten Ekedahls Experimental::Exception.pm module (see "Other Exception Modules").

Technologies such as these may eventually be incorporated into future releases of Perl. The exception handling used by Bio::Root::Object.pm can be expected to change as Perls exception handling mechanism evolves.

TERMINOLOGY NOTE: In this discussion and elsewhere in this module, the terms "Exception" and "Error" are used interchangeably to mean "something unexpected occurred" either as a result of incorrect user input or faulty internal processing.

Ops Control Panel is a frontend for MRTG.

Unlike many other frontends, it does not have any requirements beyond those of MRTG, although it can support PHP-enabled Web servers instead of just running as a Perl CGI script.

Ops Control Panel project provides overviews of MRTG-based monitoring pages in a variety of formats.

Service Control is a basically it allows you to easily control services. Very very simple.

Currently only for Gentoos service directories, so if you use another distrobution, youll have to edit the initial combo variable to suit your needs.

NEEDS TO BE RUN AS ROOT!

Installation:

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 a while. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

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

4. You can remove the program binaries and object files from the source code directory by typing `make clean.

Ace::Object is a Perl module to manipulate Ace Data Objects.

SYNOPSIS

# open database connection and get an object
use Ace;
$db = Ace->connect(-host => beta.crbm.cnrs-mop.fr,
-port => 20000100);
$sequence = $db->fetch(Sequence => D12345);

# Inspect the object
$r = $sequence->at(Visible.Overlap_Right);
@row = $sequence->row;
@col = $sequence->col;
@tags = $sequence->tags;

# Explore object substructure
@more_tags = $sequence->at(Visible)->tags;
@col = $sequence->at("Visible.$more_tags[1]")->col;

# Follow a pointer into database
$r = $sequence->at(Visible.Overlap_Right)->fetch;
$next = $r->at(Visible.Overlap_left)->fetch;

# Classy way to do the same thing
$r = $sequence->Overlap_right;
$next = $sequence->Overlap_left;

# Pretty-print object
print $sequence->asString;
print $sequence->asTabs;
print $sequence->asHTML;

# Update object
$sequence->replace(Visible.Overlap_Right,$r,M55555);
$sequence->add(Visible.Homology,GR91198);
$sequence->delete(Source.Clone,MBR122);
$sequence->commit();

# Rollback changes
$sequence->rollback()

# Get errors
print $sequence->error;

Ace::Object is the base class for objects returned from ACEDB databases. Currently there is only one type of Ace::Object, but this may change in the future to support more interesting object-specific behaviors.

Using the Ace::Object interface, you can explore the internal structure of an Ace::Object, retrieve its content, and convert it into various types of text representation. You can also fetch a representation of any object as a GIF image.

If you have write access to the databases, add new data to an object, replace existing data, or kill it entirely. You can also create a new object de novo and write it into the database.

AJAX Tree Control is a modified version of SilverStripes tree control. It adds dynamic loading of child nodes via AJAX.

The default implementation uses the prototype library to make dynamic requests, but this behavior can be overridden by setting functions on the global Tree object.

There are a few demo Ruby on Rails applications included in the distribution that show how to use and customize the tree.