Free toc software for linux

mkcdtoc is a small and flexible command line utility to create TOC files for cdrdao. mkcdtoc project reads a list of audio files and outputs a TOC file with a track specification for each audio file.
Input data can be a raw list with one file name on each line, or an m3u play list. The program has a modular architecture and can be extended via plugins.
The distribution includes a few plugins that can retrieve meta information from audio files to fill CD-TEXT blocks in the generated TOC file. There are plugins to perform audio file to WAVE format conversion.
To install mkcdtoc type:
# tar xjf mkcdtoc-VERSION.tar.bz2
# cd mkcdtoc-VERSION
# make install
This will install executable to /usr/local/bin, man page to /usr/local/man/man1 and plugins to /usr/local/share/mkcdtoc/plugins. You can change the installation prefix by editing include.mak.
vim:tw=70
Enhancements:
- New plugins info-ogginfo and info-translit-cyr.
- New options to disable arbitrary CD-TEXT flags.
- Minor improvements and bugfixes.

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::GenToc is a Perl module that generate a Table of Contents for HTML documents.

SYNOPSIS

use HTML::GenToc;

# create a new object
my $toc = new HTML::GenToc();

my $toc = new HTML::GenToc(title=>"Table of Contents",
toc=>$my_toc_file,
toc_entry=>{
H1=>1,
H2=>2
},
toc_end=>{
H1=>/H1,
H2=>/H2
}
);

# add further arguments
$toc->args(toc_tag=>"BODY",
toc_tag_replace=>0,
);

# generate anchors for a file
$toc->generate_anchors(infile=>$html_file,
overwrite=>0,
);

# generate a ToC from a file
$toc->generate_toc(infile=>$html_file,
footer=>$footer_file,
header=>$header_file
);

HTML::GenToc generates anchors and a table of contents for HTML documents. Depending on the arguments, it will insert the information it generates, or output to a string, a separate file or STDOUT.

While it defaults to taking H1 and H2 elements as the significant elements to put into the table of contents, any tag can be defined as a significant element. Also, it doesnt matter if the input HTML code is complete, pure HTML, one can input pseudo-html or page-fragments, which makes it suitable for using on templates and HTML meta-languages such as WML.

Also included in the distrubution is hypertoc, a script which uses the module so that one can process files on the command-line in a user-friendly manner.

Bigtop::Docs::TOC is a table of contents for Bigtop::Docs::* documentation modules.

What Should I Read?

This document is a brief annotated list of each Bigtop::Docs::* module.

Here are the highlights:

Lazy people should start with Bigtop::Docs::TentTut
Those allergic to web apps should start with Bigtop::Docs::Tutorial
Pedants should look in Bigtop::Docs::Syntax instead
Developers should carefully read Bigtop::Docs::Modules

Bigtop::Docs::About

Describes the features and motivations of Bigtop.

Bigtop::Docs::Cookbook

Modeled after the Perl Cookbook, this provides a list of things you might want to do, the syntax needed to make Bigtop do them for you, and the output produced by them. It focuses on hand written bigtop files, rather than on tentmaker.

Bigtop::Docs::Keywords

A (fairly) complete list of keywords Bigtop understands in a compact text file. See Bigtop::Docs::QuickRef for most of the same information in html tabular formatting or run tentmaker which shows complete information in your browser.

Bigtop::Docs::Modules

Documents many of the modules in the bigtop distribution including at least: Bigtop.pm, Bigtop::Parser. This includes a description of the grammar of the Bigtop language and how to work with it. (Note that the grammar is now in its own file called bigtop.grammar, but this has no effect on the docs in Bigtop::Docs::Modules. It may be out of date, but the extraction of the grammar is not the reason.)

Bigtop::Docs::QuickRef

This provides a somewhat complete list of all the keywords Bigtop understands along with some examples in html form. The depth of the tables involved makes it somewhat difficult to use. For a more compact version in plain text, see Bigtop::Docs::Keywords or run tentmaker for complete information in a different web format.

Bigtop::Docs::Syntax

This is meant to fully describe all of the syntax (including deprecations) in the Bigtop language. It is the encyclopedic version of Bigtop::Docs::Keywords.

Bigtop::Docs::TentTut

The tentmaker tutorial. Explains in detail how to use tentmaker to edit Bigtop files. Filled with beautiful screen shots.

Bigtop::Docs::TentRef

