Free eq augments software for linux

User::grent is an interface to Perls built-in getgr*() functions.

SYNOPSIS

use User::grent;
$gr = getgrgid(0) or die "No group zero";
if ( $gr->name eq wheel && @{$gr->members} > 1 ) {
print "gid zero name wheel, with other members";
}

use User::grent qw(:FIELDS);
getgrgid(0) or die "No group zero";
if ( $gr_name eq wheel && @gr_members > 1 ) {
print "gid zero name wheel, with other members";
}

$gr = getgr($whoever);

This modules default exports override the core getgrent(), getgruid(), and getgrnam() functions, replacing them with versions that return "User::grent" objects. This object has methods that return the similarly named structure field name from the Cs passwd structure from grp.h; namely name, passwd, gid, and members (not mem). The first three return scalars, the last an array reference.

You may also import all the structure fields directly into your namespace as regular variables using the :FIELDS import tag. (Note that this still overrides your core functions.) Access these fields as variables named with a preceding gr_. Thus, $group_obj->gid() corresponds to $gr_gid if you import the fields. Array references are available as regular array variables, so @{ $group_obj->members() } would be simply @gr_members.

The getpw() function is a simple front-end that forwards a numeric argument to getpwuid() and the rest to getpwnam().

To access this functionality without the core overrides, pass the use an empty import list, and then access function functions with their full qualified names. On the other hand, the built-ins are still available via the CORE:: pseudo-package.

Term::ANSIMenu is an infrastructure for creating menus in ANSI capable terminals.

SYNOPSIS

use Term::ANSIMenu;
my $menu = Term::ANSIMenu->new(
width => 40,
help => [[, &standard_help],
[hint 1, &help_item],
[ undef, &standard_help],
[hint 3, undef]
],
title => title,
items => [[1, First menu item, &exec_item],
[2, This string is just too long
to fit in a normal terminal
and thus it will be clipped.],
[3, , sub { system "man man" }]
],
status => status,
prompt => prompt: );

$menu->print_menu();
while (my $key = $menu->read_key()) {
last unless defined $menu->do_key($key);
$menu->update_status() if $key eq S;
$menu->update_status(New status) if $key eq s;
$menu->update_prompt() if $key eq P;
$menu->update_prompt(New prompt: ) if $key eq p;
}
$menu->pos($menu->line_after_menu() + 1, 1);

I wrote this mainly to make live easy on those staff members to whom I delegate tasks. Most of them prefer to use a menu instead of having to type complicated commands. To them its a faster and safer way of working (we all know about typos dont we...).

By using this module you can create menus with only a few lines of code and still have a shipload of features. Need context-sensitive help or a statusbar? Like to use hotkeys? Want flashy colors and styles? Its all there. Just fill in the attributes and youre good to go.

Lingua::Phonology::Segment is a module to represent a segment as a bundle of feature values.

SYNOPSIS

use Lingua::Phonology;
$phono = new Lingua::Phonology;

# Define a feature set
$features = $phono->features;
$features->loadfile;

# Make a segment
$segment = $phono->segment;

# Set some values
$segment->labial(1);
$segment->continuant(0);
$segment->voice(1);
# Segment is now voiced labial stop, i.e. [b]

# Reset the segment
$segment->clear;

A Lingua::Phonology::Segment object provides a programmatic representation of a linguistic segment. Such a segment is associated with a Lingua::Phonology::Features object that lists the available features and the relationships between them. The segment itself is a list of the values for those features.

This module provides methods for returning and setting these feature values. A segment may also be associated with a Lingua::Phonology::Symbols object, which allows the segment to return the symbol that it best matches.

OVERLOADING

As of Lingua::Phonology v0.32 (Lingua::Phonology::Segment v0.4), string conversion of segments is overloaded. When you use a Lingua::Phonology::Segment in string context, the spell() method is automatically called, and the representation of the segment from the current symbolset is returned. String comparison operators (cmp eq ne lt le gt ge) are also overloaded. Therefore, the following work correctly, assuming that you have a Lingua::Phonology object correctly set up in $phono.

my ($b, $k) = $phono->symbols->segment(b, k);

print "Segments: $b, $kn"; # Prints "Segments: b, k";
print "$b is greater than $kn" if $b gt $k; # Wont print
print "$b is less than $kn" if $b lt $k; # Prints b is less than k;
print "$b is equal to $kn" if $b eq $k; # Wont print

my $b2 = $b->duplicate;
print "$b is equal to $b2n" if $b eq $b2 # Prints b is equal to b;
Note that stringification is not overloaded if the symbolset is not properly set. However, it turns on as soon as a symbolset is available:
my $b = Lingua::Phonology::Segment->new($features);
$b->voice(1);
$b->labial(1);

print "$bn"; # Prints Lingua::Phonology::Segment=HASH(0x88af598)
# or something similar, because there is no symbolset
# defined for spelling the segment.

