Free predictive text input software for linux

HTML_QuickForm_LiveText project is custom HTML_QuickForm element implemented as an input text that intercepts key presses to perform a query via AJAX and then shows the result.
When a result line is selected, its value fills the input text and optionally other HTML elements, based on result structure and a map between result component and HTML elements IDs.
Enhancements:
- Result-boxes positions are now "fixed" after the window is loaded.
- This is due to IE, which shows the div at the right of the input text.

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*

Polymorphic XML Parser is a validating XML parser for the programming language Objective Caml.
In October, 1999, I started writing a validating XML parser for OCaml; the first published versions have been called "Markup" (simply because the package name was "markup"). After this parser had some success, I decided to revise the whole code, and to redesign the parser where it was needed. The result of this work is PXP, the Polymorphic XML Parser. The name reflects an important property of the parser, namely that the type of the XML nodes can be customized; a feature which is missing in most other XML parsers.
Now, one year later, I can announce the first stable version of PXP. "Stable" means mostly that the interface of the parser has become stable, i.e. future changes will extend but not break the current interface. The parser worked relatively well from the very beginning, and during the pre-release phase (several months) users reported only few bugs. I am now relatively sure that PXP is mature enough to be used in applications.
In general, the task of a XML parser is to read XML text, and to represent the text somehow in memory. There are several models for the data structures; for PXP I have chosen the luxury representation as object tree, in which every XML node is stored as two objects. One object contains the set of methods describing the fixed properties of every node; the other object is called the extension object and can be configured by the user of the parser.
The extension object is the polymorphic part of the representation. The type of the class may be arbitrary (except three base methods which connect the object to the tree), and the parser has a mechanism to dynamically select the class of the object depending on the element type of the XML node.
Main features:
- The XML instance is validated against the DTD; any violation of a validation constraint leads to the rejection of the instance. The validator has been carefully implemented, and conforms strictly to the standard. If needed, it is also possible to run the parser in a well-formedness mode.
- If possible, the validator applies a deterministic finite automaton to validate the content models. This ensures that validation can always be performed in linear time. However, in the case that the content models are not deterministic, the parser uses a backtracking algorithm which can be much slower. - It is also possible to reject non-deterministic content models.
- The parser can read XML text encoded in a variety of character sets. Independent of this, it is possible to choose the encoding of the internal representation of the tree nodes; the parser automatically converts the input text to this encoding. Currently, the parser supports UTF-8 and ISO-8859-1 as internal encodings.
- The interface of the parser has been designed such that it is best integrated into the language OCaml. The first goal was simplicity of usage which is achieved by many convenience methods and functions, and by allowing the user to select which parts of the XML text are actually represented in the tree. For example, it is possible to store processing instructions as tree nodes, but the parser can also be configured such that these instructions are put into hashtables. The information model is compatible with the requirements of XML-related standards such as XPath.
- There is also an interface for DTDs; you can parse and access sequences of declarations.

VietIME is a Java-based Vietnamese input method editor (IME). Enable input of Vietnamese Unicode text in Javas AWT and Swing text components.
VietIME uses the input method framework in the Java 2 platform (1.3 or higher) to enable the collaboration between text editing components and input methods in entering Vietnamese text with any Java runtime environment.
Text editing components that use the input method framework run on any Java application environment and support any text input methods available on that Java application environment without modifying or recompiling the text editing component.
Main features:
- Multi-platform
Windows
Solaris
Linux/Unix
Mac OS X
Others
- Unicode compatibility
- Common Vietnamese input methods
VNI
VIQR
Telex
- SmartMark
- Spell Check, Convert, Change Case, Strip/Normalize Diacritics, Sort Vietnamese words, etc. (available only to Swing applications)

GnuDialer is a predictive dialer for contact centers. GnuDialer currently supports inbound, outbound, open/closer, and auto campaigns.

GnuDialer project has a multi-process object oriented design and uses the Asterisk PBX. Gnudialer is separate from any agent interface or CRM, but does include a capable (Java-based) CRM application that uses Firefox, Internet Explorer, and Mozilla.

Linux::Input::Joystick is a joystick-specific interface for Linux 2.2+

SYNOPSIS

Usage

use YAML;
my $js = Linux::Input::Joystick->new(/dev/input/js0);
while (1) {
my @event = $js->poll(0.01);
print Dump($_) foreach (@event);
}

This is a subclass of Linux::Input that implements the joystick event interface that versions of Linux from 2.2 onward support. It differs from the normal event interface in that it uses a slightly different C struct to return event information.

This subclass inherits all of Linux::Inputs methods, but differs from it in the following ways:

Class Methods

new

This method takes a $filename and returns a Linux::Input::Joystick object on success.

Example:

my $js = Linux::Input::Joystick->new(/dev/input/js1);

event_bytes

This method returns the size of the joystick event structure (which is always 8) no matter what platform you run this on.

Object Methods

poll

This method takes a $timeout as a parameter and returns an list of @events after that timeout has elapsed. The hashrefs inside @events have the following key/value pairs.

time

This is the time in microseconds that this event happened.
type

This is the type of event.
number

This number represents a more specific instance of type. For example, if type is 1 (meaning button event), then number might be 5 (meaning button 5 moved).
value

This number specifies what happened. Keeping the previous example in mind, if the value received is 1, that means the button was pressed. However, if its 0, that means the button was released.

For more information on what values to expect in this hashref, go look at /usr/include/linux/joystick.h

Text::Kakasi::JP is a Japanese Perl extension for Text::Kakasi.

SYNOPSIS

use Text::Kakasi;
# functional
$res = Text::Kakasi::getopt_argv(kakasi, -ieuc, -w);
$str = Text::Kakasi::do_kakasi($japanese_text);
# object-oriented
$obj = Text::Kakasi->new(-ieuc,-w);
$str = $obj->get($japanese_text);