Free in html software for linux

HTML::Toc module can generate, insert and update HTML Table of Contents.

The HTML::Toc consists out of the following packages:

HTML::Toc
HTML::TocGenerator
HTML::TocInsertor
HTML::TocUpdator

HTML::Toc is the object which will eventually hold the Table of Contents. HTML::TocGenerator does the actual generation of the ToC. HTML::TocInsertor handles the insertion of the ToC in the source. HTML::TocUpdator takes care of updating previously inserted ToCs.

HTML::Parser is the base object of HTML::TocGenerator, HTML::TocInsertor and HTML::TocUpdator. Each of these objects uses its predecessor as its ancestor, as shown in the UML diagram underneath:

+---------------------+
| HTML::Parser |
+---------------------+
+---------------------+
| +parse() |
| +parse_file() |
+----------+----------+
/_
|
+----------+----------+ +-----------+
| HTML::TocGenerator + - - - - - -+ HTML::Toc |
+---------------------+ +-----------+
+---------------------+ +-----------+
| +extend() | | +clear() |
| +extendFromFile() | | +format() |
| +generate() | +-----+-----+
| +generateFromFile() | :
+----------+----------+ :
/_ :
| :
+----------+----------+ :
| HTML::TocInsertor + - - - - - - - - -+
+---------------------+ :
+---------------------+ :
| +insert() | :
| +insertIntoFile() | :
+----------+----------+ :
/_ :
| :
+----------+----------+ :
| HTML::TocUpdator + - - - - - - - - -+
+---------------------+
+---------------------+
| +insert() |
| +insertIntoFile() |
| +update() |
| +updateFile() |
+---------------------+

When generating a ToC youll have to decide which object you want to use:

TocGenerator:

for generating a ToC without inserting the ToC into the source

TocInsertor:

for generating a ToC and inserting the ToC into the source

TocUpdator:

for generating and inserting a ToC, removing any previously inserted ToC elements

Thus in tabular view, each object is capable of:

generating inserting updating
---------------------------------
TocGenerator X
TocInsertor X X
TocUpdator X X X

HTML::Latex is a Perl module that creates a Latex file from an HTML file.

SYNOPSIS

use HTML::Latex

my $parser = new HTML::Latex($conffile);
$parser->set_option(%options);
$parser->add_package(@packages);
$parser->ban_tag(@banned);
$parser->set_log($logfile);

# Option 1:
foreach my $uri (@ARGV) {
my ($htmlfile,$latexfile) = $parser->html2latex($uri);
}

# Option 2:
foreach my $uri (@ARGV) {
my $in = IO::File->new("< $uri");
my $out = IO::File->new("> $uri.tex");
$parser->html2latex($in,$out);
}

# Option 3:
my $html_string = join("n",);
my $tex_string = $parser->parse_string($html_string,1);

# Option 4:
my $html_string = join("",@ARGV);
my $tex_string = $parser->parse_string($html_string);
print $tex_string;

This class is used to create a text file in Latex format from a file in HTML format. Use the class as follows:

1. Create a new HTML::Latex object.
2. Override any options using set_option(), add_package(), ban_tag(), or set_log().
3. Run html2latex() on a file or URL.
4. Do whatever you want with the filename that was returned.

Pod::Html is a Perl module to convert pod files to HTML.

SYNOPSIS

use Pod::Html;
pod2html([options]);

Converts files from pod format (see perlpod) to HTML format. It can automatically generate indexes and cross-references, and it keeps a cache of things it knows how to cross-reference.

Learn HTML By Example is a sweet little JavaScript / HTML program that allows you to see the HTML you input into on side displayed as a web page on the other.
To install the program, just download it from Web Design Factory, and upload it to your web site.
Main features:
- Easy installation. Just upload to your web site and youre done!
- Immediate feedback on testing HTML and CSS code
- Several examples of commonly used HTML and CSS elements
- No page refreshing required
- Easy to expand by adding new examples

HTML::YaTmpl is yet another template processor.

SYNOPSIS

use HTML::YaTmpl;

my $t=HTML::YaTmpl->new( file=>template.tmpl );
$t->evaluate( key1=>$value1,
key2=>[$val21, $val22, ...]
... );
$t->evaluate_to_file( $outputfilename,
key1=>$value1,
key2=>[$val21, $val22, ...]
... );

ABSTRACT

HTML::YaTmpl aims mainly to provide a HTML template processor that saves the template writer typing.

There are general template processors like Text::Template and tools to embed perl in HTML like HTML::Embperl or HTML template processors like HTML::Template. Why have I decided to start yet another? Well, Text::Template is not really convenient when it comes to process repeating data records like HTML tables. With HTML::Embperl no professional "WEB Designer" will be able to "enhance" the pages. And HTML::Template enforces a strict division of design and programming. Thus, it enforces changes to the programming logic even if you only want to exchange a long number like 2835067264068365493 with a more human readable 2,835,067,264,068,365,493.

HTML::YaTmpl attempts to make simple things easy but complexity feasible.

HTML::Myasp can generate HTML pages based on Templates. JATP (Just Another Template Parser).

This library is another template module for the generation of HTML pages. Why ?. Well primarily i wanted a module: light, that keeps mod_perl power and flow control like HTML::Template, good interaction with external contents administrators, have the chance of using naturally the print statement for generating web content, but, for some situations have the chance of directly replace keywords in the template with values. In some way this module centralizes the feature of a hash with values for replacing that you find in HTML::Template and the XMLSubsMatch feature of Apache::ASP.

This module keeps the basic mod_perl flow, and permits the replacing with dynamic content using two forms of marking. Is very well suited for working in parallel with the designers team, living each group advance on its own.

HTML::Myasp export the send_page function by default, you can attach the dynamic content using:

A callback style for special tags delimiting zones.
Direct replacing of keywords by values.
In order to improve performance it uses a global pages CACHE hash, avoiding parsing files unless modified.

HTML::Mason is a powerful Perl-based web site development and delivery engine. With Mason you can embed Perl code in your HTML and construct pages from shared, reusable components.

Mason solves the common problems of site development: caching, debugging, templating, maintaining development and production sites, and more.

Mason is 100% free and open source. Although it can be used from CGI or even stand-alone, it is optimally designed for use with two other open source technologies: mod_perl and Apache.