Free ex software for linux

OSSP ex is a small ISO-C++ style exception handling library for use in the ISO-C language. It allows you to use the paradigm of throwing and catching exceptions in order to reduce the amount of error handling code without making your program less robust.

This is achieved by directly transferring exceptional return codes (and the program control flow) from the location where the exception is raised (throw point) to the location where it is handled (catch point) -- usually from a deeply nested sub-routine to a parent routine.

All intermediate routines no longer have to make sure that the exceptional return codes from sub-routines are correctly passed back to the parent.

The OSSP ex facility also provides advanced exception handling features like shielded and deferred exceptions. Additionally, OSSP ex allows you to choose the used underlying machine context switching facility and optionally support multi-threading environments by allowing you to store the exception catching stack in a thread-safe way.

Gtk2::Ex::DBI - Bind a Gtk2::GladeXML can generated window to a DBI data source.

SYNOPSIS

use DBI; use Gtk2 -init; use Gtk2::GladeXML; use Gtk2::Ex::DBI;
my $dbh = DBI->connect ( "dbi:mysql:dbname=sales;host=screamer;port=3306", "some_username", "salespass", { PrintError => 0, RaiseError => 0, AutoCommit => 1, } );
my $prospects_form = Gtk2::GladeXML->new("/path/to/glade/file/my_form.glade", Prospects);
my $data_handler = Gtk2::Ex::DBI->new( { dbh => $dbh, schema => "sales", sql => { select => "*", from => "Prospects", where => "Actve=? and Employees>?", where_values => [ 1, 200 ], order_by => "ClientName", }, form => $prospects, formname => "Prospects", on_current => &Prospects_current, calc_fields => { calc_total => eval { $self->{form}->get_widget("value_1")->get_text + $self->{form}->get_widget("value_2")->get_text } }, default_values => { ContractYears => 5, Fee => 2000 } } );
sub Prospects_current {
# I get called when moving from one record to another ( see on_current key, above )
}

CGI::Ex::Conf is a Perl module with Conf Reader/Writer for many different data format types.

SYNOPSIS

use CGI::Ex::Conf qw(conf_read conf_write);

my $hash = conf_read("/tmp/foo.yaml");

conf_write("/tmp/foo.yaml", {key1 => $val1, key2 => $val2});


### OOP interface

my $cob = CGI::Ex::Conf->new;

my $full_path_to_file = "/tmp/foo.val"; # supports ini, sto, val, pl, xml
my $hash = $cob->read($file);

local $cob->{default_ext} = conf; # default anyway


my @paths = qw(/tmp, /home/pauls);
local $cob->{paths} = @paths;
my $hash = $cob->read(My::NameSpace);
# will look in /tmp/My/NameSpace.conf and /home/pauls/My/NameSpace.conf


my $hash = $cob->read(My::NameSpace, {paths => [/tmp]});
# will look in /tmp/My/NameSpace.conf


local $cob->{directive} = MERGE;
my $hash = $cob->read(FooSpace);
# OR #
my $hash = $cob->read(FooSpace, {directive => MERGE});
# will return merged hashes from /tmp/FooSpace.conf and /home/pauls/FooSpace.conf
# immutable keys are preserved from originating files


local $cob->{directive} = FIRST;
my $hash = $cob->read(FooSpace);
# will return values from first found file in the path.


local $cob->{directive} = LAST; # default behavior
my $hash = $cob->read(FooSpace);
# will return values from last found file in the path.


### manipulate $hash
$cob->write(FooSpace); # will write it out the changes

There are half a million Conf readers out there. Why not add one more. Actually, this module provides a wrapper around the many file formats and the config modules that can handle them. It does not introduce any formats of its own.

This module also provides a preload ability which is useful in conjunction with mod_perl.

Gtk2::Ex::Carp is a GTK+ friendly die() and warn() functions.

SYNOPSIS

use Gtk2::Ex::Carp;

# these override the standard Perl functions:

warn(i told you not to push that button!);

die(an ignominious death);


# new functions for showing extended error information:

# like warn(), but shows a dialog with extra information
# in an expandable text entry:
worry($SHORT_MESSAGE, $EXTENDED_INFORMATION);

# like worry(), but fatal:
wail($SHORT_MESSAGE, $EXTENDED_INFORMATION);

This module exports four functions, of which two override the standard die() and warn() functions, and two which allow for extended error reporting. When called, these functions display a user-friendly message dialog window.

The die() function in this module actually replaces the core die() function, so any modules youve loaded may die will use former instead of the latter. die() will also print the error message to STDERR and will exit the program (with the appropriate exit code) when the dialog is dismissed.

The warn() function will also print a message to STDERR, but will allow the program to continue running when the dialog is dismissed.

EXTRA FUNCTIONS
The worry() and wail() functions behave just like warn() and die(), respectively, except that they allow you to provide additional information. A second argument, which can contain additional error information, is used to fill a text box inside an expander.