A comprehensive tour of tentmaker which assumes you understand the material from Bigtop::Docs::TentTut.

Bigtop::Docs::Tutorial

If you dont like tentmaker, this is where you should start. It walks through building a moderately complex application from scratch using a text editor to enter the proper Bigtop syntax.

Bigtop::Docs::Vim

Explains how to install vim syntax highlighting for Bigtop source files.

docbooktoc.xsl is a XSLT file for generating a XHTML table of contents from DocBook XML documents. It is used by the LayManSys project for the documentation.

Parameters

docbooktoc accepts the following parameters:

ext

The names of linked files are determined from the chapters id, which does not contain a filename suffix. This (string) parameter tells docbooktoc the suffix to use. Its default value is html.

style.sheet

This (string) parameter may contain stylesheets for styling the output document. You can pass more than one stylesheet by delimiting their filenames with a white-space (space, tab or newline).

style.type

This (string) parameter contains the MIME type used for content stylesheets. It defaults to text/css.

Program output

docbooktoc generates a XHTML document containing the books meta information (in DocBook XML, this is the subnode bookinfo and than lists all of the books chapters and section in an ordered list. The meta information are both used for generating the < head > as well as the documents header (in the XHTML < body >) and the output is the same like the DocBook XSLT driver for XHTML generates.

The books chapters and sections are presented as a n ordered, nested list, where the chapters are top level items, that contain lists of sections, where a section item again may contain a list of subsections.

You can use the Makefile distributed in this package and the LayManSys documentation for generating the example file toc.html. The make command for this is make test.

Bigtop is a web application data language processor.

SYNOPSIS

See Bigtop::Docs::TentTut or Bigtop::Docs::Tutorial for how to create a Bigtop file. Bigtop::Docs::TOC is a guide to all of the documentation modules.
The real synopsis:

vi your_app.bigtop (or use tentmaker see Bigtop::Docs::TentTut)
bigtop --create your_app.bigtop all

Modify your bigtop file and try again:

bigtop docs/your_app.bigtop all

Bigtop is a language for describing the data of a web application. Usually this data will be stored in a relational database. Once you have a description of your data, you can generate a web application from it. This includes all the pieces you need like: the sql statements ready for feeding to your database command line tool, the httpd.conf you need to Include in the httpd.conf on your system, the modules that will handle the web requests, the models that make the database tables look like classes, etc.

If you need to alter the data model in the future, you can change your original description to match the new reality, then regenerate the application without fear of losing hand written code (though you may have to modify some of it to reflect the new reality).

FUNCTIONS

This module is really a place holder, but it does provide some developer routines (which are not exported):

write_file
use Bigtop;
Bigtop::write_file( $file_name, $file_content, $no_overwrite )

This attempts to write $file_content to $file_name and dies on failures of open or close. Further, if you pass a true no_overwrite flag, it will check to see if the file exists and refuse to overwrite it. In that case, the user gets a warning that the file has been skipped because it already exists. If you dont want the user to see the warning, turn off the Bigtop warning. To avoid fatal errors on write failures, wrap in an eval. Putting these together, we come to my typcial usage:

eval {
no warnings qw( Bigtop );
Bigtop::write_file( $some_output_file, $content, no_overwrite );
}
warn $@ if $@;
make_module_path

(Note that make_module_path uses File::Spec, so even though Unix directory syntax is shown below, the function should work in other places.)

use Bigtop;
Bigtop::make_module_path( $build_dir, $module_name );

This attempts to make all the directories from $build_dir to the home of the module. It assumes that lib comes immediately after $build_dir.

For example, a call like:

Bigtop::make_module_path(
/home/username/App-Name, App::Name::Subname
);
Attempts to make these directories:
/home/username/App-Name/lib
/home/username/App-Name/lib/App
/home/username/App-Name/lib/App/Name
/home/username/App-Name/lib/App/Name/Subname

It doesnt report failures. Making directories can fail because the directories already exist (in which case you probably dont care) or because they could not be written (in which case youll notice soon enough, when you try to write to them).

Dox is a documentation browser.

Its an extensible browser for manpages and HTML documentation.

It allows you to access documentation via tables of contents, keyword indices, and full text searches.

Interfaces to pydoc and perldoc are provided. Doxygen-generated documentation can easily be integrated in the toc and index sections.

Dox comes with libc and STL documentation, and tables of contents for Perl and GNUstep.

You can easily make documentation generated by doxygen available both in the Contents and Index tabs.