anyevent::impl::tk(3pm) [debian man page]

AnyEvent::Impl::Tk(3pm) 				User Contributed Perl Documentation				   AnyEvent::Impl::Tk(3pm)

NAME

       AnyEvent::Impl::Tk - AnyEvent adaptor for Tk

SYNOPSIS

	  use AnyEvent;
	  use Tk;

	  # this module gets loaded automatically as required

DESCRIPTION

       This module provides transparent support for AnyEvent. You don't have to do anything to make Tk work with AnyEvent except by loading Tk
       before creating the first AnyEvent watcher.

       Tk is buggy. Tk is extremely buggy. Tk is so unbelievably buggy that for each bug reported and fixed, you get one new bug followed by
       reintroduction of the old bug in a later revision. It is also basically unmaintained: the maintainers are not even interested in improving
       the situation - reporting bugs is considered rude, and fixing bugs is considered changing holy code, so it's apparently better to leave it
       broken.

       I regularly run out of words to describe how bad it really is.

       To work around some of the many, many bugs in Tk that don't get fixed, this adaptor dup()'s all filehandles that get passed into its I/O
       watchers, so if you register a read and a write watcher for one fh, AnyEvent will create two additional file descriptors (and handles).

       This creates a high overhead and is slow, but seems to work around most known bugs in Tk::fileevent on 32 bit architectures (Tk seems to be
       terminally broken on 64 bit, do not expect more than 10 or so watchers to work on 64 bit machines).

       Do not expect these workarounds to avoid segfaults and crashes inside Tk.

       Note also that Tk event ids wrap around after 2**32 or so events, which on my machine can happen within less than 12 hours, after which Tk
       will stomp on random other events and kill them. So don't run Tk programs for more than an hour or so.

       To be able to access the Tk event loop, this module creates a main window and withdraws it immediately. This might cause flickering on some
       platforms, but Tk perversely requires a window to be able to wait for file handle readyness notifications. This window is always created
       (in this version of AnyEvent) and can be accessed as $AnyEvent::Impl::Tk::mw.

SEE ALSO

       AnyEvent, Tk.

AUTHOR

	Marc Lehmann <schmorp@schmorp.de>
	http://anyevent.schmorp.de

perl v5.14.2							    2012-04-08						   AnyEvent::Impl::Tk(3pm)

AnyEvent::AggressiveIdle(3pm)				User Contributed Perl Documentation			     AnyEvent::AggressiveIdle(3pm)

NAME

       AnyEvent::AggressiveIdle - Aggressive idle processes for AnyEvent.

SYNOPSIS

	   use AnyEvent::AggressiveIdle qw(aggressive_idle};

	   aggressive_idle {
	       ... do something important
	   };

	   my $idle;
	   $idle = aggressive_idle {
	       ... do something important

	       if (FINISH) {
		   undef $idle;    # do not call the sub anymore
	       }
	   };

DESCRIPTION

       Sometimes You need to do something that takes much time but can be split into elementary phases. If You use AE::idle and Your program is a
       highload project, idle process can be delayed for much time (second, hour, day, etc). aggressive_idle will be called for each AnyEvent loop
       cycle. So You can be sure that Your idle process will continue.

EXPORTS

   aggressive_idle
       Register Your function as aggressive idle watcher. If it is called in VOID context, the watcher wont be deinstalled. Be carrefully.

       In NON_VOID context the function returns a guard.  Hold the guard until You want to cancel idle process.

   stop_aggressive_idle
       You can use the function to stop idle process. The function receives idle process PID that can be received in idle callback (the first
       argument).

       Example:

	   use AnyEvent::AggressiveIdle ':all'; # or:
	   use AnyEvent::AggressiveIdle qw(aggressive_idle stop_aggressive_idle);

	   aggressive_idle {
	       my ($pid) = @_;
	       ....

	       stop_aggressive_idle $pid;
	   }

       The function will throw an exception if invalid PID is received.

Continuous process.
       Sometimes You need to to something continuous inside idle callback. If You want to stop idle calls until You have done Your work, You can
       hold guard inside Your process:

	   aggressive_idle {
	       my ($pid, $guard) = @_;
	       my $timer;
	       $timer = AE::timer 0.5, 0 => sub {
		   undef $timer;
		   undef $guard;   # POINT 1
	       }
	   }

       Until 'POINT 1' aggressive_idle won't call its callback.  Feel free to stop_aggressive_idle before free the guard.

AUTHOR

       Dmitry E. Oboukhov, <unera@debian.org>

COPYRIGHT AND LICENSE

       Copyright (C) 2011 by Dmitry E. Oboukhov

       This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.10.1 or,
       at your option, any later version of Perl 5 you may have available.

VCS

       The project is placed on my GIT repo: <http://git.uvw.ru/?p=anyevent-aggressiveidle;a=summary>

perl v5.10.1							    2011-03-01					     AnyEvent::AggressiveIdle(3pm)