event meister 1.1.0.4

Event Meister is a Windows Event Log reader with system wide monitoring and event notification facilities. A single installation can harvest Event Log data throughout your network without the need for multiple licences. EventMeister gathers information from the Windows Event Logs on your computer or any networked computer.

Data from all logs is presented to you in a consistent, easy to read format. Use powerful filters to retrieve only the information in which youre interested and merge data from multiple logs for easier timeline analysis. You can filter, sort and reorganize columns to assist with detailed analysis and data presentation, and create multiple views of the same data.

At any time you can export a log, aggregate log or cross-section of a log in various formats including text, csv, xml, formatted html and RSS. This makes it easy to import filtered data into databases or analysis applications such as Excel. You can even publish your event logs or as RSS feeds.

EventMeister resides in your system tray and will monitor your logs 24/7, watching out for certain entry patterns. When it identifies an item of interest, it will respond by issuing visual and audio alerts, sending emails, writing to a log and even running your own scripts.

Whats new in this version:
Fix to ensure that icons are retained when installation is moved to different PC or a different account on the same PC: Adaptive timeout in Event Log Wizard when determining available logs; Added minimize to / restore from tray animation

Limitations:
30 day trial

Promo Meister description
Promo Meister lets you to print your own professional quality bookmarks, calendars and postcards to promote yourself Promo Meister lets you to print your own professional quality bookmarks, calendars and postcards to promote yourself, your business or a special event.

Includes: Starter kit of blank bookmarks, calendars, and post card stock. Printed samples of bookmarks, calendars, and post cards. Laminated samples of bookmarks and calendars. Sample laminating pouches. Color swatch booklet showing stock colors and textures.

Here are some key features

of "Promo Meister":

· Backup and restore data to CD s and floppy drives.
· Built-in User Manual and Help index search function.
· Use your own graphics, clip art and logos.
· Downloadable, on-line updates.
· Windows 98, 2000, ME, NT, and XP.
· No use restrictions. No meters.
· Sample templates for all formats.
· Save layouts for future use.
· Print background images and watermarks.
· Can be used on multiple PC s.
· Used by thousands. Since 1987.
· Bookmark Features
· Print vertically and horizontally on same bookmark at same time.
· Print calendars directly onto bookmark layouts.
· Use your own graphics, clip art and logos.
· Downloadable, on-line updates.
· Windows 98, 2000, ME, NT, and XP.
· Calendar Features
· Print both wallet size (9 to a sheet) and ID size (8 to a sheet) calendars.
· Highlight up to 15 different days per year on each calendar.
· Begin with any month and year perpetually.
· Postcard Features
· Maintain and manage database of names and addresses for selective post card printing using built-in PromoMeister database function.
· Selectively sort and address post cards by name, ZIP or type (for example, "PRSNL", "MEMBR", "BUSNS", etc.).
· Automatically addresses four post cards at a time (4 to a sheet).


Limitations:

· Word sample on printed materials

Event is an Event loop processing.

SYNOPSIS

use Event qw(loop unloop);

# initialize application
Event->flavor(attribute => value, ...);

my $ret = loop();

# and some callback will call
unloop(ok);

The Event module provide a central facility to watch for various types of events and invoke a callback when these events occur. The idea is to delay the handling of events so that they may be dispatched in priority order when it is safe for callbacks to execute.

Events (in the ordinary sense of the word) are detected by watchers, which reify them as events (in the special Event module sense). For clarity, the former type of events may be called "source events", and the latter "target events". Source events, such as signals arriving, happen whether or not they are being watched. If a source event occurs which a watcher is actively watching then the watcher generates a corresponding target event. Target events are only created by watchers. If several watchers are interested in the same source event then each will generate their own target event. Hence, any particular source event may result in zero, one, two, or any number of target events: the same as the number of watchers which were actively watching for it.

Target events are queued to be processed in priority order (priority being determined by the creating watcher) and in FIFO order among events of the same priority. Queued ("pending") events can, in some cases, be cancelled before being processed. A queued event is processed by being passed to the callback function (or method on a particular object or class) which was specified to the watcher.

A watcher, once created, operates autonomously without the Event user having to retain any reference to it. However, keeping a reference makes it possible to modify most of the watchers characteristics. A watcher can be switched between active and inactive states. When inactive, it does not generate target events.

Some types of source event are not reified as target events immediately. Signals received, for example, are counted initially. The counted signals are reified at certain execution points. Hence, signal events may be processed out of order, and if handled carelessly, on the wrong side of a state change in event handling. A useful way to view this is that occurrence of the source event is not actually the arrival of the signal but is triggered by the counting of the signal.
Reification can be forced when necessary. The schedule on which some other events are created is non-obvious. This is especially the case with watchers that watch for a condition rather than an event. In some cases, target events are generated on a schedule that depends on the operation of the event loop.

Event::RPC is a event based transparent Client/Server RPC framework.

SYNOPSIS

#-- Server Code
use Event::RPC::Server;
use My::TestModule;
my $server = Event::RPC::Server->new (
port => 5555,
classes => { "My::TestModule" => { ... } },
);
$server->start;

----------------------------------------------------------

#-- Client Code
use Event::RPC::Client;
my $client = Event::RPC::Client->new (
server => "localhost",
port => 5555,
);
$client->connect;

