Free report designer tutorial software for linux

iReport project is a powerful, intuitive and easy to use visual report builder/designer for JasperReports written in 100% pure java.
This tool allows users to visually edit complex reports with charts, images, subreports,.... iReport is integrated with JFreeChart, one of the most diffused OpenSource chart library for java.
The data to print can be retrieved through several ways including multiple JDBC connections, TableModels, JavaBeans, XML, etc...
Enhancements:
- Full support for JasperReports 1.3.4.
- A new XML field mapping tool.
- A new document structure outline.
- Improved refactoring capabilities.
- An improved report query dialog.
- An improved UI with sortable tables.
- Several bugfixes.

Sub::Exporter::Tutorial is a friendly guide to exporting with Sub::Exporter.

Whats an Exporter?

When you use a module, first it is required, then its import method is called. The Perl documentation tells us that the following two lines are equivalent:

use Module LIST;

BEGIN { require Module; Module->import(LIST); }

The import method is the modules exporter.

The Basics of Sub::Exporter

Sub::Exporter builds a custom exporter which can then be installed into your module. It builds this method based on configuration passed to its setup_exporter method.

A very basic use case might look like this:

package Addition;
use Sub::Exporter;
Sub::Exporter::setup_exporter({ exports => [ qw(plus) ]});

sub plus { my ($x, $y) = @_; return $x + $y; }

This would mean that when someone used your Addition module, they could have its plus routine imported into their package:

use Addition qw(plus);

my $z = plus(2, 2); # this works, because now plus is in the main package

That syntax to set up the exporter, above, is a little verbose, so for the simple case of just naming some exports, you can write this:

use Sub::Exporter -setup => { exports => [ qw(plus) ] };
...which is the same as the original example -- except that now the exporter is built and installed at compile time. Well, that and you typed less.

Using Export Groups

You can specify whole groups of things that should be exportable together. These are called groups. Exporter calls these tags. To specify groups, you just pass a groups key in your exporter configuration:

package Food;
use Sub::Exporter -setup => {
exports => [ qw(apple banana beef fluff lox rabbit) ],
groups => {
fauna => [ qw(beef lox rabbit) ],
flora => [ qw(apple banana) ],
}
};

Now, to import all that delicious foreign meat, your consumer needs only to write:

use Food qw(:fauna);
use Food qw(-fauna);

Either one of the above is acceptable. A colon is more traditional, but barewords with a leading colon cant be enquoted by a fat arrow. Well see why that matters later on.

Groups can contain other groups. If you include a group name (with the leading dash or colon) in a group definition, it will be expanded recursively when the exporter is called. The exporter will not recurse into the same group twice while expanding groups.

There are two special groups: all and default. The all group is defined by default, and contains all exportable subs. You can redefine it, if you want to export only a subset when all exports are requested. The default group is the set of routines to export when nothing specific is requested. By default, there is no default group.

SRG is a Squid Report Generator designed for the needs of CRCnet. None of the existing report generators could provide the exact solution that we required and we decided to start from scratch rather than trying to modify an existing progamme.
SRG is designed to be fast and easy to integrate in to other authentication systems (such as those that are driving Squid itself).
Main features:
- PHP Output with built in authentication hooks
- Fast Processing
- Reporting right down the the location vistied
Enhancements:
- Fixed assertion failure when output directory contains a subdirectory with an invalid name.
- Fixed compilation problems on sparc64. Endianess problems.
- Fixed bug with localtime using a static buffer (or similar) which caused the Period to be misreported as firstdate - firstdate.
- Marked -A, -c, -D, -e, -L, -p, -P and -T as deprecated. See FAQ for details.
- Added option (-r) to allow sorting output reports by any column via javascript
- Added meta tags to prevent indexing of reports by robots
- Minor stylesheet updates
- SRG now defaults to generating location reports
- SRG now defaults to showing the requesting host in location reports
- -H is now used only to specify whether DNS lookups should be performed
- Fix some minor output formatting errors reported by Guiliano Cioffi
- Added some example scripts for generating SRG reports
- Added basic debian package

Crow is a modern GUI builder for the GTK+ toolkit.
Crow is full-featured yet lightweight: its tree-based [Property Explorer]? solves many GUI constructing tasks in a versatile manner without additional popup dialogs. The project is targeted to develop a tool that is coherent and productive for experienced GTK+ users as well as simple and accessible for newcomers.
Main features:
- [Property Explorer]? for managing trees of nested objects and arrays
- undo/redo for all operations
- uses GuiXml as a save format: a simple GUI description language
- utilizes GtkUIManager for generating menus and toolbars
- multi-platform: GNU/Linux, *BSD and Windows are supported
- IDE-embeddable: implemented as a widget in a dynamic library
- standalone designer application is included in the distribution
- GPL license

