Team Elements is a collaboration and project management Web application featuring wikis, news and blogs, project plans, assignments, team members, shared discussions, announcements, lists, issue tracking, document storage, full-text search, reporting, and personalized RSS feeds.

Users can create a project, then invite others to participate. The project is designed for professional and personal use, with each project space containing a full set of permissions and users.

Here are some key features of "Team Elements":

· News Articles and Blogs - Keep everyone on the project informed with the latest project news
· Wiki - Quickly create a web of information; perfect for up-to-date knowledge sharing
· Discussion Groups - Centralize collaboration among project members, including status reports
· Document Management - Store and retrieve documents online, using versioning and folders
· Lists - Record project items, such as to-do items in mulitple lists
· Plans - Assign milestones and activities using an outline view of your project or import them from Excel
· Tickets - Capture issues as they arise and quickly plot a solution; a sophisticated Help Desk solution
· Team - Invite others to your project and assign them a project role
· Search - Full-text search on all project data
· Reports and RSS feeds

Whats New in This Release:

· This release improves upon the functionality and user workflow around tickets.
· Tickets now have file attachments and user subscribed email notifications.
· There is also a clear distinction among users that can submit tickets, those that can assign, and those that can complete tickets.
· A contact directory has also been added for storing user and global contact information.
· There are more than 20 general improvements throughout.

Analysis of Reinforced Concrete Elements will assist its user to find out capacity of various Reinforced Concrete Structural Elements.

The following professionals are the target audience:

Structural Engineers
Civil Engineers
Architect
Builders

Installation:

The software is web-based, so you need web-server (Apache) running with PHP. The installaton is very simple. If your document root is /var/www/html , then on uncompressing downloaded compressed file in this "document root", the URL for ARCE application become: http://YourWebSite/arce/

SWF::Element is a set of classes of SWF tags and elements.

SYNOPSIS

use SWF::Element;
use SWF::BinStream;

$swf_stream=SWF::BinStream::Write;
....
$rect=SWF::Element::RECT->new;
$rect->configure(Xmin=>0, Ymin=>0, Xmax=>100, Ymax=>100);
$rect->pack($swf_stream);
....

SWF::Element module handles SWF tags and any other sub elements to create, configure, clone, pack to bit strings, and unpack from bit strings.

SWF::Element::*

SWF::Element class is a base class of SWF element, such as Tag, RECT, SHAPE, etc. Each SWF::Element object has one or more fields.

XML::Mini::Element::Comment is used internally to represent .

You shouldnt need to use it directly, see XML::Mini::Elements comment() method.

XML::Mini::Element::DocType Perl module is used internally to represent < !DOCTYPE bla bla [ ... ] >.

You shouldnt need to use it directly, see XML::Mini::Elements docType() method.

XML::Mini::Element::CData Perl module is used internally to represent < ![CDATA [ CONTENTS ]] >.

You shouldnt need to use it directly, see XML::Mini::Elements cdata() method.

XML::Mini::Element::Entity Perl module is used internally to represent < !ENTITY name "stuff" >.

You shouldnt need to use it directly, see XML::Mini::Elements entity() method.

XML::Mini::Element::Header Perl module is used internally to represent < ? xml blah="hohoho" ? > type headers.

You shouldnt need to use it directly, see XML::Mini::Elements header() method.

XML::DOM::Element is an XML element node in XML::DOM.

XML::DOM::Element extends XML::DOM::Node.

By far the vast majority of objects (apart from text) that authors encounter when traversing a document are Element nodes. Assume the following XML document:

< elementExample id="demo" >
< subelement1/ >
< subelement2 >< subsubelement/ >< /subelement2 >
< /elementExample >

When represented using DOM, the top node is an Element node for "elementExample", which contains two child Element nodes, one for "subelement1" and one for "subelement2". "subelement1" contains no child nodes.

Elements may have attributes associated with them; since the Element interface inherits from Node, the generic Node interface method getAttributes may be used to retrieve the set of all attributes for an element. There are methods on the Element interface to retrieve either an Attr object by name or an attribute value by name.

In XML, where an attribute value may contain entity references, an Attr object should be retrieved to examine the possibly fairly complex sub-tree representing the attribute value. On the other hand, in HTML, where all attributes have simple string values, methods to directly access an attribute value can safely be used as a convenience.

