Free 0.09 software for linux

Goo - stick things together with The Goo.

SYNOPSIS

shell> goo -p Object.pm # show a [P]rofile of Object.pm
shell> goo -l Object.pm # show Back [L]inks to Object.pm
shell> goo -r Object.pm # [R]un Object.pm
shell> goo -i Object.pm # comp[I]le Object.pm
shell> goo -p access.log # show a [P]rofile of access.log
shell> goo -c Object.pm # [C]lone Object.pm into another Thing
shell> goo -o # the Care[O]Meter shows Things you care about while coding (e.g., tasks, bugs)
shell> goo -z # show Things in your working [Z]one or mental buffer

"The Goo" helps you stick "Things" together in your working environment.
Things include Perl modules, Perl scripts, log files, javascripts, configuration files, database tables, templates etc.

The Goo records a "Trail" as you jump quickly from Thing to Thing in a simple, text-based console. It remembers how you associate Things in your environment.

Accelerate your work by quickly traversing the Trail of associations between Things.

METHODS

check_environment

Check and set up the environment.

do_action

Take a command line switch (e.g., -p) and map it to an action handler (e.g., [P]rofile) and perform the action on the Thing.

VCShell is a command line interface for VCS::Lite::Repository.

SYNOPSIS

B< add > element|repository [element|repository...]
B< remove > name [name...]
B< ci >|check_in name [name...]
B< co >|check_out parent_repository
B< commit >
B< update >
B< cd > repository
B< fetch > name@@gen [>outfile]
B< diff > file1[@@gen1] [file2[@@gen2]] [>outfile]

VCShell provides a command line interface to the VCS Lite Repository. This aims to be usable by non-Perl programmers, as it provides a wrapper to the functionality in the module.

COMMANDS

add

The add command adds something to a repository: an element or a repository. If the parameter given is a directory, it makes it a repository, otherwise an element. An empty file is created for the element if none exists.

remove

Remove breaks the association between a repository and something it contains. It does not delete any files.

ci

This command is used to check in changes to one or more elements and repositories. Each repository checked in is also recursively checked in.

clone

This makes a clone of one repository into another, and recursively for everything in it. The new repository contains a parent link which points at the original.

commit

If the repository is a clone of a parent repository, this propagates any changes to the parent. Note, a check in (ci) is needed on the parent, for this change to be applied.

update

This command is used to apply any changes that have happened to the parent. Three way merging occurs for any change that has happened in the mean time.

diff

This command outputs a udiff listing for two generations of an element, or for two different elements. The default generation used is the latest, and the default generation for the "from" file is the predecessor to the "to" generation if comparing the same element.

The output is in diff -u format.

wmifinfo is a simple applet showing basic network info for all available interfaces. It shows IP address, netmask, gateway and MAC address.

Left-button click moves to the next interface, right-button click calls ifup/ifdown scripts.

Please report bugs if you find any.

Left-button click moves to the next interface, right-button click calls ifup/ifdown scripts. These can be set with the -u and -d options. The %s variable is replaced with the interface name.

Example:

$ wmifinfo -i ppp0 -u "/sbin/ifup %s" -d "/sbin/ifdown %s"

(ifup/ifdown or the wmifinfo binaries should be suid root for this to work)

Led color Meaning
-------------------------------------------------------------------
red interface is down
yellow ifup/ifdown script is busy
dark green interface is up, no traffic
light green interface is up, and sending or receiving

GStreamer is a Perl interface to the GStreamer library.

SYNOPSIS

use GStreamer -init;

my $loop = Glib::MainLoop -> new();

# set up
my $play = GStreamer::ElementFactory -> make("playbin", "play");
$play -> set(uri => Glib::filename_to_uri $file, "localhost");
$play -> get_bus() -> add_watch(&my_bus_callback, $loop);
$play -> set_state("playing");

# run
$loop -> run();

# clean up
$play -> set_state("null");

sub my_bus_callback {
my ($bus, $message, $loop) = @_;

if ($message -> type & "error") {
warn $message -> error;
$loop -> quit();
}

elsif ($message -> type & "eos") {
$loop -> quit();
}

# remove message from the queue
return TRUE;
}

CGI::Utils is a Perl module for retrieving information through the Common Gateway Interface and mod_perl.
Enhancements:
- This release adds support for mod_perl 2 in addition to mod_perl 1.
- It fixes some formatting issues with the POD documentation and adds underscore versions of more methods.

Tk::ToolBar is a toolbar widget for Perl/Tk.

SYNOPSIS

use Tk;
use Tk::ToolBar;

my $mw = new MainWindow;
my $tb = $mw->ToolBar(qw/-movable 1 -side top
-indicatorcolor blue/);

$tb->ToolButton (-text => Button,
-tip => tool tip,
-command => sub { print "hin" });
$tb->ToolLabel (-text => A Label);
$tb->Label (-text => Another Label);
$tb->ToolLabEntry(-label => A LabEntry,
-labelPack => [-side => "left",
-anchor => "w"]);

