Free helper software for linux

Installation Instructions:

• pt-helper is written in Python, so you'll need a Python interpreter to get anything working. It also depends on several Python modules;
• If you do have all the dependencies, you should be able to run the program just by running the pt-helper script with a Python interpreter. From a shell, the following command should do the trick: $ python pt-helper.py
  
• Users of graphical file managers can probably double-click the pt-helper script to achieve the same effect.

Requirements:

• Python
• PyGame
• Festival Speech Synthesis System

Gtk2::Helper is a Perl module for convenience functions for the Gtk2 module.

SYNOPSIS

use Gtk2::Helper;

# Handle I/O watchers easily, like Gtk 1.x did
$tag = Gtk2::Helper->add_watch ( $fd, $cond, $callback, $data )
$rc = Gtk2::Helper->remove_watch ( $tag )

ABSTRACT

This module collects Gtk2 helper functions, which should make implementing some common tasks easier.

Gtk2::Helper->add_watch ( ... )

$tag = Gtk2::Helper->add_watch ( $fd, $cond, $callback, $data )

This method is a wrapper for Glib::IO->add_watch. The callback is called every time when its safe to read from or write to the watched filehandle.

$fd

Unix file descriptor to be watched. If you use the FileHandle module you get this value from the FileHandle->fileno() method.

$cond

May be either in or out, depending if you want to read from the filehandle (in) or write to it (out).

$callback

A subroutine reference or closure, which is called, if you can safely operate on the filehandle, without the risk of blocking your application, because the filehandle is not ready for reading resp. writing.

But aware: you should not use Perls builtin read and write functions here because these operate always with buffered I/O. Use low level sysread() and syswrite() instead. Otherwise Perl may read more data into its internal buffer as your callback actually consumes. But Glib wont call the callback on data which is already in Perls buffer, only when events on the the underlying Unix file descriptor occur.

The callback subroutine should return always true. Two signal watchers are connected internally (the I/O watcher, and a HUP watcher, which is called on eof() or other exceptions). Returning false from a watcher callback, removes the correspondent watcher automatically. Because we have two watchers internally, only one of them is removed, but probably not both. So always return true and use Gtk2::Helper->remove_watch to disable a watcher, which was installed with Gtk2::Helper->add_watch.

(Gtk2::Helper could circumvent this by wrapping your callback with a closure returning always true. But why adding another level of indirection if writing a simple "1;" at the end of your callback solves this problem? ;)

$data

This data is passed to the callback.

$tag

The method returns a tag which represents the created watcher. Later you need to pass this tag to Gtk2::Helper->remove_watch to remove the watcher.

squid-nufw-helper is the authentication Single Sign On module for Squid, working with a NuFW firewall. The project allows for transparent authentication of users on a Squid proxy, even if the proxy is a "transparent" one.
Enhancements:
- This release adds an "-a" switch to pass the clients source port to htons() at will (this is required by some versions of squid, but not all).
- This release is marked as stable, as it has been extensively tested.

Catalyst::Helper::Doc is a documentation page generator.

SYNOPSIS

# execute helper script.
script/myapp_create.pl Doc

# you can set description
# default is "Catalyst based application"

script/myapp_create.pl Doc "This is description!"

# you can set language type used as xml:lang. defualt is "en"
script/myapp_create.pl Doc "This is description!" ja

# you also can set charset, default is UTF-8
script/myapp_create.pl Doc "This is description!" ja EUC-JP

This module allows you to parse your libraries POD, and generate documentation like pages in search.cpan.org

Execute according to SYNOPSIS, and doc directory will be created, and documentation will be put into it.

Aargh is a code generator, written in C++ and licensed under the terms of the GNU General Public License (GPL). It generates C++ code to parse a command line, using the getopt() facility available in UNIX and UNIX-like environments.
Automated Argument Helper project supports command-line options with integer arguments, string arguments, and no arguments. The generated code is commented and carefully indented for readability.
Its nice to have lots of command line options, but its a real pain to code for them.
Not that its difficult. Its just tedious, time-consuming, error prone, and no fun. I used to wince at the thought of adding command line options.
Not any more. All I have to do is define the options I want in a small XML file, and run it through aargh. Instantly I have C++ source code that I can compile and link into my program.
If I need to add another option, or otherwise change the rules, I can edit the XML and regenerate the code. No muss, no fuss. Now I can spend more time on the interesting parts of the project.
To use aargh, write an XML file to describe the options you want. When aargh reads the file, it generates two C++ files.
One file is a header that declares a class to represent the options. By default this class is named "Opts," but you can specify a different name. The other file is the implementation of Opts, or whatever you decide to call it. The Opts class provides member functions to parse the command line and return the results.
In your own code, declare an instance of Opts and call Opts::get() to parse the command line, passing it the argc and argv arguments from main(). Opts::get() returns zero if the command line follows the rules that you have outlined in the XML file, or non-zero otherwise. If the parsing is successful, the Opts object stores the results and makes them available to your program by a series of accessor functions.
Main features:
- You can enforce upper and/or lower limits on the number of non-option arguments.
- You can distinguish between options that take arguments and those that dont.
- You can specify that an option is required.
- You can require that the argument to an option be a non-negative integer.
- For an integer argument you can enforce upper and/or lower limits.
- For a string argument you can enforce upper and/or lower limits on the string length.
- For a string argument you can call a function of your own to validate the argument.
- You can allow multiple occurrences of the same option. In that case the generated code builds an STL vector to hold the arguments. By default the generated software allows only one occurrence of any given option.
Enhancements:
- You can now specify the location of the generated header file independently of its name.
- This feature may make it easier to incorporate aargh into complex build environments.

Adblock Plus: Element Hiding Helper is an extension meant for creating element hiding rules easier.

Fight the text ads! Element Hiding Helper is a companion extension for Adblock Plus meant to make creating element hiding rules easier.

You simply select the element you want to be hidden and then choose which attributes of this element should be taken into account when hiding it in future.

The element hiding rule is generated and added automatically.

PyRoe project is a "static partial linker" for small helper Python libraries.

PyRoe links a Python script with its helper libraries into self-contained Python executable (PyRoe capsule).

Pyroe HOWTO

Assume that your main module is called frob.py and that it uses libraries libfoo.py and libbar.py (directly or indirectly). To pyroize your program, follow these steps (see Figure above for enlightenment):

Create the file Manifest.pyroe containing these three lines:

frob.py
libfoo.py
libbar.py

and put it in a directory together with your source files.

Run pyroe
After pyroe is done, you will find the file frob in the working directory.
The file frob is executable, the invocation
./frob ARGS...

is equivalent to

python frob.py ARGS...

but to run frob you no longer need libfoo.py or libbar.foo lying around.
Pyroe runtime library hidden inside of frob hijacks some command-line options starting with --pyroe-; in particular

frob --pyroe-unpack

will unpack the content of the capsule back to individual files.

For more information see

pyroe --help

The name of PyRoe capsule is always derived from the name of the first file in the Manifest.pyroe.