Free tt software for linux

Template::Alloy::TT Perl module contains a Template::Toolkit role.

The Template::Alloy::TT role provides the syntax and the interface for Template::Toolkit version 1, 2, and 3. It also brings many of the features from the various templating systems.

And it is fast.

See the Template::Alloy documentation for configuration and other parameters.

Font::TTF::Glyph is a Perl module that holds a single glyphs information.

This is a single glyph description as held in a TT font. On creation only its header is read. Thus you can get the bounding box of each glyph without having to read all the other information.

INSTANCE VARIABLES

In addition to the named variables in a glyph header (xMin etc.), there are also all capital instance variables for holding working information, mostly from the location table.

The standard attributes each glyph has are:

numberOfContours
xMin
yMin
xMax
yMax

There are also other, derived, instance variables for each glyph which are read when the whole glyph is read (via read_dat):

instLen

Number of bytes in the hinting instructions (Warning this variable is deprecated, use length($g-{hints})> instead).

hints

The string containing the hinting code for the glyph
In addition there are other attribute like instance variables for simple glyphs:

For each contour there is:

endPoints

An array of endpoints for each contour in the glyph. There are numberOfContours contours in a glyph. The number of points in a glyph is equal to the highest endpoint of a contour.

There are also a number of arrays indexed by point number

flags

The flags associated with reading this point. The flags for a point are recalculated for a point when it is updated. Thus the flags are not very useful. The only important bit is bit 0 which indicates whether the point is an on curve point, or an off curve point.

x

The absolute x co-ordinate of the point.

y

The absolute y co-ordinate of the point

For composite glyphs there are other variables

metric

This holds the component number (not its glyph number) of the component from which the metrics for this glyph should be taken.

comps

This is an array of hashes for each component. Each hash has a number of elements:

glyph

The glyph number of the glyph which comprises this component of the composite.

args

An array of two arguments which may be an x, y co-ordinate or two attachment points (one on the base glyph the other on the component). See flags for details.

flag

The flag for this component

scale

A 4 number array for component scaling. This allows stretching, rotating, etc. Note that scaling applies to placement co-ordinates (rather than attachment points) before locating rather than after.

numPoints

This is a generated value which contains the number of components read in for this compound glyph.

The private instance variables are:

INFILE (P)

The input file form which to read any information

LOC (P)

Location relative to the start of the glyf table in the read file

BASE (P)

The location of the glyf table in the read file

LEN (P)

This is the number of bytes required by the glyph. It should be kept up to date by calling the update method whenever any of the glyph content changes.

OUTLOC (P)

Location relative to the start of the glyf table. This variable is only active whilst the output process is going on. It is used to inform the location table where the glyphs location is, since the glyf table is output before the loca table due to alphabetical ordering.

OUTLEN (P)

This indicates the length of the glyph data when it is output. This more accurately reflects the internal memory form than the LEN variable which only reflects the read file length. The OUTLEN variable is only set after calling out or out_dat.

OpenInteract2::TT2::Plugin is a Perl module for custom OpenInteract functionality in templates.

SYNOPSIS

# Create the TT object with the OI plugin

my $template = Template->new(
PLUGINS => { OI => OpenInteract2::TT2::Plugin }, ... );
my ( $output );
$template->process( package::template, %params, $output );

# In the template (brief examples, see below for more)

Here is what the plugin can do:
< ul>< li>[% OI.show_all_actions.join( "n < li>" ) -%]< /ul>

Here are plugins available to you:
[% OI.show_all_plugins.keys.sort.join( , ) %]

Here are all the parameters passed to the request:
[% OI.request_param.sort.join( , ) %]

And the value of a particular parameter:
last name: [% OI.request_param( last_name ) %]

[% OI.action_execute( error_display, error_msg = error_msg ) -%]

# Note that you can also use the MSG function
[% OI.msg( mypage.intro, OI.login.full_name ) %]

# Note that you can also use the LH variable
[% mh = OI.msg_handle %]
[% mh.maketext( mypage.intro, OI.login.full_name ) %]
[% mh.maketext( mypage.learnmore ) %]

[% OI.box_add( contact_tools_box, title = Contact Tools,
weight = 2 ) -%]

[% object_info = OI.object_description( object ) %]
This is a [% object_info.name %] object.

Is the object in the class?
[% OI.class_isa( object, SPOPS::DBI ) ? yes : no %]

Is the SPOPS object writable?
[% IF OI.can_write( object ) %]Youre special![% END %]

[% action = OI.action %]
Action that called this template: [% action.name %]
Security for action:
[% action.security_level %] found,
[% action.security_required %] required

Properties of action:
[% action_prop = action.properties %]
[% FOREACH key = action_prop.keys %]
[% key %] = [% action_prop.$key %]
[% END %]

Parameters of action:
[% action_param = action.param %]
[% FOREACH key = action_param.keys %]
[% key %] = [% action_param.$key %]
[% END %]

Today is [% OI.date_format( now, %Y-%m-%d %l:%M %p ) %] the
[% OI.date_format( now, %j ) %] day of the year

