Free rev software for linux

JGuiGen is a Java GUI Generation System Elegant CRUD (Create/Review/Update/Delete). It supports any major database using JDBC. It generates fully internationalized and accessible screens that allow users to search tables, run reports, and calculate summary stats.
It generates multi-user safe screens with help buttons that work, generates test cases to test the generated GUIs, and generates HTML documentation about the GUIs generated.
Here is a partial list of classes that are included and used by JGuiGen:
- BoundedTextField.java - Creates a JTextField that will not accept more than x characters where you define the x value. BoundedPlainDocument.java - part of BoundedTextField
- CustomViewer.java - This is a pop-up viewer for JTables. It allows you to view the contents of long strings or text fields.
- DateDialog.java - pop-up calendar for choosing a date.
- DoublyLinkedList.java - create two lists, side by side. Move items from side to the other in order to select a group of options, features, tasks, people etc.
- Frequency Count routine - Create a table that shows a count of the values in a column in a result set.
- GeneralDialog.java - a generic three button, give text and ask a question screen.
- GeneralDialog4Btn.java - a generic four button, give text and ask a question screen.
- GetBrowserAndWP.java - code to ask a user for the path to their word processor and Browser. These values are stored in a table and used to call up these applications as needed.
- History.java - code to view an HTML file. The date and time a user views the file is stored and they are only offered the option to view the file when it is newer than the one they last viewed. Used by a developer to notify users of changes in the application they are using.
- JFreeReports example - generate a report using an existing JTable of data.
- JSearchableComboBox.java - A JComboBox with "Look-ahead". It fills in the most probable answer based upon what the user has entered so far. (This fills a much needed void in Java. By default in a pup-up list if your user types FL for Florida they will get Louisiana. It goes to Florida with the F and then Louisiana with the L. The look-ahead system will leave them on Florida.
- JxFrame.java - a class to inherit instead of JFrame. This gives a single point to make modifications that will affect each frame in an entire application. This one adds the automatic determination of Look and Feel code. It also informs the system to make button more active.
- JxButton.java -a class to inherit instead of JButton. This gives a single point to make modifications that will affect each frame in an entire application.
- JxLabel.java - a class to inherit instead of JLabel. This gives a single point to make modifications that will affect each frame in an entire application.
- JxTextArea.java - a class to inherit instead of JTextArea. This gives a single point to make modifications that will affect each frame in an entire application. This one makes the tab key exit a JTextArea that is being edited. The default requires a user to press CTRL-Tab. ListDialog.java - a generic screen to show a list that the user chooses an option from. It has an optional "Add a new value" feature.
- LowVisionMetalLookAndFeel.java - code to change the look and feel to very large text and very high contrast.
- MutableInteger.java - code to pass an integer value into a class and allow changes made in the class to be known by the calling class.
- NumericPlainDocument.java - Part of the Numeric TextField class.
- NumericTextField.java - creates a JTextField that accepts a number with a specified number of decimal places.
- ProgressMonitorDemo.java - and ProgressMonitorInc.java and ProgressMonitorWork.java. I found it very difficult to get the ProgressMonitor (a small pop-up that fills as your long running task runs) to work. I finally figured out something that works reliably and these three classes show how to do it.
- PrintScreen code - this code is included inside the various classes that JGuiGen generates.
- RegexFormatter.java - code to help apply a Regex value to a JFormattedText field
- RowLayout1.java - a layout manager that includes one column of labels and then a variable number of columns. This can be used for most business applications.
- RowLayoutConstraint.java - part of the rowlayout manager.
- SetIcon.java - code to replace the coffee cup icon on each frame.
- SQLWhereClause.java - a class to pop-up a simple SQL Where clause generator. It includes the ability to name, save and rerun queries. It also saves and runs reports using JFreeReports.
- StreamEditorPane.java - Part of the TextEditor class.
- SwitchLF.java - code to switch look and feels in a running application.
- TableMap.java - part of the TableSorter class.
- TableSorter.java - code to make a JTable that sorts on each column when the column header is clicked.
- TernarySearchTree.java - part of the JSearchableComboBox class.
- TextViewer.java - Code to view a Text field.
- TextEditor.java - Code to edit a text field. This includes a way to make Tab exit a JTextArea (which is not the default for Java.)
- TableHeaderJLabel.java - Code to display special headers over a column in a JTable.
- WholeNumberField.java - code to create a JTextField that will only accept integer values.
- Switch Look and Feel menu
- Change Locale menu
- Change Font menu

Trend is a general-purpose, efficient trend graph for "live" data. Data is read in ASCII form from a file or continuously from a FIFO and displayed in real-time into a multi-pass trend (much like a CRT oscilloscope). trend can be used as a rapid analysis tool for progressive or time-based data series together with trivial scripting.
Main features:
- OpenGL graphics
- Automatic or fixed graph scaling
- Two graph scrolling and shading modes
- Configurable colours/grid
- Flexible input
- Interactivity

Snort::Rule is a Perl extension for dynamically building snort rules.

SYNOPSIS

use Snort::Rule;
$rule = Snort::Rule->new(
-action => alert,
-proto => tcp,
-src => any,
-sport => any,
-dir => ->,
-dst => 192.188.1.1,
-dport => 44444,
);

$rule->opts(msg,Test Rule");
$rule->opts(threshold,type limit,track by_src,count 1,seconds 3600);
$rule->opts(sid,500000);

print $rule->string()."n";

OR

$rule = alert tcp $SMTP_SERVERS any -> $EXTERNAL_NET 25 (msg:"BLEEDING-EDGE POLICY SMTP US Top Secret PROPIN"; flow:to_server,established; content:"Subject|3A|"; pcre:"/(TOPsSECRET|TS)//[sw,/-]*PROPIN[sw,/-]*(?=//(25)?X[1-9])/ism"; classtype:policy-violation; sid:2002448; rev:1;);

$rule = Snort::Rule->new(-parse => $rule);
print $rule->string()."n";

This is a very simple snort rule object. It was developed to allow for scripted dynamic rule creation. Ideally you could dynamically take a list of bad hosts and build an array of snort rule objects from that list. Then write that list using the string() method to a snort rules file.

Bio::PrimarySeqI is a Perl Interface definition for a Bio::PrimarySeq.

SYNOPSIS

# Bio::PrimarySeqI is the interface class for sequences.

# If you are a newcomer to bioperl, you should
# start with Bio::Seq documentation. This
# documentation is mainly for developers using
# Bioperl.

# to test this is a seq object

$obj->isa("Bio::PrimarySeqI") ||
$obj->throw("$obj does not implement the Bio::PrimarySeqI interface");

# accessors

$string = $obj->seq();
$substring = $obj->subseq(12,50);
$display = $obj->display_id(); # for human display
$id = $obj->primary_id(); # unique id for this object,
# implementation defined
$unique_key= $obj->accession_number();
# unique biological id

# object manipulation

eval {
$rev = $obj->revcom();
};
if( $@ ) {
$obj->throw(-class => Bio::Root::Exception,
-text => "Could not reverse complement. ".
"Probably not DNA. Actual exceptionn$@n",
-value => $@);
}

$trunc = $obj->trunc(12,50);

# $rev and $trunc are Bio::PrimarySeqI compliant objects

This object defines an abstract interface to basic sequence information - for most users of the package the documentation (and methods) in this class are not useful - this is a developers only class which defines what methods have to be implmented by other Perl objects to comply to the Bio::PrimarySeqI interface. Go "perldoc Bio::Seq" or "man Bio::Seq" for more information on the main class for sequences.

PrimarySeq is an object just for the sequence and its name(s), nothing more. Seq is the larger object complete with features. There is a pure perl implementation of this in Bio::PrimarySeq. If you just want to use Bio::PrimarySeq objects, then please read that module first. This module defines the interface, and is of more interest to people who want to wrap their own Perl Objects/RDBs/FileSystems etc in way that they "are" bioperl sequence objects, even though it is not using Perl to store the sequence etc.

This interface defines what bioperl consideres necessary to "be" a sequence, without providing an implementation of this. (An implementation is provided in Bio::PrimarySeq). If you want to provide a Bio::PrimarySeq compliant object which in fact wraps another object/database/out-of-perl experience, then this is the correct thing to wrap, generally by providing a wrapper class which would inheriet from your object and this Bio::PrimarySeqI interface. The wrapper class then would have methods lists in the "Implementation Specific Functions" which would provide these methods for your object.

Module::Versions is a Perl module to handle versions of loaded modules with flexible result interface.

SYNOPSIS

use Module::Versions;

# Simple Interface
list Module::Versions; # prints formatted results to STDOUT
Module::Versions->list; # prints formatted results to STDOUT

# Shortcuts
$vers = get Module::Versions; # retrieves loaded modules

$vers = Module::Versions->get; # retrieves loaded modules

$array = Module::Versions->ARRAY; # returns array with version infos
$hash = Module::Versions->HASH; # returns hash with version infos

$list = Module::Versions->SCALAR; # returns text list with version infos
$csv = Module::Versions->CSV; # returns csv list with version infos
$xml = Module::Versions->XML; # returns xml struct with version infos
$xsd = Module::Versions->XSD; # returns xml schema of version infos
$dtd = Module::Versions->DTD; # returns DTD of version infos

# Individual Parameters
$vers = Module::Versions # retrieves mods and vars as defined
->new($mods,$vars)
->get($criteria);

$vers->list($fd,$mask); # prints formatted results to file
$vers->list($fd,$preform); # prints preformatted results to file
$vers->list($fd,&cb); # prints serialied results as handled
# in callback routine
$vers->data(&cb); # returns transformed results as
# defined in callback routine
# Individual formatted output
list Module::Versions(*LOG, %5d %1s %-20s %10s %-16s);
# prints individually formatted
# results to LOG
list Module::Versions(*DBIMPORT, %s|%s|%s);
# prints individually formatted
# results to Database Import file

list Module::Versions(*FD, SCALAR);# prints text list results to file
list Module::Versions(*FD, CSV); # prints csv list results to file
list Module::Versions(*FD, XML); # prints xml struct results to file
list Module::Versions(*FD, XSD); # prints xml schema to file
list Module::Versions(*FD, DTD); # prints DTD to file

list Module::Versions(*FD, ARRAY); # prints serialized results to file
list Module::Versions(*FD, HASH); # prints serialized results to file

Module::Versions->list(*LOG); # prints formatted results to LOG

# Pretty Compact
Module::Versions->list # prints formatted results on STDOUT
->list(*XML,XML); # prints xml struct results to XML file

Module::Versions->list # prints formatted results on STDOUT
->list(*XSD,XSD) # prints xml schema to XSD file
->list(*XML,XML); # prints xml struct results to XML file

Module::Versions->list # prints formatted results on STDOUT
->list(*DTD,DTD) # prints DTD to DTD file
->list(*XML,XML); # prints xml struct results to XML file

Module::Versions handles versions of loaded modules with a flexible result interface. The main goal is to get as much version informations as possible about a module or module list with a simple call interface and an absolutely flexible result interface. Module::Versions handles *loaded* and *loadable* modules.

The motivation for writing this module was the need for better support facilities to get informations about the used modules and versions in the productivity environment. Module::Versions allows shipping applications basically with something like a -version option (See Getopt::Long) but with expanded functions.

Module::Versions tries to read the loaded/loadable modules $VERSION. For extended purposes any private project version variables can be fetched ($_VERSION, $version, $REV, etc.).

Module::Versions has a flexible result interface to satisfy different needs: results can be lists and data structures with different formats - pre-formed ARRAY, HASH, SCALAR, CSV, XML/XSD/DTD and a full flexible user callback interface.
It is for example very simple to print a good formatted version list to the console and save a version.xml file (in conjunction with an xsd-schema) at the same time with an absolutely minimum of coding (SYNOPSIS, Pretty Compact) .
Module::Versions tries to load version.pm to support Perl 5.10.0s $VERSION formatting.