NAME

NAME
"Term::TermKey::Async" - terminal key input using "libtermkey" with
"IO::Async"

SYNOPSIS
use Term::TermKey::Async qw( FORMAT_VIM KEYMOD_CTRL );
use IO::Async::Loop;

my $loop = IO::Async::Loop->new();

my $tka = Term::TermKey::Async->new(
term => \*STDIN,

on_key => sub {
my ( $self, $key ) = @_;

print "Got key: ".$self->format_key( $key, FORMAT_VIM )."\n";

$loop->loop_stop if $key->type_is_unicode and
$key->utf8 eq "C" and
$key->modifiers & KEYMOD_CTRL;
},
);

$loop->add( $tka );

$loop->loop_forever;

DESCRIPTION
This class implements an asynchronous perl wrapper around the
"libtermkey" library, which provides an abstract way to read keypress
events in terminal-based programs. It yields structures that describe
keys, rather than simply returning raw bytes as read from the TTY
device.

This class is a subclass of "IO::Async::Handle", allowing it to be put
in an "IO::Async::Loop" object and used alongside other objects in an
"IO::Async" program. It internally uses an instance of Term::TermKey to
access the underlying C library. For details on general operation,
including the representation of keypress events as objects, see the
documentation on that class.

Proxy methods exist for normal accessors of "Term::TermKey", and the
usual behaviour of the "getkey" or other methods is instead replaced by
the "on_key" event.

EVENTS
The following events are invoked, either using subclass methods or CODE
references in parameters:

on_key $key
Invoked when a key press is received from the terminal. The $key
parameter will contain an instance of "Term::TermKey::Key" representing
the keypress event.

CONSTRUCTOR
$tka = Term::TermKey::Async->new( %args )
This function returns a new instance of a "Term::TermKey::Async" object.
It takes the following named arguments:

term => IO or INT
Optional. File handle or POSIX file descriptor number for the
file handle to use as the connection to the terminal. If not
supplied "STDIN" will be used.

PARAMETERS
The following named parameters may be passed to "new" or "configure":

flags => INT
"libtermkey" flags to pass to constructor or "set_flags".

on_key => CODE
CODE reference for the "on_key" event.

METHODS
$tk = $tka->termkey
Returns the "Term::TermKey" object being used to access the "libtermkey"
library. Normally should not be required; the proxy methods should be
used instead. See below.

$flags = $tka->get_flags
$tka->set_flags( $flags )
$canonflags = $tka->get_canonflags
$tka->set_canonflags( $canonflags )
$msec = $tka->get_waittime
$tka->set_waittime( $msec )
$str = $tka->get_keyname( $sym )
$sym = $tka->keyname2sym( $keyname )
( $ev, $button, $line, $col ) = $tka->interpret_mouse( $key )
$str = $tka->format_key( $key, $format )
$key = $tka->parse_key( $str, $format )
$key = $tka->parse_key_at_pos( $str, $format )
$cmp = $tka->keycmp( $key1, $key2 )
These methods all proxy to the "Term::TermKey" object, and allow
transparent use of the "Term::TermKey::Async" object as if it was a
subclass. Their arguments, behaviour and return value are therefore
those provided by that class. For more detail, see the Term::TermKey
documentation.

AUTHOR
Paul Evans <[email protected]>