#-- Call methods of My::TestModule on the server
my $obj = My::TestModule->new ( foo => "bar" );
my $foo = $obj->get_foo;

ABSTRACT

Event::RPC supports you in developing Event based networking client/server applications with transparent object/method access from the client to the server. Network communication is optionally encrypted using IO::Socket::SSL. Several event loop managers are supported due to an extensible API. Currently Event and Glib are implemented.

Tk::event contains miscellaneous event facilities: define virtual events and generate events.

SYNOPSIS

$widget->eventAction(?arg, arg, ...?);

The eventAction methods provides several facilities for dealing with window system events, such as defining virtual events and synthesizing events. Virtual events are shared by all widgets of the same MainWindow. Different MainWindows can have different virtual event.

The following methods are currently supported:

$widget->eventAdd(, sequence ?,sequence, ...?)

Associates the virtual event virtual with the physical event sequence(s) given by the sequence arguments, so that the virtual event will trigger whenever any one of the sequences occurs. Virtual may be any string value and sequence may have any of the values allowed for the sequence argument to the bind method. If virtual is already defined, the new physical event sequences add to the existing sequences for the event.

$widget->eventDelete( ?,sequence, sequence, ...?)

Deletes each of the sequences from those associated with the virtual event given by virtual. Virtual may be any string value and sequence may have any of the values allowed for the sequence argument to the bind method. Any sequences not currently associated with virtual are ignored. If no sequence argument is provided, all physical event sequences are removed for virtual, so that the virtual event will not trigger anymore.

$widget->eventGenerate(event ?,option => value, option => value, ...?)

Generates a window event and arranges for it to be processed just as if it had come from the window system. $window is a reference to the window for which the event will be generated. Event provides a basic description of the event, such as < Shift-Button-2 > or >. If Window is empty the whole screen is meant, and coordinates are relative to the screen. Event may have any of the forms allowed for the sequence argument of the bind method except that it must consist of a single event pattern, not a sequence. Option-value pairs may be used to specify additional attributes of the event, such as the x and y mouse position; see "EVENT FIELDS" below. If the -when option is not specified, the event is processed immediately: all of the handlers for the event will complete before the eventGenerate method returns. If the -when option is specified then it determines when the event is processed.

$widget->eventInfo(?>?)

Returns information about virtual events. If the argument is omitted, the return value is a list of all the virtual events that are currently defined. If is specified then the return value is a list whose elements are the physical event sequences currently defined for the given virtual event; if the virtual event is not defined then undef is returned.

izi-Event is FileMaker Pro solution that allows you to organize and setup arrangements for a seminar, conference, festivity, or other event.

It has personalized mailing lists, attendance lists, badged invoices, and more.

Event::ExecFlow is a high level API for event-based execution flow control.

ABSTRACT

Event::ExecFlow provides a ligh level API for defining complex flow controls with asynchronous execution of external programs.

SYNOPSIS

use Event::ExecFlow;

my $job = Event::ExecFlow::Job::Group->new (
jobs => [
Event::ExecFlow::Job::Command->new (
name => "transcode",
title => "Transcoding DVD title to OGG",
command => "transcode -i /dev/dvd ...",
fetch_output => 1,
progress_max => 4711, # number of frames
progress_parser => sub {
my ($job, $buffer) = @_;
$job->set_progress_cnt($1) if $buffer =~ /[d+-(d+)]/;
#-- or simply write this:
#-- progress_parser => qr/[d+-(d+)]/,
},
),
Event::ExecFlow::Job::Code->new (
name => "checks",
title => "Do some checks",
depends_on => [ "transcode" ],
code => sub {
my ($job) = @_;
my $transcode = $job->get_group->get_job_by_name("transcode");
if ( $transcode->get_output !~ /.../ ) {
$job->set_error_message("XY check failed");
}
#-- this could be done easier as a post_callback added to
#-- the "transcode" job above, but its nevertheless a good
#-- example for the Code job type and shows how jobs can
#-- interfere with each other.
},
),
Event::ExecFlow::Job::Command->new (
title => "Muxing OGG file",
depends_on => [ "checks" ],
command => "ogmmerge ...",
no_progress => 1,
),
],
);

#-- this inherits from Event::ExecFlow::Frontend
my $frontend = Video::DVDRip::GUI::ExecFlow->new(...);
$frontend->start_job($job);

Event::ExecFlow offers a high level API to declare jobs, which mainly execute external commands, parse their output to get progress or other status information, triggers actions when the command has been finished etc. Such jobs can be chained together in a recursive fashion to fulfill rather complex tasks which consist of many jobs.

Additionally it defines an extensible API for communication with the frontend application, which may be a written using Gtk2, Tk or Qt or is a simple text console program.

In case of Gtk2 a custom widget for displaying an Event::ExecFlow job plan, including progress updates, is shipped with the Gtk2::Ex::FormFactory package.

Event Notifier is a Three Steps Wizard to create unlimited Notification Events using the icons of your installed programs that you think they correspond better for the reason you want to be notified for.

Event Notifier will notify you with a sound, a Tray tip, and by changing its Notification area and Taskbar icon for 10 minutes with the selected desirable one.