my $tb2 = $mw->ToolBar;
$tb2->ToolButton(-image => navback22,
-tip => back,
-command => &back);
$tb2->ToolButton(-image => navforward22,
-tip => forward,
-command => &forward);
$tb2->separator;
$tb2->ToolButton(-image => navhome22,
-tip => home,
-command => &home);
$tb2->ToolButton(-image => actreload22,
-tip => reload,
-command => &reload);

MainLoop;

This module implements a dockable toolbar. It is in the same spirit as the "short-cut" toolbars found in most major applications, such as most web browsers and text editors (where you find the "back" or "save" and other shortcut buttons).

Buttons of any type (regular, menu, check, radio) can be created inside this widget. You can also create Label, Entry and LabEntry widgets. Moreover, the ToolBar itself can be made dockable, such that it can be dragged to any edge of your window. Dragging is done in "real-time" so that you can see the contents of your ToolBar as you are dragging it. Furthermore, if you are close to a stickable edge, a visual indicator will show up along that edge to guide you.

ToolBars can be made "floatable" such that if they are dragged beyond their associated window, they will detach and float on the desktop. Also, multiple ToolBars are embeddable inside each other.

If you drag a ToolBar to within 15 pixels of an edge, it will stick to that edge. If the ToolBar is further than 15 pixels away from an edge and still inside the window, but you release it over another ToolBar widget, then it will be embedded inside the second ToolBar. You can "un-embed" an embedded ToolBar simply by dragging it out. You can change the 15 pixel limit using the -close option.

Various icons are built into the Tk::ToolBar widget. Those icons can be used as images for ToolButtons (see "SYNOPSIS"). A demo program is bundled with the module that should be available under the User Contributed Demonstrations when you run the widget program. Run it to see a list of the available images.

Tk::ToolBar attempts to use Tk::CursorControl if its already installed on the system. You can further control this using the -cursorcontrol option. See "PREREQUISITES".
The ToolBar is supposed to be created as a child of a Toplevel (MainWindow is a Toplevel widget) or a Frame. You are free to experiment otherwise, but expect the unexpected.

Cache::Mmap Perl module helps you to share data cache using memory mapped files.

SYNOPSIS

use Cache::Mmap;

$cache=Cache::Mmap->new($filename,%options);

$val1=$cache->read($key1);
$cache->write($key2,$val2);
$cache->delete($key3);

This module implements a shared data cache, using memory mapped files. If routines are provided which interact with the underlying data, access to the cache is completely transparent, and the module handles all the details of refreshing cache contents, and updating underlying data, if necessary.
Cache entries are assigned to "buckets" within the cache file, depending on the key. Within each bucket, entries are stored approximately in order of last access, so that frequently accessed entries will move to the head of the bucket, thus decreasing access time. Concurrent accesses to the same bucket are prevented by file locking of the relevant section of the cache file.

CONFIGURATION METHODS

These methods are used to examine/update the configuration of a cache. Most of these methods are read-only, and the value returned may be different to that passed to the constructor, since the cache may have been created by an earlier process which specified different parameters.

buckets()

Returns the number of buckets in the cache file.

bucketsize()

Returns the size of buckets (in bytes) in the cache file.

cachenegative()

Returns true if items not found in the underlying data are cached anyway.

context()

Returns the context data for reads and writes to the underlying data.

context($context)

Provides new context data for reads and writes to the underlying data.

expiry()

Returns the time in seconds cache entries are considered valid for, or zero for indefinite validity.

pagesize()

Returns the page size (in bytes) of the cache file.

strings()

Returns true if the cache stores strings rather than references.

writethrough()

Returns true if items written to the cache are immediately written to the underlying data.

B::TerseSize is a Perl module that prints information about ops and their (estimated) size.

SYNOPSIS

perl -MO=TerseSize[,OPTIONS] foo.pl

The B::Size and B::TerseSize modules attempt to measure the size of Perl op codes. The output of B::TerseSize is similar to that of B::Terse, but includes the size of each OP in the tree and the PADLIST (subroutine lexical variables). The module can be run just as other compiler backends or used via Apache::Status (version 2.02 and higher).

If the Apache::Status StatusTerseSize option is enabled, there will be a main menu item added, "Memory Usage". Clicking on this link will cause B::TerseSize to produce a summary of package memory usage. This summary can take quite a while to produce, as each package subroutine syntax tree will be walked, adding up the information. This information will be cached, so running httpd in -X (non-forking mode) is a good choice.

When browsing the Apache::Status "Symbol Table Dump", a "Memory Usage" link will be at the bottom of each page. These summaries also include measurements of package global variables.

The Apache::Status symbol table browser will also provide an option to dump a subroutine tree along with the other subroutine options.