IPTables-tutorials aim is to explain iptables in a complete and simple way. The iptables-tutorial is currently rather stable, and contains information on all the currently available matches and targets (in kernel), as well as a couple of complete example scripts and explanations. It contains a complete section on iptables syntax, as well as other interesting commands such as iptables-save and iptables-restore.

The tutorial has recently been under heavy scrutiny and updating, as can be seen in this, the latest version of the tutorial. It is now also available in bookform from Lulu.com. If you feel like contributing or donating to the author of this tutorial, please do buy the book! Thank you!

If you need help, you are better off by asking the netfilter mailing list which you can reach at netfilter at lists.netfilter.org. For more information on this, visit the netfilter mailinglist page. You may also contact the linuxsecurity mailing list at security-discuss AT linuxsecurity dotcom. Both are fairly large, and should be able to help you much much better than I can.

Prima::tutorial is an introductory tutorial.

Programming graphic interfaces is often considered somewhat boring, and not without a cause. It is a small pride in knowing that your buttons and scrollbars work exactly as millions of others buttons and scrollbars do, so whichever GUI toolkit is chosen, it is usually regarded as a tool of small importance, and the less obtrusive, the better.

Given that, and trying to live up to the famous Perl making easy things easy and hard things possible mantra, this manual page is an introductory tutorial meant to show how to write easy things easy. The hard things are explained in the other Prima manual pages ( see Prima ).

The IceWM Control Panel (IceWMCP) IcePref2 Theme Designer tool allows you to easily create and modify themes for IceWM.
IceWM Control Panel (IceWMCP) is the first full-featured, Gtk-based control panel for IceWM. It is meant to run in IceWM, but can be used in ANY window manager as a general-purpose control panel.
IceWMCP is multi-lingual. Currently, the following languages are supported: English, Spanish, Russian, Traditional Chinese, French (partial), and Finnish (IceWMCP-IceMe only).
Developers: If you would like to use IceWMCP as the foundation for a new control panel (for a new window manager, etc.), see the developers release of IceWMCP. IceWMCP was inspired by the Qt-based application called IceCC, but includes many more tools, a more familiar Windoze Control Panel-like interface, and uses the MUCH faster Gtk user interface (Who runs a fast Window Manager like IceWM, to launch SLOW-running, memory-intensive Qt/KDE-based applications?? I sure dont).
Lets face it: IceWM and fast Gtk interfaces work well together. In addition, because IceWM Control Panel is written with a TRUE open source widget set, Gtk+, you dont have to worry about the licensing problems associated with proprietary QT-based applications. IceWM Control Panel is TRUE open source, through and through.
Version restrictions:
- Access to a Bash shell (very important)
- Python (2.2 or better), PyGtk-2 (1.9.9/2.0.0 or better)
- Gtk+ 2.0.6 or better - neither Gnome nor PyGnome is required
- (IceWMCP versions 2.5 and earlier require Gtk+1 and PyGtk-1 0.6.9)
- Your version of PyGtk should have the Gdk-Pixbuf modules on your system
- Please run ALL IceWMCP programs from a BASH shell: Using other shells such as ksh, pdksh, csh, tcsh, etc. is likely to cause problems.
- If your IceWMCP programs have trouble launching other applications, it is most likely because you are using something other than a Bash (/bin/bash) shell.
- Run the programs from Bash...period!

RiveScript::Tutorial is a beginners guide to creating their first RiveScript brain.

This tutorial outlines the various capabilities of the RiveScript specification and offers some recommended pointers for creating a well-formed RiveScript brain. What you do with this knowledge is up to you; be creative!

Be sure to skim over the RiveScript manpage first, because this tutorial jumps right in to using the various RiveScript commands without always explaining what each of them do.

A Simple RiveScript Interpreter

Here is a simple Perl script for running a RiveScript interpreter. This assumes that the brains RS files will be stored in a directory called "tutorial", local to the Perl script. Youd want to edit certain parameters in this code if you see fit.

#!/usr/bin/perl -w

use strict;
use warnings;
use RiveScript;

# Create the RiveScript interpreter.
my $rive = new RiveScript();

# Load the RS tutorial brain.
$rive->loadDirectory ("./tutorial");

# Sort them.
$rive->sortReplies;

# Go into a chatting loop.
while (1) {
print "User> ";
my $msg = ;
chomp $msg;

# Grab a reply.
my @reply = $rive->reply (user,$msg);
print " Bot> $_n" foreach(@reply);
}