|
|
- _Events_handler(
adesklets.signal_handler.Signal_handler, adesklets.singleton._States)
-
- Events_handler(
adesklets.singleton._Singleton, _Events_handler)
- adesklets.singleton._Singleton
-
- Events_handler(
adesklets.singleton._Singleton, _Events_handler)
class
Events_handler(adesklets.singleton._Singleton,
_Events_handler) |
|
High-level events handler
Made to be used as a base class in applications wanting to catch
adesklets related events.
class My_events_handler(Events_handler):
def __init__(self):
Events_handler.__init__(self)
def __del__(self):
Events_handler.__del__(self)
...
from there, you just have to redefine the methods you are interested in,
choosing between ready(), quit(), alarm(), menu_fire(),
background_grab(),
button_press(),
button_release(), motion_notify(),
enter_notify() and
leave_notify() - see short descriptions below.
As soon as you will instanciate an object from your class, all
events corresponding to functions you 'overloaded' will
automatically be caugth and will cause your object methods to be
appropriately called.
Note 1: all methods events but
alarm() are protected critical
sections, if POSIX reliable signals are supported on your
architecture. This means they will not get interrupted by normal
adesklets operation. No adesklets events will ever be lost either:
they are garanteed to be all processed in the order they arrived,
except for one case: quit() signal is always processed right after
the current event method returns.
WARNING 1: Of course, this means that events are not guaranteed
to be processed as they arrive: they can be arbitrarily delayed
since former events processing could have taken any amount of time.
This is the reason you are encouraged to take advantage of the
'delayed' flag passed to most methods (and to write quick to compute
methods!). For instance, depending of your desklet, you may want
to ignore all motion_notify events that were not processed right
away, since they are no longuer relevant for giving quick feedback
to the user.
WARNING 2: As stated above, the
alarm() method, used for periodic
action, could get interrupted, unless on the initial call.
You are responsible for providing proper exception recovery
in case of problem with IO, for instance. Alternatively, you can
use the posix_signal API, already imported, to make your
own signal management, or use the
block()/unblock() methods
provided. Please note it is probably a bad idea to have a
long-running alarm() method blocking signals without any possibility
of being interrupted.
Note 2: every time an object from a class deriving from
Events_handler
is instanciated, the content of all communications channel to adesklets
interpreter is flushed.
Note 3: for obvious reasons, at most one instance of
Events_handler's
children can exist at any given time.
Note 4: when using the python interpreter in interactive mode,
calls to
Events_handler's functions could block, depending
of the platform/python version you use. This is due to
the way python handle access to various streams, including
stdout and stderr. If this happens to you, there are
two workarounds:
- Invoke python with the -u swith or the environment variable
PYTHONUNBUFFERED=1 - this works many times
- Avoid interactive mode - directly build a test script
and run it. :-)
Note 5: It you need to (from adesklets 0.3.0), you also have the two
methods Events_handler::get_events() and
Events_handler::set_events()
that give you an easy way to change at run time what events are catched,
and using what unbounded methods.
This is especially convenient if you want to program interruptable
timed 'effects' (see test/fading.py), while not having them
interrupetd by the same set of events you normally use.
|
|
- Method resolution order:
- Events_handler
- adesklets.singleton._Singleton
- _Events_handler
- adesklets.signal_handler.Signal_handler
- adesklets.singleton._States
Methods defined here:
- __del__(self)
- __init__(self)
- alarm(self)
-
Called periodically. Usefull to perform any perdiodic operation.
Delay until next call is determined from return value (which must be
an integer), in seconds (zero means not to reschedule). First call is
automatically scheduled right after the
ready() event method returns.
- background_grab(self,
delayed)
-
Called whenever adesklets' background image is updated
- block(self)
-
Convenience functions to block signals generated
by adesklets, if supported by your platform
WARNING: you never need to call it for any event but
alarm()
- button_press(self,
delayed, x, y, button)
-
Called whenever a button is pressed
- button_release(self,
delayed, x, y, button)
-
Called whenever a button is released
- enter_notify(self,
delayed, x, y)
-
Called whenever pointer enters the window
- get_events(self)
-
This returns a dictionary of all events catched by the desklet
at the time of calling.
For reliable use, it should always be called when signals are blocked
(See Events_handler class description above)
- leave_notify(self,
delayed, x, y)
-
Called whenever pointer leaves the window
- menu_fire(self,
delayed, menu_id, item)
-
Called whenever a catchable menu selection returns.
`item' may be None if no selection was made.
- motion_notify(self,
delayed, x, y)
-
Called whenever pointer is moved inside the window
- pause(self)
-
Put python intepreter to sleep forever, only waking up to
process events.
- quit(self)
-
Called only once when adesklets is about to quit:
the python interpreter will exit right after this function returns.
Note: this function is guaranteed not to be interrupted
by others signals from adesklets, but SIGKILL, whether you have POSIX
reliable signal support or not.
- ready(self)
-
Called only once when adesklets is ready to receive command
- set_events(self,
events)
-
This overrides the catched events using a dictionnary compatible to
the one sent back by
Events_handler::get_events().
This gives the desklet programmer a way to dynamically change
what signals are caught, which may be useful when working
with indirect mode programming (adesklets.start() command and others
alike).
- unblock(self)
-
Convenience functions to block signals generated
by adesklets, if supported by your platform
WARNING: you never need to call it for any event but
alarm()
Methods inherited from adesklets.signal_handler.Signal_handler:
- clear(self,
my_signals=None)
Data and other attributes inherited from adesklets.signal_handler.Signal_handler:
- func = <built-in function
signal>
-
signal(sig, action) -> action
Set the action for the given signal. The action can be SIG_DFL,
SIG_IGN, or a callable Python object. The previous action is
returned. See getsignal() for possible return values.
*** IMPORTANT NOTICE ***
A signal handler function is called with two arguments:
the first is the signal number, the second is the interrupted stack frame.
- ignore = 1
- posix_signal = <module
'posix_signal' from
'/usr/lib/python2.4/site-packages/posix_signal.so'>
|
|