def testBitmapManager(self):
WAIT_TIMEOUT = 2000
def expectException(returnValue, nextAction):
if isinstance(returnValue, Exception):
nextAction()
else:
raise RuntimeError("Expected exception, got %s (%s)" %
(returnValue, type(returnValue)))
def loadValidBitmap():
def validBitmapCb(bitmap):
self.assert_(not isinstance(bitmap, Exception))
player.setTimeout(0, loadBitmapWithPixelFormat)
avg.BitmapManager.get().loadBitmap("media/rgb24alpha-64x64.png",
validBitmapCb)
def loadBitmapWithPixelFormat():
def validBitmapCb(bitmap):
self.assert_(not isinstance(bitmap, Exception))
self.assert_(bitmap.getFormat() == avg.B5G6R5)
player.setTimeout(0, loadUnexistentBitmap)
avg.BitmapManager.get().loadBitmap("media/rgb24alpha-64x64.png",
validBitmapCb, avg.B5G6R5)
def loadUnexistentBitmap():
avg.BitmapManager.get().loadBitmap(
"nonexistent.png", lambda bmp: expectException(
returnValue=bmp,
nextAction=lambda: player.setTimeout(0, loadBrokenBitmap)))
def loadBrokenBitmap():
import tempfile
tempFileName = os.path.join(tempfile.gettempdir(), "broken.png")
open(tempFileName, "w")
def cleanupAndTestReturnValue(returnValue):
os.unlink(tempFileName)
expectException(returnValue=returnValue,
nextAction=player.stop)
avg.BitmapManager.get().loadBitmap(tempFileName,
cleanupAndTestReturnValue)
def reportStuck():
raise RuntimeError("BitmapManager didn't reply "
"within %dms timeout" % WAIT_TIMEOUT)
player.stop()
for multithread in [False, True]:
self.loadEmptyScene()
if multithread:
avg.BitmapManager.get().setNumThreads(2)
player.setTimeout(WAIT_TIMEOUT, reportStuck)
player.setResolution(0, 0, 0, 0)
loadValidBitmap()
player.play()
avg.BitmapManager.get().setNumThreads(1)
def __init__(self, w, h, parent=None, **kw):
super(MenuBackground, self).__init__(**kw)
self.registerInstance(self, parent)
self.__outline = avg.PolygonNode(
parent=self,
opacity=0.3,
fillopacity=0.9,
fillcolor='cccccc')
self.__arrow = avg.PolygonNode(parent=self,
fillopacity=0.8,
opacity=0)
player.setTimeout(500,lambda :self.highlight(False))
ps = []
ps += getArc(-w,0, "lb")
ps += getArc(-w,-h, "lt")
ps += getArc(-20-21,-h-21, "rb")[::-1]
ps += getArc(-20,-h-60, "lt")
ps += getArc(+20,-h-60, "rt")
ps += getArc(+20+21,-h-21, "lb")[::-1]
ps += getArc(w,-h, "rt")
ps += getArc(+w,0, "rb")
ps.append(ps[0])
self.__outline.pos = ps
self.__arrow.pos = map(lambda x: P(0,-h-60)+x,
[[14, 14], [0, 0], [-14, 14],
[-10, 18], [-3, 11], [-3, 30],
[3, 30], [3, 11], [10, 18], [14, 14]])
def nextKey(self):
if not self.keys:
player.stop()
else:
key = self.keys.pop()
self.singleKeyPress(key)
player.setTimeout(0, self.nextKey)
def nextKey(self):
if not self.keys:
player.stop()
else:
key = self.keys.pop()
self.singleKeyPress(key)
player.setTimeout(0, self.nextKey)
def testBitmapManager(self):
WAIT_TIMEOUT = 2000
def expectException(returnValue, nextAction):
if isinstance(returnValue, Exception):
nextAction()
else:
raise RuntimeError("Expected exception, got %s (%s)" % (
returnValue, type(returnValue)))
def loadValidBitmap():
def validBitmapCb(bitmap):
self.assert_(not isinstance(bitmap, Exception))
player.setTimeout(0, loadBitmapWithPixelFormat)
avg.BitmapManager.get().loadBitmap("media/rgb24alpha-64x64.png",
validBitmapCb)
def loadBitmapWithPixelFormat():
def validBitmapCb(bitmap):
self.assert_(not isinstance(bitmap, Exception))
self.assert_(bitmap.getFormat() == avg.B5G6R5)
player.setTimeout(0, loadUnexistentBitmap)
avg.BitmapManager.get().loadBitmap("media/rgb24alpha-64x64.png",
validBitmapCb, avg.B5G6R5)
def loadUnexistentBitmap():
avg.BitmapManager.get().loadBitmap("nonexistent.png",
lambda bmp: expectException(
returnValue=bmp,
nextAction=lambda: player.setTimeout(0, loadBrokenBitmap)))
def loadBrokenBitmap():
import tempfile
tempFileName = os.path.join(tempfile.gettempdir(),
"broken.png")
open(tempFileName, "w")
def cleanupAndTestReturnValue(returnValue):
os.unlink(tempFileName)
expectException(returnValue=returnValue, nextAction=player.stop)
avg.BitmapManager.get().loadBitmap(tempFileName,
cleanupAndTestReturnValue)
def reportStuck():
raise RuntimeError("BitmapManager didn't reply "
"within %dms timeout" % WAIT_TIMEOUT)
player.stop()
for multithread in [False, True]:
self.loadEmptyScene()
if multithread:
avg.BitmapManager.get().setNumThreads(2)
player.setTimeout(WAIT_TIMEOUT, reportStuck)
player.setResolution(0, 0, 0, 0)
loadValidBitmap()
player.play()
avg.BitmapManager.get().setNumThreads(1)
def __addResultRow(self):
row = self.rows[0]
self.rows.remove(row)
self.__resultsParagraph.text += row + '<br/>'
if self.rows:
player.setTimeout(consts.RESULTS_ADDROW_DELAY, self.__addResultRow)
else:
player.setTimeout(consts.RESULTS_DELAY, self.returnToGame)
def _postTransIn(self):
db = app.instance.mainDiv.scoreDatabase
if not db.isFull() or db.data[-1].points < \
self.sequencer.getState('game').getScore():
player.setTimeout(consts.GAMEOVER_DELAY / 2,
lambda: self.sequencer.changeState('hiscore'))
else:
player.setTimeout(consts.GAMEOVER_DELAY,
lambda: self.sequencer.changeState('start'))
def onButtonPressed(self):
if not (self.isFading):
if self.runningVideo == 0:
avg.fadeIn(self.videoNodes[1], self.__duration)
else:
avg.fadeOut(self.videoNodes[1], self.__duration)
player.setTimeout(self.__duration, self.fadeEnd)
self.runningVideo = (self.runningVideo + 1) % 2
self.isFading = True
def onButtonPressed(self):
if not (self.isFading):
if self.runningVideo == 0:
avg.Anim.fadeIn(self.videoNodes[1], self.__duration)
else:
avg.Anim.fadeOut(self.videoNodes[1], self.__duration)
player.setTimeout(self.__duration, self.fadeEnd)
self.runningVideo = (self.runningVideo + 1) % 2
self.isFading = True
def testError(self):
self.initDefaultImageScene()
player.setTimeout(1, lambda: undefinedFunction)
player.setTimeout(50, player.stop)
try:
player.play()
except NameError:
self.assert_(1)
else:
self.assert_(0)
def testError(self):
self.initDefaultImageScene()
player.setTimeout(1, lambda: undefinedFunction)
player.setTimeout(50, player.stop)
try:
player.play()
except NameError:
self.assert_(1)
else:
self.assert_(0)
def _onUp(self, event):
def gone(self):
BaseTouchVisualization._onUp(self, event)
self.unlink(True)
del self
avg.fadeIn(self.__circle, 100, 1)
avg.LinearAnim(self.__circle, "size", 100, self.__circle.size, (4,4)).start()
avg.LinearAnim(self.__circle, "pos", 100, self.__circle.pos, (-2,-2)).start()
player.setTimeout(100, lambda: gone(self))
def _onUp(self, event):
def gone(self):
BaseTouchVisualization._onUp(self, event)
self.unlink(True)
del self
avg.fadeIn(self.__circle, 100, 1)
avg.LinearAnim(self.__circle, "size", 100, self.__circle.size, (4,4)).start()
avg.LinearAnim(self.__circle, "pos", 100, self.__circle.pos, (-2,-2)).start()
player.setTimeout(100, lambda: gone(self))
def __on_cursor_down(self, event):
"""
:type event: CursorEvent
"""
event.node.sensitive = False
event.node.fillcolor = "046d0e"
self.__touch_count += 1
if self.__touch_count >= 12:
player.setTimeout(
1,
(lambda: self.dispatch(self.__ALL_NODES_CLICKED, sender=self)))
def onInit(self):
self.curFrame = 0
avg.logger.info("Creating camera:")
avg.logger.info("driver=%(driver)s device=%(device)s" % self.optdict)
avg.logger.info(
"width=%(width)d height=%(height)d pixelformat=%(pixelFormat)s" %
self.optdict)
avg.logger.info(
"unit=%(unit)d framerate=%(framerate)d fw800=%(fw800)s" %
self.optdict)
self.canvas = player.createCanvas(id="canvas", size=self.size)
self.camNode = avg.CameraNode(driver=self.optdict["driver"],
device=self.optdict["device"],
unit=self.optdict["unit"],
fw800=self.optdict["fw800"],
framerate=self.optdict["framerate"],
capturewidth=self.optdict["width"],
captureheight=self.optdict["height"],
pixelformat=self.optdict["pixelFormat"],
parent=self.canvas.getRootNode())
if not self.optdict["noinfo"]:
self.infoText = (
"Driver=%(driver)s (dev=%(device)s unit=%(unit)d) "
"%(width)dx%(height)d@%(framerate)f" % self.optdict)
avg.WordsNode(text=self.infoText,
color="ff3333",
pos=(5, 5),
fontsize=14,
rawtextmode=True,
parent=self.canvas.getRootNode())
self.frameText = avg.WordsNode(color="ff3333",
pos=(5, 25),
fontsize=14,
parent=self.canvas.getRootNode())
else:
self.frameText = None
self.canvasImage = avg.ImageNode(href="canvas:canvas",
size=self.size,
parent=self)
if self.capture:
self.videoWriter = avg.VideoWriter(self.canvas, "camera.mov", 60,
3, 5, True)
self.setupKeys()
self.camNode.play()
player.setTimeout(100, self.checkCamera)
def isOffscreenSupported():
def testOffscreenSupported():
global offscreenSupported
offscreenSupported = avg.OffscreenCanvas.isSupported()
player.stop()
global offscreenSupported
sceneString = """<avg id="avg" width="160" height="120"/>"""
player.loadString(sceneString)
player.setTimeout(0, testOffscreenSupported)
player.play()
return offscreenSupported
def _startApp(self, appClass):
self._onBeforePlay()
player.setTimeout(0, self._onStart)
self._appInstance = appClass(self._appNode)
g_KbManager.setup(self._appInstance.onKeyDown,
self._appInstance.onKeyUp)
self._setupDefaultKeys()
self._appInstance.setStarter(self)
player.play()
self._appInstance.exit()
g_KbManager.teardown()
def __dumpConfig(self):
player.enableGLErrorChecks(True)
avg.logger.pushCategories()
avg.logger.setCategories(avg.logger.APP | avg.logger.CONFIG |
avg.logger.DEPRECATION)
player.loadString("""
<avg id="avg" width="160" height="120">
</avg>
""")
player.setTimeout(0, player.stop)
player.setFramerate(10000)
player.play()
avg.logger.popCategories()
def isOffscreenSupported():
def testOffscreenSupported():
global offscreenSupported
offscreenSupported = avg.OffscreenCanvas.isSupported()
player.stop()
global offscreenSupported
sceneString = """<avg id="avg" width="160" height="120"/>"""
player.loadString(sceneString)
player.setTimeout(0, testOffscreenSupported)
player.play()
return offscreenSupported
def __on_all_test_nodes_clicked(self, sender):
"""
Called when all nodes in the test touch view were touched.
:type sender: TouchTestView
"""
if not self.__touch_test_view:
return
self.__touch_test_view.active = False
if sender is not None:
StudyLog.get_instance().write_event_log(
'The touch test view was successfully passed.')
player.setTimeout(1, lambda: self.__draw_main_view())
def _startApp(self, appClass):
self._onBeforePlay()
player.setTimeout(0, self._onStart)
self._appInstance = appClass(self._appNode)
g_KbManager.setup(
self._appInstance.onKeyDown,
self._appInstance.onKeyUp)
self._setupDefaultKeys()
self._appInstance.setStarter(self)
player.play()
self._appInstance.exit()
g_KbManager.teardown()
def __dumpConfig(self):
player.enableGLErrorChecks(True)
cats = avg.logger.getCategories()
for cat in [avg.logger.Category.APP, avg.logger.Category.CONFIG,
avg.logger.Category.DEPREC]:
avg.logger.configureCategory(cat, avg.logger.Severity.INFO)
player.loadString("""
<avg id="avg" width="160" height="120">
</avg>
""")
player.setTimeout(0, player.stop)
player.setFramerate(10000)
player.play()
for cat, severity in cats.iteritems():
avg.logger.configureCategory(cat, severity)
def __stop(self, forceClearWins=False):
def restart():
for p in self.__activePlayers:
p.setDead(False)
avg.fadeIn(self.__winsDiv, 200)
self.__winsDiv.sensitive = True
self.__activateIdleTimer()
if forceClearWins:
self.__clearButton.activate()
else:
self.__preStart()
player.unsubscribe(player.ON_FRAME, self.__onGameFrame)
self.__shield.deactivate()
self.__blocker.deactivate()
player.setTimeout(2000, restart)
def setNotification(self, text, timeout=0):
player.getElementByID('cal_notification').text = text
if timeout:
if self.__notificationTimer is not None:
player.clearInterval(self.__notificationTimer)
self.__notificationTimer = player.setTimeout(timeout,
self.__clearNotification)
def setDead(self, restart=False):
if self.__isRunning:
super(IdlePlayer, self)._setDead(restart)
self.__isRunning = False
elif not self.__respawnTimoutID is None:
player.clearInterval(self.__respawnTimoutID)
if restart:
self.__respawnTimoutID = player.setTimeout(randint(600, 1200), self.setReady)
def __dumpConfig(self):
player.enableGLErrorChecks(True)
cats = avg.logger.getCategories()
for cat in [
avg.logger.Category.APP, avg.logger.Category.CONFIG,
avg.logger.Category.DEPREC
]:
avg.logger.configureCategory(cat, avg.logger.Severity.INFO)
player.loadString("""
<avg id="avg" width="160" height="120">
</avg>
""")
player.setTimeout(0, player.stop)
player.setFramerate(10000)
player.play()
for cat, severity in cats.iteritems():
avg.logger.configureCategory(cat, severity)
def __resetTimeout(self):
def fire():
self.__timeout = None
self.__saveScore()
self.sequencer.changeState('start')
self.__clearTimeout()
self.__timeout = player.setTimeout(self.TIMEOUT, fire)
def setNotification(self, text, timeout=0):
player.getElementByID('cal_notification').text = text
if timeout:
if self.__notificationTimer is not None:
player.clearInterval(self.__notificationTimer)
self.__notificationTimer = player.setTimeout(timeout,
self.__clearNotification)
def testEOF(self, node):
def onEOF():
player.stop()
def onNoEOF():
self.fail("No EOF")
def onSubscribeEOF():
self.eofCalled = True
self.eofCalled = False
root = self.loadEmptyScene()
root.appendChild(node)
node.play()
node.setEOFCallback(onEOF)
node.subscribe(avg.Node.END_OF_FILE, onSubscribeEOF)
player.setTimeout(100000, onNoEOF)
player.play()
self.assert_(self.eofCalled)
def testEOF(self, node):
def onEOF():
player.stop()
def onNoEOF():
self.fail("No EOF")
def onSubscribeEOF():
self.eofCalled = True
self.eofCalled = False
root = self.loadEmptyScene()
root.appendChild(node)
node.play()
node.setEOFCallback(onEOF)
node.subscribe(avg.Node.END_OF_FILE, onSubscribeEOF)
player.setTimeout(100000, onNoEOF)
player.play()
self.assert_(self.eofCalled)
def testVideoSeekAfterEOF(self):
def onEOF():
node.seekToTime(0)
player.subscribe(avg.Player.ON_FRAME, onFrame)
def onFrame():
if node.getCurTime() < 100:
self.compareImage("testSeekAfterEOF")
player.stop()
def onNoEOF():
self.fail("No EOF")
player.setFakeFPS(25)
root = self.loadEmptyScene()
node = avg.VideoNode(href="mpeg1-48x48.mov", parent=root)
node.play()
node.subscribe(avg.VideoNode.END_OF_FILE, onEOF)
player.setTimeout(100000, onNoEOF)
player.play()
def testVideoSeekAfterEOF(self):
def onEOF():
node.seekToTime(0)
player.subscribe(avg.Player.ON_FRAME, onFrame)
def onFrame():
if node.getCurTime() < 100:
self.compareImage("testSeekAfterEOF")
player.stop()
def onNoEOF():
self.fail("No EOF")
player.setFakeFPS(25)
root = self.loadEmptyScene()
node = avg.VideoNode(href="mpeg1-48x48.mov", parent=root)
node.play()
node.subscribe(avg.VideoNode.END_OF_FILE, onEOF)
player.setTimeout(100000, onNoEOF)
player.play()
def __screenshot(self):
fnum = 0
fnameTemplate = 'screenshot-%03d.png'
while os.path.exists(fnameTemplate % fnum):
fnum += 1
try:
player.screenshot().save('screenshot-%03d.png' % fnum)
except RuntimeError:
text = 'Cannot save snapshot file'
else:
text = 'Screenshot saved as ' + fnameTemplate % fnum
self.__killNotifyNode()
self.__notifyNode = avg.WordsNode(
text=text, x=player.getRootNode().width - 50,
y=player.getRootNode().height - 50, alignment='right', fontsize=20,
sensitive=False, parent=player.getRootNode())
player.setTimeout(2000, self.__killNotifyNode)
def __screenshot(self):
fnum = 0
fnameTemplate = 'screenshot-%03d.png'
while os.path.exists(fnameTemplate % fnum):
fnum += 1
try:
player.screenshot().save('screenshot-%03d.png' % fnum)
except RuntimeError:
text = 'Cannot save snapshot file'
else:
text = 'Screenshot saved as ' + fnameTemplate % fnum
self.__killNotifyNode()
self.__notifyNode = avg.WordsNode(
text=text, x=player.getRootNode().width - 50,
y=player.getRootNode().height - 50, alignment='right', fontsize=20,
sensitive=False, parent=player.getRootNode())
player.setTimeout(2000, self.__killNotifyNode)
def _leave(self):
#unbind all calibrator keys - bind old keys
g_KbManager.pop()
def hideMainNode():
self.mainNode.opacity=0
self.mainNode.active = False
self.appStarter.hideTrackerImage()
#grandparent = self.parentNode.getParent()
#if grandparent:
# grandparent.reorderChild(grandparent.indexOf(self.parentNode), 0)
self.hideMainNodeTimeout = player.setTimeout(400, hideMainNode)
player.clearInterval(self.__onFrameID)
def _leave(self):
#unbind all calibrator keys - bind old keys
g_KbManager.pop()
def hideMainNode():
self.mainNode.opacity=0
self.mainNode.active = False
self.appStarter.hideTrackerImage()
#grandparent = self.parentNode.getParent()
#if grandparent:
# grandparent.reorderChild(grandparent.indexOf(self.parentNode), 0)
self.hideMainNodeTimeout = player.setTimeout(400, hideMainNode)
player.clearInterval(self.__onFrameID)
def onInit(self):
self.curFrame = 0
avg.logger.info("Creating camera:")
avg.logger.info("driver=%(driver)s device=%(device)s" %self.optdict)
avg.logger.info(
"width=%(width)d height=%(height)d pixelformat=%(pixelFormat)s"
%self.optdict)
avg.logger.info("unit=%(unit)d framerate=%(framerate)d fw800=%(fw800)s"
%self.optdict)
self.canvas = player.createCanvas(id="canvas", size=self.size)
self.camNode = avg.CameraNode(driver=self.optdict["driver"],
device=self.optdict["device"], unit=self.optdict["unit"],
fw800=self.optdict["fw800"], framerate=self.optdict["framerate"],
capturewidth=self.optdict["width"], captureheight=self.optdict["height"],
pixelformat=self.optdict["pixelFormat"], parent=self.canvas.getRootNode())
if not self.optdict["noinfo"]:
self.infoText = ("Driver=%(driver)s (dev=%(device)s unit=%(unit)d) "
"%(width)dx%(height)d@%(framerate)f" %self.optdict)
avg.WordsNode(text=self.infoText, color="ff3333", pos=(5,5), fontsize=14,
rawtextmode=True, parent=self.canvas.getRootNode())
self.frameText = avg.WordsNode(color="ff3333", pos=(5,25), fontsize=14,
parent=self.canvas.getRootNode())
else:
self.frameText = None
self.canvasImage = avg.ImageNode(href="canvas:canvas", size=self.size,
parent=self)
if self.capture:
self.videoWriter = avg.VideoWriter(self.canvas, "camera.mov", 60, 3, 5, True)
self.setupKeys()
self.camNode.play()
player.setTimeout(100, self.checkCamera)
def testTimeoutOnFrameHandling(self):
def onTimeOut():
self.callCount += 1
def onFrame():
player.clearInterval(self.longTimeoutId)
self.longTimeoutId = None
player.setTimeout(0, onTimeOut)
player.unsubscribe(player.ON_FRAME, self.onFrameID)
self.initDefaultImageScene()
self.callCount = 0
# long running dummy timeout. Will be removed before the timer elapses.
self.longTimeoutId = player.setTimeout(10000, lambda: None)
self.onFrameID = player.subscribe(player.ON_FRAME, onFrame)
self.start(False, (None, None, None, lambda: self.assert_(self.callCount == 1)))
def testTimeoutOnFrameHandling(self):
def onTimeOut():
self.callCount += 1
def onFrame():
player.clearInterval(self.longTimeoutId)
self.longTimeoutId = None
player.setTimeout(0, onTimeOut)
player.unsubscribe(player.ON_FRAME, self.onFrameID)
self.initDefaultImageScene()
self.callCount = 0
# long running dummy timeout. Will be removed before the timer elapses.
self.longTimeoutId = player.setTimeout(10000, lambda: None)
self.onFrameID = player.subscribe(player.ON_FRAME, onFrame)
self.start(False, (
None,
None,
None,
lambda: self.assert_(self.callCount == 1),
))
def delay(self, time):
def timeout():
self.__delaying = False
self.__delaying = True
player.setTimeout(time, timeout)
def requestStop(self, timeout=0):
player.setTimeout(timeout, player.stop)
def deferredRefresh(self):
player.setTimeout(1500, self.__deferredRefreshCB)
self.setNotification('Please wait for settlement')
g_KbManager.push()
player.getElementByID('cal_params').opacity = 0.3
def __detectedHandler(self):
event = player.getCurrentEvent()
self.__updateCursorPosition(event)
self.__timerID = player.setTimeout(1000, self.__addLoupe)
def threadFunc():
player.setTimeout(0, onAsyncCall)
def __detectedHandler(self):
event = player.getCurrentEvent()
self.__updateCursorPosition(event)
self.__timerID = player.setTimeout(1000, self.__addLoupe)
def onFrame():
player.clearInterval(self.longTimeoutId)
self.longTimeoutId = None
player.setTimeout(0, onTimeOut)
player.unsubscribe(player.ON_FRAME, self.onFrameID)
def setupTimeouts():
self.timeout1ID = player.setTimeout(0, timeout1)
self.timeout2ID = player.setTimeout(1, timeout2)
self.intervalID = player.setOnFrameHandler(onFrame)
def loadUnexistentBitmap():
bitmapManager.loadBitmap(
"nonexistent.png", lambda bmp: expectException(
returnValue=bmp,
nextAction=lambda: player.setTimeout(0, loadBrokenBitmap)))
def init(self):
self.keys = TOGGLE_KEYS[:]
player.setTimeout(0, self.nextKey)
def validBitmapCb(bitmap):
self.assert_(not isinstance(bitmap, Exception))
self.assert_(bitmap.getFormat() == avg.B5G6R5)
player.setTimeout(0, loadUnexistentBitmap)
def validBitmapCb(bitmap):
self.assert_(not isinstance(bitmap, Exception))
player.setTimeout(0, loadBitmapWithPixelFormat)
def onLoop(self):
self.loadURL(self.url)
if not self.stopLoop:
player.setTimeout(1000, self.onLoop)
def init(self):
player.setTimeout(0, player.stop)
def loadUnexistentBitmap():
avg.BitmapManager.get().loadBitmap("nonexistent.png",
lambda bmp: expectException(
returnValue=bmp,
nextAction=lambda: player.setTimeout(0, loadBrokenBitmap)))
def __teaserTimer(self):
player.setTimeout(1000, lambda: avg.fadeOut(self.__teaser, 3000))
def deferredRefresh(self):
player.setTimeout(1500, self.__deferredRefreshCB)
self.setNotification('Please wait for settlement')
g_KbManager.push()
player.getElementByID('cal_params').opacity = 0.3
def validBitmapCb(bitmap):
self.assert_(not isinstance(bitmap, Exception))
player.setTimeout(0, loadBitmapWithPixelFormat)
def validBitmapCb(bitmap):
self.assert_(not isinstance(bitmap, Exception))
self.assert_(bitmap.getFormat() == avg.B5G6R5)
player.setTimeout(0, loadUnexistentBitmap)
def setupTimeouts():
self.timeout1ID = player.setTimeout(0, timeout1)
self.timeout2ID = player.setTimeout(1, timeout2)
self.intervalID = player.setOnFrameHandler(onFrame)
def initException():
self.timeout3ID = player.setTimeout(0, throwException)
