Free sharepoint templates software for linux

SmartTemplate is a Template Engine that was designed to support large scale, web based applications.
Whats so special about it?
Common template engines work like the following: Your PHP script specifies an HTML template and assigns some dynamic content to display. The template parser replaces all placeholders within the template with the assigned content and displays it to the user. This means a lot of string processing and regular expression work each time you want to display some content.
SmartTemplate works like a template compiler that converts templates into executable PHP code and stores it for later reuse. The first time a new template is processed, all placeholders in the template are replaced by small PHP code elements that print the assigned content. The HTML template fragment < H3 >{TITLE}< /H3 >, for example, is converted into something like < H3 >< ?php echo $TITLE; ? >< /H3 >. If you have assigned your content to the right variables, there is no need for any template parsing anymore. The only thing that has to be done is to include and execute the compiled template. This usually increases the execution time of the template engine dramatically.
SmartTemplate supports:
- Simple Scalar Substitution (Strings, etc.)
- Block Iterations (nested Arrays / BEGIN..END)
- Basic Control Structures (IF..ELSEIF..ELSE)
- Custom Extension (Output filters, uppercase, sprintf, etc.)
- Template Compilation (HTML templates are converted to executable PHP Code)
- SubTemplate System (HTML templates can be included on other templates)
- Output Caching (Accelerates your applications by reusing page output)

HCKit::Template is a Perl module with a template system for HTML construction.

This module constructs an HTML page from a template. The conversion proceeds with the help of rewrite rules and data sources. Rewrite rules can be specified in the template file itself, or in the Perl script. Data sources can be XML files, or dynamically constructed in the Perl script.

HTML::Template module attempts to make using HTML templates simple and natural.
HTML::Template library extends standard HTML with a few new tags for variables, loops, if/else blocks and includes.
A file written with HTML and these new tags is called a template. Using this module you fill in the values for the variables and loops declared in the template.
This allows you to seperate design (the HTML) from the data, which you generate in the Perl script. While there are many other HTML template systems available, this module is simple and fast.
It doesnt try to reinvent Perl CGI, it just augments HTML with a few new and very useful abilities.
Enhancements:
- A new option was added to enforce Taint mode for unescaped variables.
- Several long-standing bugs were fixed.
- The enhanced tests produced by the Phalanx project are now part of the module.

Smarty project is a template engine for PHP. Many other template engines for PHP provide basic variable substitution and dynamic block functionality.
Smarty takes a step further to be a "smart" template engine, adding features such as configuration files, template functions, and variable modifiers, and making all of this functionality as easy as possible to use for both programmers and template designers.
Smarty also converts the templates into PHP scripts, eliminating the need to parse the templates on every invocation. This makes Smarty extremely scalable and managable for large application needs.
Main features:
- Caching: Smarty provides fine-grained caching features for caching all or parts of a rendered web page, or leaving parts uncached. Programmers can register template functions as cacheable or non-cachable, group cached pages into logical units for easier management, etc.
- Configuration Files: Smarty can assign variables pulled from configuration files. Template designers can maintain values common to several templates in one location without intervention from the programmer, and config variables can easily be shared between the programming and presentation portions of the application.
- Security: Templates do not contain PHP code. Therefore, a template designer is not unleashed with the full power of PHP, but only the subset of functionality made available to them from the programmer (application code.)
- Easy to Use and Maintain: Web page designers are not dealing with PHP code syntax, but instead an easy-to-use templating syntax not much different than plain HTML. The templates are a very close representation of the final output, dramatically shortening the design cycle.
- Variable Modifiers: The content of assigned variables can easily be adjusted at display-time with modifiers, such as displaying in all upper-case, html-escaped, formatting dates, truncating text blocks, adding spaces between characters, etc. Again, this is accomplished with no intervention from the programmer.
- Template Functions: Many functions are available to the template designer to handle tasks such as generating HTML code segments (dropdowns, tables, pop-ups, etc.), displaying content from other templates in-line, looping over arrays of content, formatting text for e-mail output, cycling though colors, etc.
- Filters: The programmer has complete control of template output and compiled template content with pre-filters, post-filters and output-filters.
- Resources: Templates can be pulled from any number of sources by creating new resource handlers, then using them in the templates.
- Plugins: Almost every aspect of Smarty is controlled through the use of plugins. They are generally as easy as dropping them into the plugin directory and then mentioning them in the template or using them in the application code. Many user-community contributions are also available. (See the plugins section of the forum and wiki.)
- Add-ons: Many user-community contributed Add-ons are available such as Pagination, Form Validation, Drop Down Menus, Calander Date Pickers, etc. These tools help speed up the development cycle, there is no need to re-invent the wheel or debug code that is already stable and ready for deployment. (see the Add-ons section of the forum and wiki.)
- Debugging: Smarty comes with a built-in debugging console so the template designer can see all of the assigned variables and the programmer can investigate template rendering speeds.
- Compiling: Smarty compiles templates into PHP code behind the scenes, eliminating run-time parsing of templates.
- Performance: Smarty performs extremely well, despite its vast feature set. Most of Smartys capabilities lie in plugins that are loaded on-demand. Smarty comes with numerous presentation tools, minimizing your application code and resulting in quicker, less error-prone application development/deployment. Smarty templates get compiled to PHP files internally (once), eliminating costly template file scans and leveraging the speed of PHP op-code accelerators.

