Free para frame software for linux

Para::Frame is a system to use for dynamic web sites. Para::Frame runs as a backend daemon taking page requests from a Apache mod_perl client and returns a HTTP response.
The URLs in the site corresponds to templates for displaying information. Operations on the data is put in perl modules separated from the templates.
Para::Frame handles multitasking within the process, enabeling you to keep your initialized objects in memory with no need to sync with the DB for each request.
The session data lives in memory. No need to save it in an external format.
Para::Frame uses "routes" for planning things to do in a session, taking care of which page to display next, depending on form actions. Integrated with exception handling.
One Para::Frame daemon can handle many sites on the same server. It uses the Apache configuration for handling URL to file translation.
You can have any number of Para::Frame daemons running in parallell on the same server. Maby using one for development, one for the stable version and one backup in case of failure. You can easily configure the site to use a backup daemon as a last resort.
A Watchdog makes sure that the system works. It pings the daemon in regular intervals and restarts it if locks up or if the memory limit is reached. The restart is done by forking.
There are tons of useful functions.
Enhancements:
- A lot of major changes and additions were made.
- 19 new classes were added, including classes for relational database access, internationalization, and file and directory handling.
- The server/client communication has changed and is now safer and faster.
- A load-page will display a progress report from the server before the new page is loaded.
- The html/pf directory now contains some default images, styles, JavaScript, and more.
- A demo has been included.

DBIx::Frame is a Perl module for creating and maintaining DBI frameworks.

SYNOPSIS

use DBIx::Frame;
DBIx::Frame->init(server, dbtype) || exit(0);
my $DB = DBIx::Frame->new(database, user, pass)
or die("Couldnt connect to database: ", DBI->errstr);
See below for how to actually use this object.

DBIx::Frame is an extension of the standard DBI perl module, designed around mysql, and used to create and maintain frameworks for databases. It has query logging, and a standardized interface for standard SQL statements like update and insert that doesnt require understanding SQL to any great degree.

Ideally, the user or developer shouldnt have to know too much SQL to be able to administer a database. On the other hand, it does require a certain setup that isnt necessarily easy to pick up, and isnt standard SQL - with all the problems that this entails.

Database design is discussed below.

CGI::AppBuilder::Frame is a configuration initializer.

SYNOPSIS

use CGI::AppBuilder::Frame;

my $ab = CGI::AppBuilder::Frame- >new(
ifn, my_init.cfg, opt, vhS:a:);
my ($q, $ar, $ar_log) = $ab- >start_app($0, %ARGV);
print $ab- >disp_form($q, $ar);

This class provides methods for reading and parsing configuration files.
new (ifn = > file.cfg, opt = > hvS:)

This is a inherited method from CGI::AppBuilder. See the same method in CGI::AppBuilder for more details.

frame_set ($fr, $pr)

Input variables:

$fr - frame set definiton array reference. The $fr contains two
elements [$hr, $ar]:
$hr - a hash ref containing the frame set attributes
$ar - a array ref containing hash references defining each
frames in the frame set.
$pr - tag attribute array ref. It contains three elements:
class - CSS class name
attr - attribute string such as width=5 onChange=js_func
hr - hash ref with key and value pairs. This will be obtained
from $fr for each frame set and frame.
pretty - whether to add line breaks

Variables used or methods called:

CGI::AppBuilder::Table
html_tag - generate HTML tags
CGI::AppBuilder::Message
echo_msg - display message

How to use:

The following shows how to define the frame array ($fr):

+-+----+ The following defines the left layout:
| | T |
| +----+ [{cols= >"150,*"},[
| | | {src= >"left.htm",name= >"L"},
|L| C | [{rows= >"100,*,50"},[
| | | {src= >"top.htm",name= >"T"},
| |----| {src= >"main.htm",name= >"C"},
| | B | {src= >"bottom.htm",name= >"B"}]]]
+-+----+ ]

In YAML, here is how it looks like:

---
cols: 150,*
- src: left.htm
name: L
- rows: 100,*,50
- src: top.htm
name: T
- src: main.htm
name: C
- src: bottom.htm
name: B
...

+-+------+ The following defines the left layout:
| | T |
| +----+-+ [{cols= >"150,*"},[
| | | | {src= >"left.htm",name= >"L"},
|L| C |R| [{rows= >"100,*,50"},[
| | | | {src= >"top.htm",name= >"T"},
| | | | [{cols= >"*,100"},[
| |----+-+ {src= >"main.htm",name= >"C"},
| | | {src= >"right.htm",name= >"R"}] ] ],
| | B | {src= >"bottom.htm",name= >"B"}]]
+-+----+-+ ]
In YAML, here is how it looks like:
---
cols: 150,*
- src: left.htm
name: L
- rows: 100,*,50
- src: top.htm
name: T
- cols: *,100
- src: main.htm
name: C
- src: right.htm
name: R
- src: bottom.htm
name: B
...
Here is the testing codes:
my $fr = [{cols= >"150,*"},[
{src= >"left.htm",name= >"L"},
[{rows= >"100,*,50"},[
{src= >"top.htm",name= >"T"},
{src= >"main.htm",name= >"C"},
{src= >"bottom.htm",name= >"B"}]
]]
];
my $pr = {pretty= >1};
print $obj- >frame_set($fr,$pr);
# the following is the result:

< FRAMESET cols=150,* >
< FRAME src=left.htm name=L >
< FRAMESET rows=100,*,50 >
< FRAME src=top.htm name=T >
< FRAME src=main.htm name=C >
< FRAME src=bottom.htm name=B >
< / FRAMESET >
< / FRAMESET >

