def callbackFunction3():
TestScheduler.callTime3 = Scheduler.timestamp()
prettyTime = strftime("%H:%M:%S", localtime(TestScheduler.callTime3))
TestScheduler.ourLogger.info("`%s' executed at: %s",
TestScheduler.callbackFunction3.__name__,
prettyTime)
def testMakeDueCallNothingScheduled(self):
timeNow = Scheduler.timestamp()
untilTime = timeNow + 5000
aTime = Scheduler.make_due_calls(time_now=timeNow, until_time=untilTime)
TestScheduler.ourLogger.info("aTime: %s", aTime)
self.assertFalse(TestScheduler.weHaveBeenCalledToken, "Someone set the token and should not have")
def testNonEqualityWithTime(self):
whenToExecute1 = Scheduler.timestamp()
whenToExecute2 = Scheduler.timestamp()
TestScheduledCall.classLogger.info(
"whenToExecute1: %s, whenToExecute2: %s", whenToExecute1,
whenToExecute2)
sc1: ScheduledCall = ScheduledCall(timeToExecute=whenToExecute1,
func=TestScheduledCall.callback1,
interval=0)
sc2: ScheduledCall = ScheduledCall(timeToExecute=whenToExecute2,
func=TestScheduledCall.callback1,
interval=0)
ans: bool = sc1 == sc2
self.assertFalse(ans, "time inequality is failing")
def scheduledMethod(self):
ts = Scheduler.timestamp()
cbText = f"I have been called at: {ts}"
self.logger.info(cbText)
oldText = self.textBox.getText()
cbText = f"{oldText}\n{cbText}"
self.textBox.setText(cbText)
def testStringRepresentation(self):
whenToExecute = Scheduler.timestamp()
sc: ScheduledCall = ScheduledCall(timeToExecute=whenToExecute,
func=TestScheduledCall.callback1,
interval=40)
strRep = sc.__str__()
self.assertIsNotNone(strRep,
"Class string rep did not return anything")
TestScheduledCall.classLogger.info("String representation: %s", sc)
def testNonEqualityWithInterval(self):
whenToExecute = Scheduler.timestamp()
sc1: ScheduledCall = ScheduledCall(timeToExecute=whenToExecute,
func=TestScheduledCall.callback1,
interval=40)
sc2: ScheduledCall = ScheduledCall(timeToExecute=whenToExecute,
func=TestScheduledCall.callback2,
interval=50)
ans: bool = (sc1 == sc2)
self.assertFalse(ans, "Interval inequality is failing")
def testGreaterThanFalse(self):
whenToExecute = Scheduler.timestamp()
sc1: ScheduledCall = ScheduledCall(timeToExecute=whenToExecute + 1000,
func=TestScheduledCall.callback1,
interval=40)
sc2: ScheduledCall = ScheduledCall(timeToExecute=whenToExecute,
func=TestScheduledCall.callback2,
interval=50)
ans: bool = (sc1 < sc2)
self.assertFalse(ans, "__cmp__ seems to be broken")
def testEquality(self):
whenToExecute = Scheduler.timestamp()
TestScheduledCall.classLogger.info("whenToExecute: %s", whenToExecute)
sc1: ScheduledCall = ScheduledCall(timeToExecute=whenToExecute,
func=TestScheduledCall.callback1,
interval=0)
sc2: ScheduledCall = ScheduledCall(timeToExecute=whenToExecute,
func=TestScheduledCall.callback1,
interval=0)
self.assertEqual(first=sc1,
second=sc2,
msg="Unit test equality is failing")
self.assertTrue((sc1 == sc2), msg="Basic equality is failing")
def testMakeDueCalls(self):
TestScheduler.ourLogger.info("Test Scheduler make calls that are due")
retToken = Scheduler.schedule_call(delay=0, func=TestScheduler.callbackFunction, repeat=False)
TestScheduler.ourLogger.info("Task %s scheduled", retToken)
TestScheduler.ourLogger.info("Sleepy time ...")
time.sleep(10.0)
TestScheduler.ourLogger.info("We've awakened . . . ")
timeNow = Scheduler.timestamp()
untilTime = timeNow + 5000
aTime = Scheduler.make_due_calls(time_now=timeNow, until_time=untilTime)
TestScheduler.ourLogger.info("aTime: %s", aTime)
self.assertTrue(TestScheduler.weHaveBeenCalledToken, "The token should have been set, but was not")
def processEvents(self, eventList: List[Event], relativeMode: bool,
deferDrawing: bool,
eventLoopParams: EventLoopParams) -> EventLoopParams:
self.logger.debug(f"Events to process: {len(eventList)}")
use_sleep = eventLoopParams.use_sleep
relative_pause = eventLoopParams.relative_pause
do_draw = eventLoopParams.do_draw
relative_warmup = eventLoopParams.relative_warmup
last_click_time = eventLoopParams.last_click_time
num_clicks = eventLoopParams.num_clicks
for event in eventList:
t = Scheduler.timestamp()
event.dict['time'] = t
event.dict['local'] = getattr(event, 'pos', (0, 0))
eventType = event.type
if eventType == QUIT:
self.quit()
elif eventType == MOUSEBUTTONDOWN:
# print "RootWidget: MOUSEBUTTONDOWN: setting do_draw" ###
do_draw = True
if t - last_click_time <= AlbowEventLoop.DOUBLE_CLICK_TIME:
num_clicks += 1
else:
num_clicks = 1
last_click_time = t
event.dict['num_clicks'] = num_clicks
CoreUtilities.add_modifiers(event)
RootWidget.last_mouse_event = event
self.logger.debug(
f"num_clicks: '{num_clicks}' -- t: '{t}' -- last_click_time: '{last_click_time}'"
)
if relativeMode:
event.dict['local'] = (0, 0)
if relative_pause:
relative_pause = False
else:
# modal_widget.dispatch_key('mouse_down', event)
mouse_widget = self.modal_widget.get_focus()
RootWidget.clicked_widget = mouse_widget
RootWidget.last_mouse_event_handler = mouse_widget
mouse_widget.handle_event('mouse_down', event)
else:
mouse_widget = self.containingWidget.find_widget(event.pos)
if not mouse_widget.is_inside(self.modal_widget):
mouse_widget = self.modal_widget
RootWidget.clicked_widget = mouse_widget
RootWidget.last_mouse_event_handler = mouse_widget
mouse_widget.notify_attention_loss()
mouse_widget.handle_mouse('mouse_down', event)
elif eventType == MOUSEMOTION:
CoreUtilities.add_modifiers(event)
RootWidget.last_mouse_event = event
if relativeMode:
event.dict['local'] = (0, 0)
if not relative_pause:
if relative_warmup:
relative_warmup -= 1
else:
# modal_widget.dispatch_key('mouse_delta', event)
mouse_widget = RootWidget.clicked_widget or self.modal_widget.get_focus(
)
RootWidget.last_mouse_event_handler = mouse_widget
mouse_widget.handle_event('mouse_delta', event)
else:
mouse_widget = self.containingWidget.find_widget(
event.pos) # Do this in else branch?
if RootWidget.clicked_widget:
RootWidget.last_mouse_event_handler = mouse_widget # Should this be clicked_widget?
RootWidget.clicked_widget.handle_mouse(
'mouse_drag', event)
else:
if not mouse_widget.is_inside(self.modal_widget):
mouse_widget = self.modal_widget
RootWidget.last_mouse_event_handler = mouse_widget
mouse_widget.handle_mouse('mouse_move', event)
elif eventType == MOUSEBUTTONUP:
CoreUtilities.add_modifiers(event)
RootWidget.last_mouse_event = event
do_draw = True
if relativeMode:
event.dict['local'] = (0, 0)
if not relative_pause:
if RootWidget.clicked_widget:
mouse_widget = RootWidget.clicked_widget
RootWidget.clicked_widget = None
else:
mouse_widget = self.modal_widget.get_focus()
RootWidget.last_mouse_event_handler = mouse_widget
mouse_widget.handle_event('mouse_up', event)
else:
if RootWidget.clicked_widget:
RootWidget.last_mouse_event_handler = RootWidget.clicked_widget
RootWidget.clicked_widget = None
RootWidget.last_mouse_event_handler.handle_mouse(
'mouse_up', event)
elif eventType == KEYDOWN:
key = event.key
if key == K_ESCAPE and relativeMode and event.mod & KMOD_CTRL and event.mod & KMOD_SHIFT:
relative_pause = True
elif relative_pause:
relative_pause = False
else:
CoreUtilities.set_modifier(key, True)
do_draw = True
self.send_key(self.modal_widget, 'key_down', event)
if RootWidget.last_mouse_event_handler:
event.dict['pos'] = RootWidget.last_mouse_event.pos
event.dict['local'] = RootWidget.last_mouse_event.local
RootWidget.last_mouse_event_handler.setup_cursor(event)
elif eventType == KEYUP:
key = event.key
CoreUtilities.set_modifier(key, False)
do_draw = True
self.send_key(self.modal_widget, 'key_up', event)
if RootWidget.last_mouse_event_handler:
event.dict['pos'] = RootWidget.last_mouse_event.pos
event.dict['local'] = RootWidget.last_mouse_event.local
RootWidget.last_mouse_event_handler.setup_cursor(event)
elif eventType == AlbowEventLoop.MUSIC_END_EVENT:
self.music_end()
elif eventType == USEREVENT:
if deferDrawing and not use_sleep:
RootWidget.ourTimerEvent = event
else:
#
# Maybe someone has registered some user events handler
#
userEventCallList = RootWidget.getUserEventList()
for cb in userEventCallList:
if cb.userEvent == eventType:
self.logger.debug(f"API User eventType: {eventType}")
cb.func(event)
retEventLoopParams: EventLoopParams = EventLoopParams(
use_sleep=use_sleep,
relative_pause=relative_pause,
do_draw=do_draw,
relative_warmup=relative_warmup,
last_click_time=last_click_time,
num_clicks=num_clicks)
return retEventLoopParams
def run_modal(self, modal_widget: Widget):
"""
Runs a modal event loop. The widget is run as a modal dialog until its dismiss() method is called.
Args:
modal_widget: The modal widget
"""
is_modal = modal_widget is not None
modal_widget = modal_widget or self
relative_pause = False
relative_warmup = 0
was_modal = None
try:
RootWidget.old_top_widget = RootWidget.top_widget
RootWidget.top_widget = modal_widget
was_modal = modal_widget.is_modal
modal_widget.is_modal = True
modal_widget.modal_result = None
if not modal_widget.focus_switch:
modal_widget.tab_to_first()
self.do_draw = True
use_sleep = self._use_sleep
from albow.core.ui.AlbowEventLoop import AlbowEventLoop
from albow.core.ui.EventLoopParams import EventLoopParams
eventLoop: AlbowEventLoop = AlbowEventLoop(
modalWidget=modal_widget, containingWidget=self)
last_click_time = 0
num_clicks = 0
while modal_widget.modal_result is None:
defer_drawing = self.frame_time != 0.0 and modal_widget.defer_drawing(
)
try:
if not is_modal:
if RootWidget.ourTimerEvent:
if not use_sleep and defer_drawing:
Scheduler.make_scheduled_calls()
CoreUtilities.add_modifiers(
RootWidget.ourTimerEvent)
if RootWidget.last_mouse_event:
RootWidget.ourTimerEvent.dict[
'pos'] = RootWidget.last_mouse_event.pos
RootWidget.ourTimerEvent.dict[
'local'] = RootWidget.last_mouse_event.local
if RootWidget.last_mouse_event_handler:
RootWidget.last_mouse_event_handler.setup_cursor(
RootWidget.ourTimerEvent)
self.do_draw = self.timer_event(
RootWidget.ourTimerEvent)
RootWidget.ourTimerEvent = None
else:
if defer_drawing:
self.do_draw = False
# RootWidget.classLogger.info(f"self.do_draw: {self.do_draw}")
if self.do_draw:
if self.is_gl:
gl_surface = self.gl_surface
gl_surface.gl_clear(self.bg_color)
self.gl_draw_all(gl_surface)
gl_surface.gl_flush()
else:
self.draw_all(self.surface)
self.do_draw = False
# tb1 = timestamp() ###
pygame.display.flip()
in_relative_mode = bool(modal_widget.relative_mode())
grab = in_relative_mode and not relative_pause
if grab != get_grab():
set_grab(grab)
set_mouse_visible(not grab)
relative_warmup = 3 # Ignore spurious deltas on entering relative mode
if use_sleep and defer_drawing:
time_now = Scheduler.timestamp()
if RootWidget.nextFrameDue < time_now:
RootWidget.nextFrameDue = time_now
while True:
sleep_time = Scheduler.make_due_calls(
time_now, RootWidget.nextFrameDue)
if sleep_time <= 0.0:
break
sleep(sleep_time / 1000.0)
time_now = Scheduler.timestamp()
RootWidget.nextFrameDue += self.frame_time
RootWidget.ourTimerEvent = Event(
USEREVENT, {'time': time_now})
events = []
else:
events = [pygame.event.wait()]
events.extend(pygame.event.get())
loopParams: EventLoopParams = EventLoopParams(
use_sleep=use_sleep,
relative_pause=relative_pause,
do_draw=self.do_draw,
relative_warmup=relative_warmup,
last_click_time=last_click_time,
num_clicks=num_clicks)
newParams: EventLoopParams = eventLoop.processEvents(
eventList=events,
relativeMode=in_relative_mode,
deferDrawing=defer_drawing,
eventLoopParams=loopParams)
use_sleep = newParams.use_sleep
relative_pause = newParams.relative_pause
self.do_draw = newParams.do_draw
relative_warmup = newParams.relative_warmup
last_click_time = newParams.last_click_time
num_clicks = newParams.num_clicks
except CancelException:
pass
except ApplicationException as e:
self.report_error(e)
finally:
modal_widget.is_modal = was_modal
RootWidget.top_widget = RootWidget.old_top_widget
RootWidget.clicked_widget = None
