This module provides subs that allow you to read or write entire files with
one simple call. They are designed to be simple to use, have flexible ways
to pass in or get the file contents and to be very efficient. There is also
a sub to read in all the files in a directory other than '.' and '..'

These slurp/spew subs work for files, pipes and sockets, stdio,
pseudo-files, and the DATA handle. Read more about why slurping files is a
good thing in the file 'slurp_article.pod' in the extras/ directory.

If you are interested in how fast these calls work, check out the
slurp_bench.pl program in the extras/ directory. It compares many different
forms of slurping. You can select the I/O direction, context and file
sizes. Use the --help option to see how to run it.

This module wraps the File::Slurp manpage and adds character encoding
support through the *'encoding'* parameter. It exports the same functions
which take all the same parameters as File::Slurp. Please see the the
File::Slurp manpage documentation for basic usage; only the differences are
described from here on out.

File::Which was created to be able to get the paths to executable programs
on systems under which the `which' program wasn't implemented in the shell.

FileHandle::Unget operates exactly the same as FileHandle, except that it
provides a version of ungetc that allows you to unget more than one
character. It also provides ungets to unget a string.

This module is useful if the filehandle refers to a stream for which you
can't just 'seek()' backwards. Some operating systems support multi-byte
'ungetc()', but this is not guaranteed. Use this module if you want a
portable solution. In addition, on some operating systems, eof() will not
be reset if you ungetc after having read to the end of the file.

NOTE: Using 'sysread()' with 'ungetc()' and other buffering functions is
still a bad idea.

*GD.pm* is a Perl interface to Thomas Boutell's gd graphics library
(version 2.01 or higher; see below). GD allows you to create color drawings
using a large number of graphics primitives, and emit the drawings as PNG
files.

This is the GD::Graph3d extensions module. It provides 3D graphs for
the GD::Graph module by Martien Verbruggen, which in turn generates
graph using Lincoln Stein's GD.pm.

This is GDGraph, a package to generate charts, using Lincoln Stein's
GD.pm. See the documentation for some history and more information.

This package provides three modules that make it possible to work with
internal GD fonts as well as TrueType fonts, without having to worry
about different interface functions to call. Apart from an abstract
interface to all font types and strings for GD, this library also
provides some utility in aligning and wrapping your string.

This module will translate latitude longitude coordinates to Universal
Transverse Mercator(UTM) coordinates and vice versa.

Getopt::Long::Descriptive is yet another Getopt library. It's built atop
Getopt::Long, and gets a lot of its features, but tries to avoid making you
think about its huge array of options.

It also provides usage (help) messages, data validation, and a few other
useful features.

The gettext module permits access from perl to the gettext() family of
functions for retrieving message strings from databases constructed to
internationalize software.

gettext(), dgettext(), and dcgettext() attempt to retrieve a string
matching their 'msgid' parameter within the context of the current locale.
dcgettext() takes the message's category and the text domain as parameters
while dcgettext() defaults to the LC_MESSAGES category and gettext()
defaults to LC_MESSAGES and uses the current text domain. If the string is
not found in the database, then 'msgid' is returned.

textdomain() sets the current text domain and returns the previously active
domain.

_bindtextdomain(domain, dirname)_ instructs the retrieval functions to look
for the databases belonging to domain 'domain' in the directory 'dirname'

This module provides perl access to GLib and GLib's GObject libraries.
GLib is a portability and utility library; GObject provides a generic
type system with inheritance and a powerful signal system. Together
these libraries are used as the foundation for many of the libraries
that make up the Gnome environment, and are used in many unrelated
projects.

Graph::Directed allows you to create directed graphs.
For the available methods, see Graph.
http://search.cpan.org/~jhi/Graph-0.94/lib/Graph.pod

This module provides an interface to layout and image generation of
directed and undirected graphs in a variety of formats (PostScript, PNG,
etc.) using the "dot", "neato", "twopi", "circo" and "fdp" programs from
the GraphViz project (http://www.graphviz.org/ or
http://www.research.att.com/sw/tools/graphviz/).

Author:
-------
Leon Brocard

A Gravatar is a Globally Recognized Avatar for a given email address. This
allows you to have a global picture associated with your email address. You
can look up the Gravatar for any email address by constructing a URL to get
the image from the gravatar.com manpage. This module does that.

Examples of use include the author faces on the http://search.cpan.org
manpage.

See the http://gravatar.com manpage for more info.

Hash::MultiValue is an object (and a plain hash reference) that may contain
multiple values per key, inspired by MultiDict of WebOb.

The majority of the web pages of the internet today are much larger
than they need to be. The reason for this is that HTML tends to be
stored in a human readable format, with indenting, newlines and
comments.

However, all of these comments, whitespace etc. are ignored by the
browser, and needlessly lengthen download times.

Second, many people are using WYSIWYG HTML editors these days. This
makes creating content easy. However these editors can cause a number
of compatibility problems by tying themselves to a particular browser
or operating system.

This module automatically inserts data from a previous HTML form into
the HTML input and select tags. It is a subclass of HTML::Parser and
uses it to parse the HTML and insert the values into the form tags.

Objects of the 'HTML::Form' class represents a single HTML ' ...
' instance. A form consists of a sequence of inputs that usually
have names, and which can take on various values. The state of a form can
be tweaked and it can then be asked to provide 'HTTP::Request' objects that
can be passed to the request() method of 'LWP::UserAgent'.

Objects of the HTML::Parser class will recognize markup and separate it
from plain text (alias data content) in HTML documents. As different
kinds of markup and text are recognized, the corresponding event handlers
are invoked.

HTML::Parser is not a generic SGML parser. We have tried to make it able to
deal with the HTML that is actually "out there", and it normally parses as
closely as possible to the way the popular web browsers do it instead of
strictly following one of the many HTML specifications from W3C. Where
there is disagreement, there is often an option that you can enable to
get the official behaviour.

The document to be parsed may be supplied in arbitrary chunks. This makes
on-the-fly parsing as documents are received from the network possible.

If event driven parsing does not feel right for your application, you might
want to use HTML::PullParser. This is an HTML::Parser subclass that allows
a more conventional program structure.

This is the HTML::SimpleParse module. It is a bare-bones HTML parser,
similar to HTML::Parser, but with a couple important distinctions:

First, HTML::Parser knows which tags can contain other tags, which
start tags have corresponding end tags, which tags can exist only in
the portion of the document, and so forth. HTML::SimpleParse
does not know any of these things. It just finds tags and text in the
HTML you give it, it does not care about the specific content of these
tags (though it does distiguish between different _types_ of tags, such
as comments, starting tags like , ending tags like , and so on).

Second, HTML::SimpleParse does not create a hierarchical tree of HTML
content, but rather a simple linear list. It does not pay any
attention to balancing start tags with corresponding end tags, or which
pairs of tags are inside other pairs of tags.

Because of these characteristics, you can make a very effective HTML
filter by sub-classing HTML::SimpleParse.

This module contains several data tables useful in various kinds of HTML
parsing operations.

Note that all tag names used are lowercase.

In the following documentation, a "hashset" is a hash being used as a set
-- the hash conveys that its keys are there, and the actual values
associated with the keys are not significant. (But what values are there,
are always true.)

This allows you to separate design - the HTML - from the data, which
you generate in the Perl script.