POE::Wheel::Curses(3pm) User Contributed Perl Documentation POE::Wheel::Curses(3pm)NAME
POE::Wheel::Curses - non-blocking input for Curses
SYNOPSIS
use Curses;
use POE qw(Wheel::Curses);
POE::Session->create(
inline_states => {
_start => sub {
$_[HEAP]{console} = POE::Wheel::Curses->new(
InputEvent => 'got_keystroke',
);
},
got_keystroke => sub {
my $keystroke = $_[ARG0];
# Make control and extended keystrokes printable.
if ($keystroke lt ' ') {
$keystroke = '<' . uc(unctrl($keystroke)) . '>';
}
elsif ($keystroke =~ /^d{2,}$/) {
$keystroke = '<' . uc(keyname($keystroke)) . '>';
}
# Just display it.
addstr($keystroke);
noutrefresh();
doupdate;
# Gotta exit somehow.
delete $_[HEAP]{console} if $keystroke eq "<^C>";
},
}
);
POE::Kernel->run();
exit;
DESCRIPTION
POE::Wheel::Curses implements non-blocking input for Curses programs.
POE::Wheel::Curses will emit an "InputEvent" of your choosing whenever an input event is registered on a recognized input device (keyboard
and sometimes mouse, depending on the curses library). Meanwhile, applications can be doing other things like monitoring network
connections or child processes, or managing timers and stuff.
PUBLIC METHODS
POE::Wheel::Curses is rather simple.
new
new() creates a new POE::Wheel::Curses object. During construction, the wheel registers an input watcher for STDIN (via select_read()) and
registers an internal handler to preprocess keystrokes.
new() accepts only one parameter "InputEvent". "InputEvent" contains the name of the event that the wheel will emit whenever there is
input on the console or terminal. As with all wheels, the event will be sent to the session that was active when the wheel was
constructed.
It should be noted that an application may only have one active POE::Wheel::Curses object.
EVENTS AND PARAMETERS
These are the events sent by POE::Wheel::Curses.
InputEvent
"InputEvent" defines the event that will be emitted when POE::Wheel::Curses detects and reads console input. This event includes two
parameters:
$_[ARG0] contains the raw keystroke as received by Curses::getch(). An application may process the keystroke using Curses::unctrl() and
Curses::keyname() on the keystroke.
$_[ARG1] contains the POE::Wheel::Curses object's ID.
Mouse events aren't portable. As of October 2009, it's up to the application to decide whether to call mousemask().
SEE ALSO
Curses documents what can be done with Curses. Also see the man page for whichever version of libcurses happens to be installed (curses,
ncurses, etc.).
POE::Wheel describes wheels in general.
The SEE ALSO section in POE contains a table of contents covering the entire POE distribution.
BUGS
None known, although curses implementations vary widely.
AUTHORS &; COPYRIGHTS
Please see POE for more information about authors and contributors.
perl v5.14.2 2012-05-15 POE::Wheel::Curses(3pm)
Check Out this Related Man Page
POE::Wheel::ListenAccept(3pm) User Contributed Perl Documentation POE::Wheel::ListenAccept(3pm)NAME
POE::Wheel::ListenAccept - accept connections from regular listening sockets
SYNOPSIS
See "SYNOPSIS" in POE::Wheel::SocketFactory for a simpler version of this program.
#!perl
use warnings;
use strict;
use IO::Socket;
use POE qw(Wheel::ListenAccept Wheel::ReadWrite);
POE::Session->create(
inline_states => {
_start => sub {
# Start the server.
$_[HEAP]{server} = POE::Wheel::ListenAccept->new(
Handle => IO::Socket::INET->new(
LocalPort => 12345,
Listen => 5,
),
AcceptEvent => "on_client_accept",
ErrorEvent => "on_server_error",
);
},
on_client_accept => sub {
# Begin interacting with the client.
my $client_socket = $_[ARG0];
my $io_wheel = POE::Wheel::ReadWrite->new(
Handle => $client_socket,
InputEvent => "on_client_input",
ErrorEvent => "on_client_error",
);
$_[HEAP]{client}{ $io_wheel->ID() } = $io_wheel;
},
on_server_error => sub {
# Shut down server.
my ($operation, $errnum, $errstr) = @_[ARG0, ARG1, ARG2];
warn "Server $operation error $errnum: $errstr
";
delete $_[HEAP]{server};
},
on_client_input => sub {
# Handle client input.
my ($input, $wheel_id) = @_[ARG0, ARG1];
$input =~ tr[a-zA-Z][n-za-mN-ZA-M]; # ASCII rot13
$_[HEAP]{client}{$wheel_id}->put($input);
},
on_client_error => sub {
# Handle client error, including disconnect.
my $wheel_id = $_[ARG3];
delete $_[HEAP]{client}{$wheel_id};
},
}
);
POE::Kernel->run();
exit;
DESCRIPTION
POE::Wheel::ListenAccept implements non-blocking accept() calls for plain old listening server sockets. The application provides the
socket, using some normal means such as socket(), IO::Socket::INET, or IO::Socket::UNIX. POE::Wheel::ListenAccept monitors the listening
socket and emits events whenever a new client has been accepted.
Please see POE::Wheel::SocketFactory if you need non-blocking connect() or a more featureful listen/accept solution.
POE::Wheel::ListenAccept only accepts client connections. It does not read or write data, so it neither needs nor includes a put() method.
POE::Wheel::ReadWrite generally handles the accepted client socket.
PUBLIC METHODS
new
new() creates a new POE::Wheel::ListenAccept object for a given listening socket. The object will generate events relating to the socket
for as long as it exists.
new() accepts two required named parameters:
Handle
The "Handle" constructor parameter must contain a listening socket handle. POE::Wheel::FollowTail will monitor this socket and accept()
new connections as they arrive.
AcceptEvent
"AcceptEvent" is a required event name that POE::Wheel::ListenAccept will emit for each accepted client socket. "PUBLIC EVENTS" describes
it in detail
ErrorEvent
"ErrorEvent" is an optional event name that will be emitted whenever a serious problem occurs. Please see "PUBLIC EVENTS" for more
details.
event
event() allows a session to change the events emitted by a wheel without destroying and re-creating the object. It accepts one or more of
the events listed in "PUBLIC EVENTS". Undefined event names disable those events.
Ignore connections:
sub ignore_new_connections {
$_[HEAP]{tailor}->event( AcceptEvent => "on_ignored_accept" );
}
sub handle_ignored_accept {
# does nothing
}
ID
The ID() method returns the wheel's unique ID. It's useful for storing the wheel in a hash. All POE::Wheel events should be accompanied
by a wheel ID, which allows the wheel to be referenced in their event handlers.
sub setup_listener {
my $wheel = POE::Wheel::ListenAccept->new(... etc ...);
$_[HEAP]{listeners}{$wheel->ID} = $wheel;
}
PUBLIC EVENTS
POE::Wheel::ListenAccept emits a couple events.
AcceptEvent
"AcceptEvent" names the event that will be emitted for each newly accepted client socket. It is accompanied by three parameters:
$_[ARG0] contains the newly accepted client socket handle. It's up to the application to do something with this socket. Most use cases
involve passing the socket to a POE::Wheel::ReadWrite constructor.
$_[ARG1] contains the accept() call's return value, which is often the encoded remote end of the remote end of the socket.
$_[ARG2] contains the POE::Wheel::ListenAccept object's unique ID. This is the same value as returned by the wheel's ID() method.
A sample "AcceptEvent" handler:
sub accept_state {
my ($client_socket, $remote_addr, $wheel_id) = @_[ARG0..ARG2];
# Make the remote address human readable.
my ($port, $packed_ip) = sockaddr_in($remote_addr);
my $dotted_quad = inet_ntoa($packed_ip);
print(
"Wheel $wheel_id accepted a connection from ",
"$dotted_quad port $port.
"
);
# Spawn off a session to interact with the socket.
create_server_session($handle);
}
ErrorEvent
"ErrorEvent" names the event that will be generated whenever a new connection could not be successfully accepted. This event is
accompanied by four parameters:
$_[ARG0] contains the name of the operation that failed. This usually is 'accept', but be aware that it's not necessarily a function name.
$_[ARG1] and $_[ARG2] hold the numeric and stringified values of $!, respectively. POE::Wheel::ListenAccept knows how to handle EAGAIN
(and system-dependent equivalents), so this error will never be returned.
$_[ARG3] contains the wheel's unique ID, which may be useful for shutting down one particular wheel out of a group of them.
A sample "ErrorEvent" event handler. This assumes the wheels are saved as in the "ID" example.
sub error_state {
my ($operation, $errnum, $errstr, $wheel_id) = @_[ARG0..ARG3];
warn "Wheel $wheel_id generated $operation error $errnum: $errstr
";
delete $_[HEAP]{listeners}{$wheel_id};
}
SEE ALSO
POE::Wheel describes the basic operations of all wheels in more depth. You need to know this.
POE::Wheel::ReadWrite for one possible way to handle clients once you have their sockets.
The SEE ALSO section in POE contains a table of contents covering the entire POE distribution.
BUGS
None known.
AUTHORS &; COPYRIGHTS
Please see POE for more information about authors and contributors.
perl v5.14.2 2012-05-15 POE::Wheel::ListenAccept(3pm)