Free element hiding helper software for linux

GNU Hosting Helper is a web hosting management package. It is distributed under the GNU GPL (General Public License) Agreement.
This package provides tools to manage many of the aspects of a hosting environment.
GNU Hosting Helper also provides a client utility to reduce the need for staff to perform tasks that a client needs such as managing email accounts.
Main features:
Administrative Features
The features provided through the administrative interface include (but not limited to):
- Server Tasks
- Security Management
- Server Monitor
- Ticket Center
- News Management
- Knowledge Base
- Fraudscreen
- Domain Management
- User Management
- Billing/Accounting
- Account Information Tools
- Miscellaneous Functions
- Package Management
- Manage Hosting Servers
- Manage Client Interfaces
- Manage Mail Servers
- Manage Name Servers
- Manage Signup Servers
- Manage Server Pools
- Manage Administrators
- Manage Admin Daemon
- System Config
Client Features
The features provided thru the client interface include (but not limited to):
- Account Quickview
- Account Resources
- System Information
- Email Functions
- Virtual FTP Management
- Sub Domain Management
- SSL Certificate Management
- Website Management
- Front Page Extensions Management
- Stats and Logs access
- Account Management
- Account Billing
System/Network Support
GNU Hosting Helper currently supports management for the following software:
- Apache 1.3x and 2x
- Sendmail and Postfix
- Most major FPTD software
- BIND 8x and BIND 9x
- MySQL 3x and 4.0.x
Enhancements:
- Fixes an error with MyDNS where straight domains wouldnt resolve.
- Fixes an error with some systems rnd file creation for creating SSL CSR.
- Fixes an error representing bandwidth allotment, usage, and remaining.
- Fixes an error in the init.d file for the admin server daemon.
- Fixes an error with encryption when editing Webmail, signup, mail, and hosting servers.
- Adds SSH port specification and SSH daemon management to all managed servers.

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.

SWF::Element is a set of classes of SWF tags and elements.

SYNOPSIS

use SWF::Element;
use SWF::BinStream;

$swf_stream=SWF::BinStream::Write;
....
$rect=SWF::Element::RECT->new;
$rect->configure(Xmin=>0, Ymin=>0, Xmax=>100, Ymax=>100);
$rect->pack($swf_stream);
....

SWF::Element module handles SWF tags and any other sub elements to create, configure, clone, pack to bit strings, and unpack from bit strings.

SWF::Element::*

SWF::Element class is a base class of SWF element, such as Tag, RECT, SHAPE, etc. Each SWF::Element object has one or more fields.

XML::Mini::Element::Header Perl module is used internally to represent < ? xml blah="hohoho" ? > type headers.

You shouldnt need to use it directly, see XML::Mini::Elements header() method.

dhcp-helper is a simple, straightforward DHCP relay agent which I wrote as alternative to the ISC relay.
Its Linux only, but doesnt require any kernel support other than
the network stack. (No LPF or packet sockets.)
If you use this software, please let me know; I would like some idea if it is generally useful to others.
Enhancements:
- This release add a workaround for a bug in some Linux kernels which have "Classical IP over ATM" enabled.

SMHelper provides Web-based tools to speed up the process of keeping paperwork for each show.
Stage Managers Helper is a set of PHP scripts to assist the Stage Managers of the world in keeping all the minutiae and paperwork which is associated with live entertainment under control. Rather than have to recreate the form for each show you use, or open a heavy application like a word processor, I find it much easier to just let the scripts generate the layout, and then fill in the blanks and click away. This should hopefully automate show management to some degree, and in so doing, ease the load on web Stage Managers servers.
Hopefully, by having the forms available via a web browser, the SM need only have a computer with access to the server and need not worry whether s/he remembered to pack their computer. In addition, since the data is stored on the server, the other members of a production team need only visit the website to see the days report, should they lose their paper copy or simply not desire more paper in their lives.
That said, I cant create this software alone. I need feedback. I want to know what you need or want from this software. If I can get it done in any sane way, Ill put it in the works. Currently planned:
Collation: Collect all data for one person/department into a single page,automatically,over a range of dates.
Currently included [and at least semi-working] in the package are pages for:
Generating Daily Reports
Viewing Daily Reports [Soon with print view]
Basic Show Info Setup
Props list generation and maintenance
Collation and summarization
French Scene Setup and Tables Generation
Enhancements:
- Added actual_sections.php. Script for setting up the breakdown of your show. *Fixed up french_scener.php to display entered data, at least rudimentarily. *Cosmetic fixes: Unified title blocks, interface consistency where possible

XML::DOM::Element is an XML element node in XML::DOM.

XML::DOM::Element extends XML::DOM::Node.

By far the vast majority of objects (apart from text) that authors encounter when traversing a document are Element nodes. Assume the following XML document:

< elementExample id="demo" >
< subelement1/ >
< subelement2 >< subsubelement/ >< /subelement2 >
< /elementExample >

When represented using DOM, the top node is an Element node for "elementExample", which contains two child Element nodes, one for "subelement1" and one for "subelement2". "subelement1" contains no child nodes.

Elements may have attributes associated with them; since the Element interface inherits from Node, the generic Node interface method getAttributes may be used to retrieve the set of all attributes for an element. There are methods on the Element interface to retrieve either an Attr object by name or an attribute value by name.

In XML, where an attribute value may contain entity references, an Attr object should be retrieved to examine the possibly fairly complex sub-tree representing the attribute value. On the other hand, in HTML, where all attributes have simple string values, methods to directly access an attribute value can safely be used as a convenience.