[% d = OI.date_into_object( object.updated_on, %Y-%m-%d ) -%]
[% OI.action_execute( date_select, month_value = d.month,
day_value = d.day,
year_value = d.year, blank = 1,
field_prefix = updated_on ) -%]

[% INCLUDE form_checkbox( name = is_in_print,
value = TRUE,
is_checked = OI.as_boolean( book.is_in_print ) ) -%]

Is in print? [% OI.as_boolean_label( book.is_in_print ) %]

Is in print? [% OI.as_boolean_label( book.is_in_print, You betcha, No way ) %]

[% OI.limit_string( object.description, 30 ) %]

var person_last_name = [% OI.javascript_quote( person.last_name ) %];

[% OI.limit_sentences( news.news_item, 3 ) %]

[% score = grade.score / test.total %]
Your grade is: [% OI.percent_format( score ) %]

You have [% OI.money_format( account.balance ) %] left to spend.

Hello [% OI.uc_first( person.first_name ) %]

You are important so I must speak to you loudly [% OI.uc( person.last_name ) %]



Item: [% OI.html_decode( news.news_item ) %]

# Add parameters to an existing URL
[% display_no_template_url = OI.add_params_to_url( my_path, no_template = yes ) %]

# Works, but not as useful...
[% edit_url = OI.make_url( BASE = /User/show/, user_id = OI.login.user_id,
edit = 1, show_all = yes ) %]

# Preferred way to generate URLs for actions
[% edit_url = OI.make_url( ACTION = user, TASK = show,
user_id = OI.login.user_id,
edit = 1, show_all = yes ) %]

[% image_url = OI.make_url( IMAGE = /images/foo.gif ) %]
[% static_url = OI.make_url( STATIC = /generated/report-q1-2003.pdf ) %]

[% theme = OI.theme_properties %]
Background color of page: [% theme.bgcolor %]

[% new_theme = OI.theme_fetch( 5 ) %]
Background color of page from other theme: [% new_theme.bgcolor %]

[% IF OI.logged_in -%]
Hello [% OI.login.full_name %].
Your groups are: [% OI.login_group.join( , ) -%]
[% ELSE -%]
You are not logged in.
[% END -%]

Your last search: [% OI.session.latest_search %]

< a href="[% OI.return_url %]">Refresh< /a>

[% IF object.tmp_security_level >= OI.security_level.write -%]
you can edit this object!
[% END %]

Catalyst is a Perl module that contains the elegant MVC web application framework.

SYNOPSIS

See the Catalyst::Manual distribution for comprehensive documentation and tutorials.

# Install Catalyst::Devel for helpers and other development tools
# use the helper to create a new application
catalyst.pl MyApp

# add models, views, controllers
script/myapp_create.pl model MyDatabase DBIC::Schema create=dynamic dbi:SQLite:/path/to/db
script/myapp_create.pl view MyTemplate TT
script/myapp_create.pl controller Search

# built in testserver -- use -r to restart automatically on changes
# --help to see all available options
script/myapp_server.pl

# command line testing interface
script/myapp_test.pl /yada

### in lib/MyApp.pm
use Catalyst qw/-Debug/; # include plugins here as well

### In lib/MyApp/Controller/Root.pm (autocreated)
sub foo : Global { # called for /foo, /foo/1, /foo/1/2, etc.
my ( $self, $c, @args ) = @_; # args are qw/1 2/ for /foo/1/2
$c->stash->{template} = foo.tt; # set the template
# lookup something from db -- stash vars are passed to TT
$c->stash->{data} =
$c->model(Database::Foo)->search( { country => $args[0] } );
if ( $c->req->params->{bar} ) { # access GET or POST parameters
$c->forward( bar ); # process another action
# do something else after forward returns
}
}

# The foo.tt TT template can use the stash data from the database
[% WHILE (item = data.next) %]
[% item.foo %]
[% END %]

# called for /bar/of/soap, /bar/of/soap/10, etc.
sub bar : Path(/bar/of/soap) { ... }

# called for all actions, from the top-most controller downwards
sub auto : Private {
my ( $self, $c ) = @_;
if ( !$c->user_exists ) { # Catalyst::Plugin::Authentication
$c->res->redirect( /login ); # require login
return 0; # abort request and go immediately to end()
}
return 1; # success; carry on to next action
}

# called after all actions are finished
sub end : Private {
my ( $self, $c ) = @_;
if ( scalar @{ $c->error } ) { ... } # handle errors
return if $c->res->body; # already have a response
$c->forward( MyApp::View::TT ); # render template
}

### in MyApp/Controller/Foo.pm
# called for /foo/bar
sub bar : Local { ... }

# called for /blargle
sub blargle : Global { ... }

# an index action matches /foo, but not /foo/1, etc.
sub index : Private { ... }

### in MyApp/Controller/Foo/Bar.pm
# called for /foo/bar/baz
sub baz : Local { ... }

# first Root auto is called, then Foo auto, then this
sub auto : Private { ... }