$pr- >{_frameset_count} = 0; # reset frame set counter
my $f2 = [ {cols= >"150,*"},[
{src= >"left.htm",name= >"L"},
[{rows= >"100,*,50"},[
{src= >"top.htm",name= >"T"},
[{cols= >"*,100"},[
{src= >"main.htm",name= >"C"},
{src= >"right.htm",name= >"R"}]
],
{src= >"bottom.htm",name= >"B"}]
]]
];
print $obj- >frame_set($f2,$pr);
# the following is the result:

< FRAMESET cols=150,* >
< FRAME src=left.htm name=L >
< FRAMESET rows=100,*,50 >
< FRAME src=top.htm name=T >
< FRAMESET cols=*,100 >
< FRAME src=main.htm name=C >
< FRAME src=right.htm name=R >
< / FRAMESET >
< FRAME src=bottom.htm name=B >
< / FRAMESET >
< / FRAMESET >

Return: HTML codes.

This method generates HTML codes based on the information provided. This method is also called < I >frameset< / I >.

AxKit2::Transformer::XSP Perl module contains eXtensible Server Pages.

SYNOPSIS

< xsp:page
xmlns:xsp="http://apache.org/xsp/core/v1" >

< xsp:structure >
< xsp:import >Time::Piece< /xsp:import >
< /xsp:structure >

< page >
< title >XSP Test< /title >
< para >
Hello World!
< /para >
< para >
Good
< xsp:logic >
if (localtime->hour >= 12) {
< xsp:content >Afternoon< /xsp:content >
}
else {
< xsp:content >Morning< /xsp:content >
}
< /xsp:logic >
< /para >
< /page >

< /xsp:page >

XSP implements a tag-based dynamic language that allows you to develop your own tags, examples include sendmail and sql taglibs. It is AxKits way of providing an environment for dynamic pages. XSP is originally part of the Apache Cocoon project, and so you will see some Apache namespaces used in XSP.

Also, use only one XSP processor in a pipeline. XSP is powerful enough that you should only need one stage, and this implementation allows only one stage. If you have two XSP processors, perhaps in a pipeline that looks like:

... => XSP => XSLT => XSLT => XSP => ...

it is pretty likely that the functionality of the intermediate XSLT stages can be factored in to either upstream or downstream XSLT:

... => XSLT => XSP => XSLT => ...

This design is likely to lead to a clearer and more maintainable implementation, if only because generating code, especially embedded Perl code, in one XSP processor and consuming it in another is often confusing and even more often a symptom of misdesign.

Likewise, you may want to lean towards using Perl taglib modules instead of upstream XSLT "LogicSheets". Upstream XSLT LogicSheets work fine, mind you, but using Perl taglib modules results in a simpler pipeline, simpler configuration (just load the taglib modules in httpd.conf, no need to have the correct LogicSheet XSLT page included whereever you need that taglib), a more flexible coding environment, the ability to pretest your taglibs before installing them on a server, and better isolation of interface (the taglib API) and implementation (the Perl module behind it). LogicSheets work, and can be useful, but are often the long way home. That said, people used to the Cocoon environment may prefer them.

Result Code

You can specify the result code of the request in two ways. Both actions go inside a < xsp:logic > tag.

If you want to completely abort the current request, throw an exception:

throw Apache::AxKit::Exception::Retval(return_code => FORBIDDEN);

If you want to send your page but have a custom result code, return it:

return FORBIDDEN;

In that case, only the part of the document that was processed so far gets sent/processed further.

Debugging

If you have PerlTidy installed (get it from http://perltidy.sourceforge.net), the compiled XSP scripts can be formatted nicely to spot errors easier. Enable AxDebugTidy for this, but be warned that reformatting is quite slow, it can take 20 seconds or more on each XSP run for large scripts.

If you enable AxTraceIntermediate, your script will be dumped alongside the other intermediate files, with an extension of ".XSP". These are unnumbered, thus only get one dump per request. If you have more than one XSP run in a single request, the last one will overwrite the dumps of earlier runs.

Animation fade-loop is a plugin for GIMP that can convert an animation to make it look better when played in a continuous loop (e.g. for DVD menus).

"This plug-in copies an animation frame by frame and adds a cross-fade effect at the end so that the last frame blends seamlessly back to the first.

Note that because of the resulting overlap, the output animation is [fade_length] frames shorter than the input. The currently loaded gimp image should be the first frame of the input animation.

Clearbox is a customizable theme for the Metacity Window Manager.
A small GTK application allow configure the differents theme aspects, preview the theme and save it in the user themes folder.
The options that can be configured in the Clearbox theme are the following ones:
- Topbar style
- Clearbox-out, Clearbox-in or flat
- Gradient intensity (3 levels)
- Frame style
- Square corners or rounded corners
- Border width
- Colorized borders
- Interior outline
- 3D effect borders
- Title position
- Left or center
- Text with shadow
- Controls style
- Simple, with dark frame or with clear frame
- Buttons size
- Buttons gap
- Button menu style
- Arrow or application icon
- Theme colors
- GTK theme colors or custom colors

Convert::Wiki::Node::Para is a Perl module that represents a text paragraph node.

SYNOPSIS

use Convert::Wiki::Node::Para;

my $para = Convert::Wiki::Node->new( txt => Foo is a foobar., type => para );

print $para->as_wiki();

A Convert::Wiki::Node::Para represents a normal text paragraph.

Artwork.pl is a script to retrieve album art images from the APIC frame of ID3v2 MP3 tags. It places the album art image file in the MP3 folder with the name of your choosing.

It requires the MP3::Tag, File::Find, Image::Magick Perl modules. This project is an effective tool to create album art JPEG files for music jukebox applications such as Andromeda and Jinzora.