Free web objects software for linux

Python Web Objects is a dynamic page generation system that allows the developer to embed Python code inside HTML. It is similar in function to what JSP is to Java. ts a module that runs under mod_python and the Apache webserver. It is designed to offer a good balance between a providing a clean way to integrate design content from code, while doing so as fast as possible.

Download the latest version, then read the documentation. If youre into antiques, you can always browse the archives, but theres no reason to use an old version.

To install PWO, first decompress the tarball you downloaded.
$ gunzip pwo-0.XX.tar.gz
$ tar xvf pwo-0.XX.tar

Then, copy the pwo.py module into some location in your PYTHONPATH. The proper location is usually /usr/local/lib/python2.x/site-packages/
$ cp pwo-0.XX/pwo.py /usr/local/lib/python2.2/site-packages/

PWO should now be ready to use.

To configure a directory to make PWO pages, you first need to make sure that the directory is visible on the web. Ask your friendly Apache sysadmin if you dont know what this means. In this document, the path youll be keeping your .pwo files in is called /path/to/pwodir/, and its corresponding URL is http://yourserver/url/to/pwodir/.
Let Apache and mod_python know that the pwo.py will be handling requests to .pwo files in that directory. Do this by adding a few lines to our entry in your httpd.conf file.


AddHandler python-program .pwo
PythonHandler pwo
PythonDebug On



The PythonDebug directive is optional, but you will most likely want it enabled while you are developing. It will make exceptions print tracebacks to the browser in plain-text format. For security reasons, you should comment it out on production systems.
Now a file /path/to/pwodir/some_file.pwo will generate its page at http://yourserver/url/to/pwodir/some_file.pwo. Try copying a simple one of the included samples, like hello.pwo, to this directory to test your installation.
If youve never used PWO before, learn the syntax, and/or check out some sample pages.

Math Objects is a math template library written in C++ using generic programming techniques. In order to use the "Math Objects" library, the user only has to include the header files he needs (e.g. Matrix.h, Polynomial.h etc.).
In order to compile the library the user needs an ISO/IEC 14882:1998 standard compliant C++ compiler (e.g. one that supports partial template specializations).
The math library has math objects like matrices, polynomials, rational functions, extended precision numbers, complex numbers etc. that can be handled in a similar way like basic numerical types (e.g. integers or floating point numbers).
One can access properties of a mathematical type through a (partial) specialization of a traits class for that type (AlgebraicTraits). Having the traits classes to expose properties of mathematical objects, one can define for example matrices of polynomials having extended precision complex coefficients and apply to them basic linear algebra algorithms using normal C++ syntax.
This library also implements two functions using two deterministic algorithms that compute the Smith form for polynomial matrices, and the Smith-McMillan form of a transfer functions matrix also keeping track of the transformation matrices.
These algorithms can be used to describe a MIMO (multi input-multi output) system by means of its zeros and poles and also give the MFD (matrix fraction description) of the system.
Enhancements:
- Recoded the LongInt class aiming for better runtime efficiency.

Active Objects is an implementation of the Active Object concept based on the boost::thread, boost::bind, and boost::function libraries.
The point of the library is to make taking advantage of multiprocessor machines as easy as possible. The library provides two types of functionality. The first is the ability to execute a function in a separate thread and automatically synchronize with the thread when the return value is needed.
The second is the ability to easily create a message cue for any existing class, and have that class process its messages asynchronously.
Enhancements:
- Minor code cleanup and code documentation updates.

Games::Object is a Perl module to provide a base class for game objects.

SYNOPSIS

package MyGameObject;
use Games::Object;
use vars qw(@ISA);
@ISA = qw(Games::Object);

sub new {
# Create object
my $proto = shift;
my $class = ref($proto) || $proto;
my $self = $class->SUPER::new(@_);
bless $self, $class;

# Add attributes
$self->new_attr(-name => "hit_points",
-type => int,
-value => 20,
-tend_to_rate => 1);
$self->new_attr(-name => "strength",
-type => int,
-value => 12,
-minimum => 3,
-maximum => 18);
...

return $self;
}