HANDLING GLIB EXCEPTIONS
This module also installs warn() as a Glib exception handler. Any unhandled exceptions will be presented to the user in a warning dialog.

PROGRAM FLOW
Note that all the functions in this module create dialogs and use the run() method, so that the standard Glib main loop is blocked until the user responds to the dialog.

ex::constant::vars is a Perl pragma to create readonly variables.

SYNOPSIS

Using the tie() interface:

use ex::constant::vars;
tie my $pi, ex::constant::vars, 4 * atan2( 1, 1 );
tie my @family, ex::constant::vars, qw( John Jane );
tie my %age, ex::constant::vars, John => 27,
Jane => Back off!;

Using the const() function:

use ex::constant::vars const;
const SCALAR my $pi, 4 * atan2( 1, 1 );
const ARRAY my @family, qw( John Jane );
const HASH my %age, John => 27, Jane => Back off!;

Using import() for compile time creation:

use ex::constant::vars (
$pi => 4 * atan2( 1, 1 ),
@family => [ qw( John Jane ) ],
%age => { John => 27, Jane => Back off! },
);

Gtk2::Ex::PodViewer is a Gtk2 widget for displaying Plain old Documentation (POD). NB: This module used to be called Gtk2::PodViewer. That module is now a stub that points to this module.

SYNOPSIS

use Gtk2 -init;
use Gtk2::Ex::PodViewer;

my $viewer = Gtk2::Ex::PodViewer->new;

$viewer->load(/path/to/file.pod); # load a file
$viewer->load(IO::Scalar); # load a module
$viewer->load(perlvar); # load a perldoc
$viewer->load(bless); # load a function

$viewer->show; # see, its a widget!

my $window = Gtk2::Window->new;
$window->add($viewer);

$window->show;

Gtk2->main;

Gtk2::Ex::PodViewer is a widget for rendering Perl POD documents. It is based on the Gtk2::TextView widget and uses Pod::Parser for manipulating POD data.

Gtk2::Ex::FormFactory is a Perl module that makes building complex GUIs easy.

SYNOPSIS

#-- Refer to http://www.exit1.org/ for
#-- a comprehensive online documentation.

#-- Read Gtk2::Ex::FormFactory::Intro

use Gtk2::Ex::FormFactory;

my $context = Gtk2::Ex::FormFactory::Context->new;

$context->add_object (
name => "worksheet",
object => My::Worksheet->new,
);

# derived from Gtk2::Ex::FormFactory::Layout
my $layouter = My::Layout->new;

# derived from Gtk2::Ex::FormFactory::Rules
my $rule_checker = My::Rules->new;

my $ff = Gtk2::Ex::FormFactory->new (
context => $context,
layouter => $layouter,
rule_checker => $rule_checker,
content => [
Gtk2::Ex::FormFactory::Window->new (
title => "Worksheet Editor",
content => [
Gtk2::Ex::FormFactory::Form->new (
title => "Main data",
content => [
Gtk2::Ex::FormFactory::Entry->new (
label => "Worksheet title",
attr => "worksheet.title",
tip => "Title of this worksheet",
),
#-- More widgets...
],
),
Gtk2::Ex::FormFactory->DialogButtons->new,
],
),
],
);

$ff->open;
$ff->update;

Gtk2->main;

ABSTRACT

With Gtk2::Ex::FormFactory you can build a GUI which consistently represents the data of your application.

This is a framework which tries to make building complex GUIs easy, by offering these two main features:

* Consistent looking GUI without the need to code resp. tune each widget by hand. Instead you declare the structure of your GUI, connect it to the data of your program (which should be a well defined set of objects) and control how this structure is transformed into a specific layout in a very generic way.

* Automatically keep widget and object states in sync (in both directions), even with complex data structures with a lot of internal dependencies, object nesting etc.

This manpage describes the facilities of Gtk2::Ex::FormFactory objects which are only a small part of the whole framework. To get a full introduction and overview of how this framework works refer to Gtk2::Ex::FormFactory::Intro.

SYNOPSIS

Gtk2::Ex::FormFactory::Table->new (
layout => "+-------%------+>>>>>>>>>>>>>>>+
| Name | |
+--------------~ Image |
| Keywords | |
+-------+------+[--------------+
^ More | Something |
^ | +-----+--------]+
_ Notes | | | Foo |
+-------+------+-----+---------+
^ Bar | Baz |
+--------------+---------------+",
content => [
Gtk2::Ex::FormFactory::Entry->new ( ... ),
Gtk2::Ex::FormFactory::Image->new ( ... ),
Gtk2::Ex::FormFactory::Entry->new ( ... ),
...
],
...
Gtk2::Ex::FormFactory::Container attributes
Gtk2::Ex::FormFactory::Widget attributes
);

This module implements a simple way of defining complex table layouts inside a Gtk2::Ex::FormFactory environment.