SVG::Element is a Perl module to generate the element bits for SVG.pm.

SVG.pm makes it possible to generate fully-functional SVG images in perl.
100% of the SVG tags are supported, and any new arbitrary element tag can be
added by users by declaring it.

***THERE ARE FIVE WAYS TO IMPLEMENT SVG MODULE IN PERL***

1/ Systems with CPAN support (all Unix/Linux/BSD/Mac):
-----------------------------------------------------
Install the new distribution via the Perl CPAN module:
In a shell:

/home/somewhere% perl -MCPAN -e"install SVG"

2/ (WIN) install Perl from Active State or equivalent:
-----------------------------------------------------
Make sure you already have perl or get it here: http://www.activestate.com
On the command line:
C:> ppm
PPM> set repository tmp http://roasp.com/PPM/SVG/
PPM> install SVG
PPM> quit
C:>

3/ Use Source RPMs.
Download the source RPM of your choice.
In a shell:
/hom/somewhere/% rpm -ihv SVG-source-rpm-name
You may be prompted for the root password

4/ The hard way (requires make or nmake, tar, gunzip, and gcc):
---------------------------------------------------------------
This method was tested in DOS, Windows, AS400, Linux, Unix, BSD, Mac.
Hard-headed users can directly get the distribution from
http://www.roasp.com/PPM/SVG/SVG-2.27.tar.gz or
http://www.roasp.com/PPM/SVG/ .
First download the source.
Then, in a shell:
/home/somewhere% gunzip SVG-2.27.tar.gz
/home/somewhere% tar-xvf SVG-2.27.tar
cd SVG-2.1
make
make test
make install


5/ If all the above fail, there is still a (cumbersome) way:
-----------------------------------------------------------
You have to install to a local dirctory and explicitly call the module
by using one of the following line in your calling program:

#using use lib
use lib path/where/the/release/is/located;

-or-

#using BEGIN block at the beginning of the file
BEGIN {
push @INC path/to/svg.pm-file; #where the SVG.pm file lives
push @INC path/to/svg.pm-file/SVG; # where the Utils.pm file lives
}
#Refer to the Perl manual for more details.

YAPE::Regex::Element contains sub-classes for YAPE::Regex elements.

SYNOPSIS

use YAPE::Regex MyExt::Mod;
# this sets up inheritence in MyExt::Mod
# see YAPE::Regex documentation

YAPE MODULES

The YAPE hierarchy of modules is an attempt at a unified means of parsing and extracting content. It attempts to maintain a generic interface, to promote simplicity and reusability. The API is powerful, yet simple. The modules do tokenization (which can be intercepted) and build trees, so that extraction of specific nodes is doable.

Methods for YAPE::Regex::Element

This class contains fallback methods for the other classes.
my $str = $obj->text;
Returns a string representation of the content of the regex node itself, not any nodes contained in it. This is undef for non-text nodes.
my $str = $obj->string;
Returns a string representation of the regex node itself, not any nodes contained in it.
my $str = $obj->fullstring;
Returns a string representation of the regex node, including any nodes contained in it.
my $quant = $obj->quant;
Returns a string with the quantity, and a ? if the node is non-greedy. The quantity is one of *, +, ?, {M,N}, or an empty string.
my $ng = $obj->ngreed;
Returns a ? if the node is non-greedy, and an empty string otherwise.

Methods for YAPE::Regex::anchor

This class represents anchors. Objects have the following methods:
my $anchor = YAPE::Regex::anchor->new($type,$q,$ng);
Creates a YAPE::Regex::anchor object. Takes three arguments: the anchor (^, A, $, Z, z, B, b, or G), the quantity, and the non-greedy flag. The quantity should be an empty string.
my $anc = YAPE::Regex::anchor->new(A, , ?);
# /A?/
my $type = $anchor->type;
Returns the string anchor.
Methods for YAPE::Regex::macro
This class represents character-class macros. Objects have the following methods:
my $macro = YAPE::Regex::macro->new($type,$q,$ng);
Creates a YAPE::Regex::macro object. Takes three arguments: the macro (w, W, d, D, s, or S), the quantity, and the non-greedy flag.
my $macro = YAPE::Regex::macro->new(s, {3,5});
# /s{3,5}/
my $text = $macro->text;
Returns the macro.
print $macro->text; # s
my $type = $macro->type;
Returns the string macro.