# powerful regular expression paths are also possible
sub details : Regex(^product/(w+)/details$) {
my ( $self, $c ) = @_;
# extract the (w+) from the URI
my $product = $c->req->captures->[0];
}

Tiny Tiny RSS is a server-side RSS feed aggregator written in PHP and heavily based on XmlHttpRequest and related technologies for user interface and operation.

For years Ive been searching for a perfect RSS aggregator. I tried desktop ones (Straw, Blam!, Liferea) - while nice programs they usually lacked something or were overencumbered with features. Also, desktop aggregators cant solve the problem of keeping read feeds in sync between different machines.

I tried server-side aggregators, several ones. Unfortunately, I didnt find anything that felt usable, they had all the problems of classical web applications - clunky interface, no realtime updates, just not designed the way I like it, etc.

Well, then the obvious solution was to write an aggregator myself. I also felt the need to exercise in simple XmlHttpRequest web application programming, so TT-RSS was born. While obviously being on early stages on development and pretty much unfinished it offers a lot of functionality of desktop application while staying on server-side with all the benefits it provides.

Catalyst::Enzyme is a CRUD framework for Catalyst.

SYNOPSIS

#Create app
catalyst BookShelf
cd BookShelf

#Create View
scriptbookshelf_create.pl view TT Enzyme::TT

#Create database
... left as an exercise for the reader (actually, see the tutorial) ...

#Create Models for all tables
scriptbookshelf_create.pl model BookShelfDB Enzyme::CDBI dbi:SQLite:dbname=db/bookshelf.db

#Create Controller
scriptbookshelf_create.pl controller Book Enzyme::CRUD BookShelfDB::Book

Browse to http://localhost:3000/book and see what it looks like without any configuration.

See the "DEMO APPLICATION" below for a ready-to-run example of the BookDB.

See the "TUTORIAL" below for a detailed example of how to create an application from the BookDB schema.

Catalyst::Enzyme is a layer on top of the Catalyst framework providing CRUD functionality for Class::DBI models.

Enzyme uses convention and configuration to provide e.g. extensible CRUD out-of-the-box, and a common way of dealing with error handling etc.

Its not completely unlike Maypole in this regard. However, at this point Enzyme isnt as feature-rich as Maypole.

Enzyme is one way of bringing many Catalyst modules and concepts together into a unified whole. There are other ways to do this (obviously. This is, like... uh, Perl).

Gantry::Docs::About is a document explaining Gantrys features and history.
History
Along about 1997 or so, our company (a cable/ISP owned by a newspaper) began serving mod_perl apps to staff and customers. A framework developed and flourished. It was simple, explicit, and fast enough for the high-volume sites run by our parent newspaper. As time passed, improvements were made until a second version was conceived and deployed.
Finally, in August of 2005, a third revision was completed which is now available as an open source product (under the standard Perl license). The new version has lots of new features and removes some of the arcana that built up over the previous six or so years. Notably, it gained an MVC structure and some nifty automated CRUD. But the newly released third version, now called Gantry, retains simplicity, explicitness, speedy throughput, and the ability to host complex projects.
Main features:
- a central mod_perl handler all apps may inherit (Gantry.pm)
- CGI/FastCGI support (Gantry::Engine::CGI)
- automated CRUD (create, retrieve, update, delete) for straightforward tables (Gantry::Plugins::AutoCRUD)
- flexible CRUD for the sophisticated parts of applications (Gantry::Plugins::CRUD)
- easy date entry (via javascript code in form.tt)

SVG::Template::Graph is a Perl extension for generating template-driven graphs with SVG.

SYNOPSIS

use SVG::Template::Graph;
$data = [
{
barGraph=>1,#
barSpace=>20,
title=> 1: Trace 1,
data => #hash ref containing x-val and y-val array refs
{
x_val =>
[50,100,150,200,250,
300,350,400,450,500,550],
y_val =>
[100,150,100,126,100,
175,100,150,120,125,100],

},
format =>
{ #note that these values could change for *each* trace
lineGraph => 1,
x_min => 0,
x_max => 600,
y_min => 50,
y_max => 200,
x_axis => 1, #draw x-axis
y_axis => 1, #draw y-axis

#define the labels that provide the data context.
labels =>
{
#for year labels, we have to center the axis markers
x_ticks =>
{
label =>[2002,2003,2004],
position=>[100,300,500],
},
y_ticks =>
{
#tick mark labels
label => [ -250, 0, 250, 500],
#tick mark location in the data space
position => [50, 100, 150, 200],
},
},
},
},
];


#construct a new SVG::Template::Graph object with a file handle
my $tt = SVG::Template::Graph->new($file);

#set up the titles for the graph
$tt->setGraphTitle([Hello svg graphing world,I am a subtitle]);

#generate the traces.
$tt->drawTraces($data,$anchor_rectangle_id);
#serialize and print
print $tt->burn();

Template::Graph:SVG is a module for the generation of template-driven graphs using Scalable Vector Graphics (SVG). Using this module, it is possible to define a template SVG document with containers which are populated with correctly scaled plot images.