MAT Template Library is a C++ mathematical template class library. The library contains classes and routines for working with:

matrices
vectors
finding roots of polynomials
solving equations
and more...

Piffle::Template is a Perlish templating language.

SYNOPSIS

use Piffle::Template;
use Piffle::Template qw{template_to_perl expand_template};

# OO syntax, with output stored and returned:
print Piffle::Template->expand(source_file => foo/fish.xml,
include_path => [foo/inc,foo]);

# Immediate: OO syntax: output goes directly to STDOUT:
Piffle::Template->expand(source_file => foo/fish.xml,
output_file => *STDOUT);

# Procedural syntax, data from a string
$string =
< ?perl } ? >
< ?include std_disclaimer.txt? >
__END__
expand_template(source => $string,
output_file => *FILE);

This is a simple Perl-embedding syntax for template code which is geared towards allowing authors to validate their templates directly against schemas or DTDs. The embedded language is Perl itself, which allows great flexibility at the expense of having to be disciplined about the barrier between template code and module code.

In operation, the source template is transformed to an in-memory Perl script which is then run using Perls eval operator. Errors can be redirected to files or subroutines, and the output can be either caught in a variable or written to a file or open filehandle.

Template::Ast is a Perl module to process ASTs for Perl Template Toolkit.

SYNOPSIS

use Template::Ast;

# Rebuild AST stored in file:
$ast = Template::Ast->read(foo.ast) or
die Template::Ast->error();

# Writing existing AST to file:
$ast = { Marry => [24, F], John => [21, M] };
Template::Ast->write($ast, foo.ast) or
die Template::Ast->error();

$ast = Template::Ast->merge([1,2,3], undef); # [1,2,3]
$ast = Template::Ast->merge(undef, [1,2,3]); # [1,2,3]
$ast = Template::Ast->merge(undef, undef); # undef

$ast = Template::Ast->merge({A=>1,B=>2}, [C]); # [C]
$ast = Template::Ast->merge([1,2,3], [5,6]); # [5,6]
$ast = Template::Ast->merge([{A=>1},2], 5); # 5

$ast = Template::Ast->merge({A=>1,B=>2}, {C=>3}); # {A=>1,B=>2,C=>3}
$ast = Template::Ast->merge({A=>1,B=>2}, {B=>3}); # {A=>1,B=>3}

# {A=>1,B=>2}
$ast = Template::Ast->merge({A=>1,B=>undef}, {A=>undef,B=>2});

Template::Ast->merge(
{A=>1,B=>{C=>1,D=>2}},
{B=>{C=>1,D=>3,E=>4}}
); # {A=>1,B=>{C=>1,D=>3,E=>4}}

Template::Ast->merge(
{A=>1,B=>{C=>[1,2]}},
{B=>{C=>[3,4]}}
); # {A=>1,B=>{C=>[3,4]}}

print Template::Ast->dump([$vars], [vars]);

ASTs are essential in the programming model based on Perl Template Toolkit. This module provides some easy interface to do the dirty work involved in AST handling. The term AST used here are referred to any Perl referece pointed to a complex data structure, such as a nested hash, a nested array, or such.