Methods for YAPE::Regex::oct

This class represents octal escapes. Objects have the following methods:
my $oct = YAPE::Regex::oct->new($type,$q,$ng);
Creates a YAPE::Regex::oct object. Takes three arguments: the octal number (as a string), the quantity, and the non-greedy flag.
my $oct = YAPE::Regex::oct->new(040);
# / 40/
my $text = $oct->text;
Returns the octal escape.
print $oct->text; # 40
my $type = $oct->type;
Returns the string oct.

Methods for YAPE::Regex::hex

This class represents hexadecimal escapes. Objects have the following methods:
my $hex = YAPE::Regex::hex->new($type,$q,$ng);
Creates a YAPE::Regex::hex object. Takes three arguments: the hexadecimal number (as a string), the quantity, and the non-greedy flag.
my $hex = YAPE::Regex::hex->new(20,{2,});
# /x20{2,}/
my $text = $hex->text;
Returns the hexadecimal escape.
print $hex->text; # x20
my $type = $hex->type;
Returns the string hex.

Methods for YAPE::Regex::utf8hex

This class represents UTF hexadecimal escapes. Objects have the following methods:
my $hex = YAPE::Regex::utf8hex->new($type,$q,$ng);
Creates a YAPE::Regex::utf8hex object. Takes three arguments: the hexadecimal number (as a string), the quantity, and the non-greedy flag.
my $utf8hex = YAPE::Regex::utf8hex->new(beef,{0,4});
# /x{beef}{2,}/
my $text = $utf8hex->text;
Returns the hexadecimal escape.
print $utf8hex->text; # x{beef}
my $type = $utf8hex->type;
Returns the string utf8hex.

Methods for YAPE::Regex::backref

This class represents back-references. Objects have the following methods:
my $bref = YAPE::Regex::bref->new($type,$q,$ng);
Creates a YAPE::Regex::bref object. Takes three arguments: the number of the back-reference, the quantity, and the non-greedy flag.
my $bref = YAPE::Regex::bref->new(2,,?);
# /2?/
my $text = $bref->text;
Returns the backescape.
print $bref->text; # 2
my $type = $bref->type;
Returns the string backref.

Methods for YAPE::Regex::ctrl

This class represents control character escapes. Objects have the following methods:
my $ctrl = YAPE::Regex::ctrl->new($type,$q,$ng);
Creates a YAPE::Regex::ctrl object. Takes three arguments: the control character, the quantity, and the non-greedy flag.
my $ctrl = YAPE::Regex::ctrl->new(M);
# /cM/
my $text = $ctrl->text;
Returns the control character escape.
print $ctrl->text; # cM
my $type = $ctrl->type;
Returns the string ctrl.

Methods for YAPE::Regex::named

This class represents named characters. Objects have the following methods:
my $ctrl = YAPE::Regex::named->new($type,$q,$ng);
Creates a YAPE::Regex::named object. Takes three arguments: the name of the character, the quantity, and the non-greedy flag.
my $named = YAPE::Regex::named->new(GREEK SMALL LETTER BETA);
# /N{GREEK SMALL LETTER BETA}/
my $text = $named->text;
Returns the character escape text.
print $named->text; # N{GREEK SMALL LETTER BETA}
my $type = $named->type;
Returns the string named.

Free Finite Element Package is a modular collection of C libraries which contain numerical methods required when working with linear and quadratic finite elements in two dimensions.

FFEP works on GNU/Linux and is portable to every system where MEML (i.e. LAPACK and BLAS) are available. The goal of FFEP is to provide basic functions for approximating the solution of elliptic and parabolic partial differential equation in two dimensions with Dirichlet and Neumann boundary conditions.

XML::Mini::Element is a Perl implementation of the XML::Mini Element API.

SYNOPSIS

use XML::Mini::Document;

my $xmlDoc = XML::Mini::Document->new();

# Fetch the ROOT element for the document
# (an instance of XML::Mini::Element)
my $xmlElement = $xmlDoc->getRoot();

# Create an tag
my $xmlHeader = $xmlElement->header(xml);

# add the version to get