$b->symbolset($symbols);
print "$bn"; # Prints b
Number conversion is not overloaded.

SVG::Metadata is a Perl module to capture metadata info about an SVG file.

SYNOPSIS

use SVG::Metadata;

my $svgmeta = new SVG::Metadata;

$svgmeta->parse($filename)
or die "Could not parse $filename: " . $svgmeta->errormsg();
$svgmeta2->parse($filename2)
or die "Could not parse $filename: " . $svgmeta->errormsg();

# Do the files have the same metadata (author, title, license)?
if (! $svgmeta->compare($svgmeta2) ) {
print "$filename is different than $filename2n";
}

if ($svgmeta->title() eq ) {
$svgmeta->title(Unknown);
}

if ($svgmeta->author() eq ) {
$svgmeta->author(Unknown);
}

if ($svgmeta->license() eq ) {
$svgmeta->license(Unknown);
}

if (! $svgmeta->keywords()) {
$svgmeta->addKeyword(unsorted);
} elsif ($svgmeta->hasKeyword(unsorted) && $svgmeta->keywords()>1) {
$svgmeta->removeKeyword(unsorted);
}

print $svgmeta->to_text();

This module provides a way of extracting, browsing and using RDF metadata embedded in an SVG file.

The SVG spec itself does not provide any particular mechanisms for handling metadata, but instead relies on embedded, namespaced RDF sections, as per XML philosophy. Unfortunately, many SVG tools dont support the concept of RDF metadata; indeed many dont support the idea of embedded XML "islands" at all. Some will even ignore and drop the rdf data entirely when encountered.
The motivation for this module is twofold. First, it provides a mechanism for accessing this metadata from the SVG files. Second, it provides a means of validating SVG files to detect if they have the metadata.

The motivation for this script is primarily for the Open Clip Art Library (http://www.openclipart.org), as a way of filtering out submissions that lack metadata from being included in the official distributions. A secondary motivation is to serve as a testing tool for SVG editors like Inkscape (http://www.inkscape.org).

eq2png is a simple Perl script to make it painless to produce Portable Network Graphic (PNG) images for OpenOffice Impress presentations (or for any other purpose I cant imagine).

Suppose you had a LaTeX snippet in a file named example-equation.tex: To produce the PNG image of this with black foreground and transparent background (the default), youd type:

eq2png example-equation.tex

INSTALLATION:

Youll need ImageMagick, dvips, and Perl.

Just copy the script somewhere into your path, and create a config file if you dont
like the default behavior.

EXAMPLE USAGE:

1) Produce an image of a equation at the command line:
eq2png int{a + b} = c -o intergral.png
If you dont specify an output file, it will default to eq.png
If you add the -b flag, it will make your equation bold (or try to). This is nice for presentations (where sometimes
thin lines dissapear).

2) Produce an image of .tex file snippet. The .tex file should only contain LaTeX code
code you want rendered (not preamble or other such stuff, which gets wrapped around your snippet).
For example, a file equation.tex might include one line, sum_{a}^b = x!.
You can then produce an image of this in the following way:
eq2png equation.tex #defaults to producing a png file with the same name, i.e., equation.png
or,
eq2png equation.tex -o outputfile.png #produce a png file with the name outputfile.png

NOTE: eq2png will only assume a filename is a .tex snippet if it ends in ".tex". So,
eq2png equation.eq
will produce a png image of the string equation.eq (probably not what you want).
To specify that the string is a filename, use the -f flag, e.g.,
eq2png -f equation.eq -o outputfile.png

NOTE: if you want to include LaTeX macros in your equations, just place a file named macros.tex (or symlink)
in your working directory. It will be included in the .tex code generated to produce your png file.

NOTE: if you need to include special LaTeX packages, see the config file stuff below.

Embperl::Syntax::RTF is a Perl class derived from Embperl::Syntax to define the syntax for RTF files. RTF files can be read and written by various word processing programms. This allows you to create dynamic wordprocessing documents or let process serial letters thru Embperl.

Currently Embperl regocnices the fields DOCVARIABLE, MERGEFIELD and NEXT. Variablenames are resolved as hash keys to $param[0] e.g. foo.bar referes to $param[0]{foo}{bar}, the @param Array can by set via the param parameter of the Execute function. NEXT moves to the next element of the @param array. If the end of the document is reached, Embperl repeats the document until all element of @param are processed. This can for example be use to tie a database table to @param and generate a serial letter.

SYNOPSIS

my $x = $Embperl::req -> component -> code ;
my ($op, $cmp, $a, $b) = XML::Embperl::DOM::Node::iChildsText (%$q%,%$x%,1) =~ /:([=])+s*"(.*?)"(?:s*"(.*?)"s*"(.*?)")?/ ;

if ($op eq =) { $op = eq }
elsif ($op eq ) { $op = gt }
elsif ($op eq >=) { $op = ge }
elsif ($op eq<<less