Rev 060c33a...Leo build: 20140825070951 contains a spectacular collapse in
complexity in idle-time handling.
Instantly, registering idle-time event handlers can be considered
deprecated, though I have no plans to remove the horrendous older code.
The new pattern allows multiple, independent (or cooperating) idle-time
handlers, created at will as needed.
The new code is based on the IdleTime class in qtGui.py. Rather than
access this directly, code should use the g.IdleTime proxy::
def IdleTime(c,handler,delay=500):
'''A proxy for the g.app.gui.IdleTime class.'''
if g.app and g.app.gui and hasattr(g.app.gui,'idleTimeClass'):
return g.app.gui.idleTimeClass(c,handler,delay)
else:
return None
g.IdleTime ensures that all is well when using gui's that don't have an
IdleTime class.
Here is how to use the new code::
def handler(it):
'''The IdleTime handler: called at idle time.'''
delta_t = it.time-it.starting_time
g.trace(it.count,it.c.shortFileName(),'%2.4f' % (delta_t))
if it.count >= 5:
g.trace('done')
it.stop()
it = g.IdleTime(c,handler,delay=500)
if it: it.start()
The code creates an instance of the IdleTime class that calls the given
handler at idle time, and no more than once every 500 msec. Here is the
output::
handler 1 ekr.leo 0.5100
handler 2 ekr.leo 1.0300
handler 3 ekr.leo 1.5400
handler 4 ekr.leo 2.0500
handler 5 ekr.leo 2.5610
handler done
Timer instances are completely independent. For example:
def handler1(it):
'''The IdleTime handler: called at idle time.'''
delta_t = it.time-it.starting_time
g.trace('%2s %s %2.4f' % (it.count,it.c.shortFileName(),delta_t))
if it.count >= 5:
g.trace('done')
it.stop()
def handler2(it):
'''The IdleTime handler: called at idle time.'''
delta_t = it.time-it.starting_time
g.trace('%2s %s %2.4f' % (it.count,it.c.shortFileName(),delta_t))
if it.count >= 10:
g.trace('done')
it.stop()
it1 = g.IdleTime(c,handler1,delay=500)
it2 = g.IdleTime(c,handler2,delay=1000)
if it1 and it2:
it1.start()
it2.start()
Here is the output::
handler1 1 ekr.leo 0.5200
handler2 1 ekr.leo 1.0100
handler1 2 ekr.leo 1.0300
handler1 3 ekr.leo 1.5400
handler2 2 ekr.leo 2.0300
handler1 4 ekr.leo 2.0600
handler1 5 ekr.leo 2.5600
handler1 done
handler2 3 ekr.leo 3.0400
handler2 4 ekr.leo 4.0600
handler2 5 ekr.leo 5.0700
handler2 6 ekr.leo 6.0800
handler2 7 ekr.leo 7.1000
handler2 8 ekr.leo 8.1100
handler2 9 ekr.leo 9.1300
handler2 10 ekr.leo 10.1400
handler2 done
That's it. I plan to use this new code in attempt to do syntax coloring in
pieces at idle time. No guarantee that it can work, but I have hopes...
Edward
P.S. Here is the IdleTime class, as rendered by the flatten-script
command. This is beautiful code::
class IdleTime:
'''A class that executes a handler at idle time.'''
def __init__(self,c,handler,delay=500):
'''ctor for IdleTime class.'''
# g.trace('(IdleTime)')
self.c = c
self.count = 0
# The number of times handler has been called.
self.delay = delay
# The argument to self.timer.start:
# 0 for idle time, otherwise a delay in msec.
self.enabled = False
# True: run the timer continuously.
self.handler = handler
# The user-provided idle-time handler.
self.last_delay = 0
# The previous value of self.delay.
self.starting_time = None
# Time that the timer started.
self.time = None
# Time that the handle is called.
# Create the timer, but do not fire it.
self.timer = QtCore.QTimer()
def IdleTime_callback():
self.at_idle_time()
self.timer.timeout.connect(IdleTime_callback)
def at_idle_time(self):
'''Call self.handler not more than once every self.delay
msec.'''
trace = False and not g.unitTesting
if self.enabled:
# Idle-time processing is enabled.
if self.last_delay == 0:
# At idle time: call the handler.
if trace: g.trace('at idle time')
self.call_handler()
# Now wait at for at least self.delay msec.
self.last_delay = self.delay
self.timer.stop()
self.timer.start(self.delay)
else:
# We have waited at least self.delay msec.
# Now wait for idle time.
if trace: g.trace('waiting for idle time')
self.last_delay = 0
self.timer.stop()
self.timer.start(0)
else:
# Idle-time processing is disabled. Stop the timer.
if trace: g.trace('Stopping timer.')
self.timer.stop()
def call_handler(self):
'''Carefully call the handler.'''
try:
self.count += 1
self.time = time.time()
self.handler(self)
except Exception:
g.es_exception()
self.stop()
def start(self):
'''Start idle-time processing'''
self.enabled = True
if self.starting_time is None:
self.starting_time = time.time()
# Wait at least self.delay msec, then wait for idle time.
self.last_delay = self.delay
self.timer.start(self.delay)
def stop(self):
'''Stop idle-time processing.'''
self.enabled = False
EKR
--
You received this message because you are subscribed to the Google Groups
"leo-editor" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/leo-editor.
For more options, visit https://groups.google.com/d/optout.