package MyObjectManager;
use Games::Object::Manager;
use vars qw(@ISA);
@ISA = qw(Games::Object::Manager);

sub new {
my $proto = shift;
my $class = ref($proto) || $proto;
my $self = $class->SUPER::new( , @_);
bless $self, $class;
...
return $self;
}


my $world = new MyObjectManager;
my $object = new MyGameObject;
$world->add($object);

ABSTRACT

The purpose of this module is to allow a programmer to write a game in Perl easily by providing a basic framework in the form of a module that can be either subclassed to a module of your own or used directly as its own object class. The most important items in this framework are:

Attributes

You can define arbitrary attributes on objects with rules on how they may be updated, as well as set up automatic update of attributes whenever the objects process() method is invoked. For example, you could set an attribute on an object such that:

It ranges from 0 to 100.

Internally it tracks fractional changes to the value but accessing the attribute will always round the result to an integer.

It will automatically tend towards the maximum by 1 every time process() is called on the object.

A method in your subclass will be invoked automatically if the value falls to 0.
This is just one example of what you can do with attributes.

Flags

You can define any number of arbitrarily-named flags on an object. A flag is a little like a boolean attribute, in that it can have a value of either true or false. Like attributes, flags can be created independently on different objects. No "global" flag list is imposed.

Load/Save functionality

Basic functionality is provided for saving data from an object to a file, and for loading data back into an object. This handles the bulk of load game / save game processing, freeing the programmer to worry about the mechanics of the game itself.

The load functionality can also be used to create objects from object templates. An object template would be a save file that contains a single object.

Object Managers

New to version 0.10 of this module is object managers. An object manager is a Perl object that allows you to manage groups of related game objects. The object manager allows you to relate objects together (for example, you could define a relationship that allows certain objects to act as containers for other objects). In effect, the object manager acts as your world or universe.
Like the game object class, the manager class can be subclassed, allowing you augment its functionality. An object manager can be loaded and saved, which in turn performs a load or save of the objects being managed by it.

Basset::Object is a Perl module used to create objects.

This is my ultimate object creation toolset to date. It has roots in Mail::Bulkmail, Text::Flowchart, and the unreleased abstract object constructors that Ive tooled around with in the past.

If you want an object to be compatible with anything else Ive written, then subclass it off of here.

Of course, you dont have to use this to create subclasses, but youll run the risk of making something with an inconsistent interface vs. the rest of the system. Thatll confuse people and make them unhappy. So I recommend subclassing off of here to be consistent. Of course, you may not like these objects, but they do work well and are consistent. Consistency is very important in interface design, IMHO.

Web Foot Avio is a GDM theme based on wallpaper Blue Web Foot - Gnome.

Web Business Pro is a Web application designed for everyday business activities. The project includes support for customer lists, inventory, receipt printing, and accounting. Fully featured search functions and filters make it easy to find what you need quickly.

DMO stands for "Database of Managed Objects." This is a tool for documenting all objects within a data center.
Database of Managed Objects provides an object-based overlay on a MySQL database, with a Web-based interface, which allows new objects to be defined in a hierarchy.
Each object can have attributes defined, which are inherited by objects below in the hierarchy. Information can be imported in CSV or XML format, and reports can be produced in XML, CSV, PDF and HTML formats.
DMO uses PHP and MySQL to support documentation of all network and system objects within your computing environment. It offers a Web interface that enables easy navigation through objects, instances and attributes, with XML and access controls.
Enhancements:
- This is the first significant release of DMO for nearly two years.
- It works with Linux and Windows (XAMPP), but should work well with any LAMP stack including PHP4.
- New features include much more graphical viewing, as well as mapping objects onto maps with drill-down to additional layers of maps following dependency trails, a new Flash viewer for browsing through objects, and the ability to create chains of objects based on any attribute type (where any other object can be an attribute of any other object).