Often Perl modules are written to wrap functionallity found in existing C
headers, libraries, or to use OS-specific features. It is useful in the
Build.PL or Makefile.PL file to check for the existance of these
requirements before attempting to actually build the module.

This module tries to make it easy to build Perl extensions that use
functions and typemaps provided by other perl extensions. This means that a
perl extension is treated like a shared library that provides also a C and
an XS interface besides the perl one.

This works as long as the base extension is loaded with the RTLD_GLOBAL
flag (usually done with a

sub dl_load_flags {0x01}

in the main .pm file) if you need to use functions defined in the module.

The basic scheme of operation is to collect information about a module in
the instance, and then store that data in the Perl library where it may be
retrieved later. The object can also reformat this information into the
data structures required by ExtUtils::MakeMaker's WriteMakefile function.

When creating a new Depends object, you give it a name, which is the name
of the module you are building. You can also specify the names of modules
on which this module depends. These dependencies will be loaded
automatically, and their typemaps, header files, etc merged with your new
object's stuff. When you store the data for your object, the list of
dependencies are stored with it, so that another module depending on your
needn't know on exactly which modules yours depends.

For example:

Gtk2 depends on Glib

Gnome2::Canvas depends on Gtk2

ExtUtils::Depends->new ('Gnome2::Canvas', 'Gtk2');
this command automatically brings in all the stuff needed
for Glib, since Gtk2 depends on it.

This module tries to figure out how to link C programs with Fortran
subroutines on your system. Basically one must add a list of Fortran
runtime libraries. The problem is their location and name varies with
each OS/compiler combination!

The pkg-config program retrieves information about installed libraries,
usually for the purposes of compiling against and linking to them.

ExtUtils::PkgConfig is a very simplistic interface to this utility,
intended for use in the Makefile.PL of perl extensions which bind libraries
that pkg-config knows. It is really just boilerplate code that you would've
written yourself.

File::Basename::Object is an object-oriented wrapper around
File::Basename. The goal is to allow pathnames to be presented and
manipulated easily.

This module exports a single function called parse_dir(), which can be used
to parse directory listings.

The first parameter to parse_dir() is the directory listing to parse. It
can be a scalar, a reference to an array of directory lines or a glob
representing a filehandle to read the directory listing from.

The second parameter is the time zone to use when parsing time stamps in
the listing. If this value is undefined, then the local time zone is
assumed.

The third parameter is the type of listing to assume. Currently supported
formats are 'unix', 'apache' and 'dosftp'. The default value 'unix'.
Ideally, the listing type should be determined automatically.

The fourth parameter specifies how unparseable lines should be treated.
Values can be 'ignore', 'warn' or a code reference. Warn means that the
perl warn() function will be called. If a code reference is passed, then
this routine will be called and the return value from it will be
incorporated in the listing. The default is 'ignore'.

Only the first parameter is mandatory.

The return value from parse_dir() is a list of directory entries. In a
scalar context the return value is a reference to the list. The directory
entries are represented by an array consisting of [ $filename, $filetype,
$filesize, $filetime, $filemode ]. The $filetype value is one of the
letters 'f', 'd', 'l' or '?'. The $filetime value is the seconds since Jan
1, 1970. The $filemode is a bitmask like the mode returned by stat().

The goal here is simply to provide recursive versions of mkdir() and
rmdir() with as little code and overhead as possible.
This module is in no way meant to derogate File::Path and is in no way an
endorsement to go out and replace all use of File::Path with
File::Path::Tiny.

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.