Free linux input event software for linux

Linux::Input is a Linux input event interface.

SYNOPSIS

Example: 1 joystick using event API

my $js1 = Linux::Input->new(/dev/input/event3);
while (1) {
while (my @events = $js1->poll(0.01)) {
foreach (@event) {
}
}
}

Example: 2 joysticks using joystick API (different event structure)

my $js1 = Linux::Input::Joystick->new(/dev/input/js0);
my $js2 = Linux::Input::Joystick->new(/dev/input/js1);
my $selector = IO::Select->new();
$selector->add($js1->fh);
$selector->add($js2->fh);

while (my $fh = $selector->can_read) {
my @event;
if ($fh == $js1->fh) {
@event = $js1->poll()
} elsif ($fh == $js2->fh) {
@event = $js2->poll()
}
foreach (@event) {
# work
}
}

Example 3: monitor all input devices

use File::Basename qw(basename);
my @inputs = map { "/dev/input/" . basename($_) }
;

my @dev;
my $selector = IO::Select->new();
foreach (@inputs) {
my $device = Linux::Input->new($_);
$selector->add($device->fh);
push @dev, $device;
}

while (my $fh = $selector->can_read) {
# work
}

Example 4: testing for events on the command line

# information on what event queue belongs to what device
cat /proc/bus/input/devices

# verify that events are coming in
sudo evtest.pl /dev/input/event*

Linux::Inotify2 is a scalable directory/file change notification.

SYNOPSIS

Callback interface
use Linux::Inotify2;

# create a new object
my $inotify = new Linux::Inotify2
or die "Unable to create new inotify object: $!";

# for Event:
Event->io (fd =>$inotify->fileno, poll => r, cb => sub { $inotify->poll });
# for Glib:
add_watch Glib::IO $inotify->fileno, in => sub { $inotify->poll };
# manually:
1 while $inotify->poll;

# add watchers
$inotify->watch ("/etc/passwd", IN_ACCESS, sub {
my $e = shift;
my $name = $e->fullname;
print "$name was accessedn" if $e->IN_ACCESS;
print "$name is no longer mountedn" if $e->IN_UNMOUNT;
print "$name is gonen" if $e->IN_IGNORED;
print "events for $name have been lostn" if $e->IN_Q_OVERFLOW;

# cancel this watcher: remove no further events
$e->w->cancel;
});
Streaming Interface
use Linux::Inotify2 ;

# create a new object
my $inotify = new Linux::Inotify2
or die "Unable to create new inotify object: $!" ;

# create watch
$inotify->watch ("/etc/passwd", IN_ACCESS)
or die "watch creation failed" ;

while () {
my @events = $inotify->read;
unless (@events > 0) {
print "read error: $!";
last ;
}
printf "maskt%dn", $_->mask foreach @events ;
}

This module implements an interface to the Linux 2.6.13 and later Inotify file/directory change notification sytem.

It has a number of advantages over the Linux::Inotify module:

- it is portable (Linux::Inotify only works on x86)
- the equivalent of fullname works correctly
- it is better documented
- it has callback-style interface, which is better suited for
integration.

Linux distribution race is a cool car race for 4 players, cars are named by Linux distributions (Mandrake, SUSE, RedHat, Debian).

You can create maps in GIMP. Controls: WSAD, TGFH, IKJL, arrows.

Swinput can fake a mouse and a keyboard by using the Linux Input System. The swinput modules read from a device and fakes hardware event (mouse motion, key presses etc) as commands written on the devices. Swinput presents status etc on the proc filesystem.

Swinput project is useful when testing applications.

It was developed to use when testing Xnee.

libRUIN (Renderer for User Interfaces in Ncurses) is a rendering library for various XML-based user interface markup languages (such as XHTML or Mozilla XUL). libRUIN is using the Ncurses terminal control library as a rendering target.
GNU Guile and the SDOM Scheme module are used as the "glue" that manages user input and event handling (as such, event handlers must currently be written in Guile Scheme; support for ECMAscript event handlers is being considered for inclusion).
An application programmer passes an XML document (including, potentially, a set of CSS stylesheets) and an Ncurses WINDOW structure, and libRUIN paints the WINDOW according to the markup and CSS; the programmer may subsequently pass Ncurses-style input strings to that WINDOW via libRUIN, and libRUIN will handle the resulting event flows.
Enhancements:
- This release adds an implementation of the automatic table layout algorithm.
- The latest versions of SCSS and SDOM have been integrated, allowing automatic document type detection and several rendering correctness fixes.
- The API has changed to reflect the mitigated need for XML dialect specification.
- Issues related to rendering corruption and border widths have been resolved.

Linux DC++ is a project to port the DC++ direct connect client to Linux or any POSIX-compliant Unix.

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.