def testKeyEvents(self): def onKeyDown(event): if event.keystring == 'A' and event.keycode == 65 and event.unicode == 65: self.keyDownCalled = True def onKeyUp(event): if event.keystring == 'A' and event.keycode == 65 and event.unicode == 65: self.keyUpCalled = True def onSubscribeKeyDown(event): self.subscribeKeyDownCalled = True def onSubscribeKeyUp(event): self.subscribeKeyUpCalled = True root = self.loadEmptyScene() root.setEventHandler(avg.Event.KEY_DOWN, avg.Event.NONE, onKeyDown) root.setEventHandler(avg.Event.KEY_UP, avg.Event.NONE, onKeyUp) player.subscribe(avg.Player.KEY_DOWN, onSubscribeKeyDown) player.subscribe(avg.Player.KEY_UP, onSubscribeKeyUp) self.start(False, (lambda: Helper.fakeKeyEvent(avg.Event.KEY_DOWN, 65, 65, "A", 65, avg.KEYMOD_NONE), lambda: self.assert_(self.keyDownCalled and self.subscribeKeyDownCalled), lambda: Helper.fakeKeyEvent(avg.Event.KEY_UP, 65, 65, "A", 65, avg.KEYMOD_NONE), lambda: self.assert_(self.keyUpCalled and self.subscribeKeyUpCalled) ))
def onInit(self): self.mediadir = getMediaDir(__file__) self.game = None self.text_size = 20 self.text_line = Point2D(0, self.text_size) self.margin = Point2D(20, 20) self.background = create_node(self, 'rect', size=self.size, fillcolor='000000', fillopacity=1) self.game_node = create_node(self, 'div', pos=self.margin + self.text_line/2, size=self.size - self.margin*2 - self.text_line/2) self.create_button( self, self.show_about_box, 'About', 1, self.margin - self.text_line/2, 'left') exit_button_pos = avg.Point2D(self.size.x/2, self.margin.y-self.text_line.y/2) self.create_button(self, self.__stop, 'Exit', 1, exit_button_pos, 'center') self.level_button_nodes = [] self.game_over_box = self.create_game_over_box() self.about_box = self.create_about_box() player.subscribe(player.KEY_DOWN, self.__onKeyDown) self.start_game()
def goGreen(): self.__greenSound.play() self.__countdownNode.fillcolor = '00FF00' avg.LinearAnim(self.__countdownNode, 'fillopacity', 1000, 1, 0).start() for c in self.__controllers: c.start() player.subscribe(player.ON_FRAME, self.__onGameFrame)
def testPublisher(self): def onDown(event): self.assert_(event.type == avg.Event.CURSOR_DOWN) curEvent = player.getCurrentEvent() self.assert_(curEvent.type == avg.Event.CURSOR_DOWN) self.assert_(curEvent.when == event.when) self.downCalled = True def unsubscribe(): self.assert_(self.img.isSubscribed(avg.Node.CURSOR_DOWN, onDown)) self.img.unsubscribe(avg.Node.CURSOR_DOWN, onDown) self.assert_(not(self.img.isSubscribed(avg.Node.CURSOR_DOWN, onDown))) self.assert_(self.img.getNumSubscribers(avg.Node.CURSOR_DOWN) == 0) self.downCalled = False self.assertException( lambda: self.img.unsubscribe(avg.Node.CURSOR_DOWN, onDown)) def initUnsubscribeInEvent(useMessageID): self.subscriberID = self.img.subscribe(avg.Node.CURSOR_DOWN, lambda event: onDownUnsubscribe(event, useMessageID)) def onDownUnsubscribe(event, useMessageID): if useMessageID: self.img.unsubscribe(avg.Node.CURSOR_DOWN, self.subscriberID) self.assertException(lambda: self.img.unsubscribe(avg.Node.CURSOR_DOWN, self.subscriberID)) else: self.img.unsubscribe(self.subscriberID) self.assertException(lambda: self.img.unsubscribe(self.subscriberID)) self.downCalled = True def onFrame(): self.onFrameCalled = True self.downCalled = False self.onFrameCalled = False root = self.loadEmptyScene() player.subscribe(player.ON_FRAME, onFrame) self.img = avg.ImageNode(pos=(0,0), href="rgb24-65x65.png", parent=root) self.img.subscribe(avg.Node.CURSOR_DOWN, onDown) self.assertException(lambda: self.img.subscribe(23, onDown)) self.assertException(lambda: self.img.unsubscribe(avg.Node.CURSOR_DOWN, 23)) self.start(False, (lambda: self.fakeClick(10,10), lambda: self.assert_(self.downCalled), lambda: self.assert_(self.onFrameCalled), unsubscribe, lambda: self.fakeClick(10,10), lambda: self.assert_(not(self.downCalled)), lambda: initUnsubscribeInEvent(True), lambda: self.fakeClick(10,10), lambda: self.assert_(self.downCalled), lambda: initUnsubscribeInEvent(False), lambda: self.fakeClick(10,10), lambda: self.assert_(self.downCalled), ))
def testLoop(self): def onEOF(): self.eof = True def onFrame(): if self.eof: if not threaded: self.compareImage("testVideoLoop") player.stop() for audio, threaded in [(False, False), (False, True), (True, True)]: self.eof = False if audio: player.setFakeFPS(-1) else: player.setFakeFPS(25) root = self.loadEmptyScene() if audio: node = avg.SoundNode(parent=root, loop=True, href="48kHz_16bit_mono.wav") else: node = avg.VideoNode(parent=root, loop=True, fps=25, size=(96,96), threaded=threaded, href="mpeg1-48x48.mov") node.subscribe(avg.Node.END_OF_FILE, onEOF) node.play() player.subscribe(player.ON_FRAME, onFrame) player.play()
def onInit(self): self.mediadir = getMediaDir(__file__) self.__gameMusic = avg.SoundNode(href='Fire_Birds.mp3', loop=True, volume=0.75, parent=self) self.__scrollingBg = ScrollingBackground(self) self.__shadowDiv = avg.DivNode(parent=self) self.__gameDiv = avg.DivNode(size=self.size, parent=self) self.__guiDiv = avg.DivNode(parent=self) bg = avg.ImageNode(href='gui_frame.png', parent=self.__guiDiv) self.__guiDiv.pos = (0, self.height - bg.height) self.__lifeCounter = LifeCounter(pos=(8, 12), parent=self.__guiDiv) gunCtrl = GunControl(pos=(300, 54), parent=self.__guiDiv) self.__scoreCounter = ScoreCounter(pos=(1142, 54), parent=self.__guiDiv) self.__enemies = [] for i in xrange(2): self.__createEnemy() self.__player = PlayerAircraft(self.__shadowDiv, gunCtrl, parent=self.__gameDiv) enemyMask = avg.Bitmap(self.mediadir + '/enemy.gif') self.__playerCollisionDetector = collisiondetector.CollisionDetector( enemyMask, avg.Bitmap(self.mediadir + '/spitfire.gif')) self.__bulletCollisionDetector = collisiondetector.CollisionDetector( enemyMask, avg.Bitmap(self.mediadir + '/bullet.gif')) self.__keyStates = dict.fromkeys(PlayerAircraft.ACTION_KEYS, False) self.__frameHandlerId = None self.__spawnTimeoutId = None self.__gameMusic.play() self.__start() player.subscribe(player.KEY_DOWN, self.__onKeyDown) player.subscribe(player.KEY_UP, self.__onKeyUp)
def setup(self, onKeyDownCb, onKeyUpCb): player.subscribe(avg.Player.KEY_DOWN, self.__onKeyDown) player.subscribe(avg.Player.KEY_UP, self.__onKeyUp) self.__onKeyDownCb = onKeyDownCb self.__onKeyUpCb = onKeyUpCb self.__keyCaptionsNode = KeysCaptionNode(pos=(5,5), parent=player.getRootNode())
def _initNodes(self): self._setSizeFromBmp(self._bmp) self._positionNodes(self.size) if player.isPlaying(): self._renderImages() else: player.subscribe(avg.Player.PLAYBACK_START, self._renderImages)
def __startIdleDemo(self): self.__idleTimeoutID = None avg.fadeOut(self.__gameDiv, 200) self.__ctrlDiv.sensitive = False for p in self.__idlePlayers: p.setReady() self.__demoDownHandlerID = self.__gameDiv.subscribe(avg.Node.CURSOR_DOWN, lambda e:self.__stopIdleDemo()) player.subscribe(player.ON_FRAME, self.__onIdleFrame)
def init(self): self.node = avg.VideoNode(href=args[0], loop=True, accelerated=not (options.disableAccel)) self.node.play() if self.node.hasAlpha(): self.__makeAlphaBackground() self._parentNode.appendChild(self.node) self.curFrameWords = avg.WordsNode(parent=self._parentNode, pos=(10, 10), fontsize=10) self.curTimeWords = avg.WordsNode(parent=self._parentNode, pos=(10, 22), fontsize=10) self.framesQueuedWords = avg.WordsNode(parent=self._parentNode, pos=(10, 34), fontsize=10) player.subscribe(player.ON_FRAME, self.onFrame)
def testRun(self, onFrameHandlersList=[], mainDiv=None, runtimeOptions={}): assert type(onFrameHandlersList) == list self.__onFrameHandlersList = onFrameHandlersList player.subscribe(player.ON_FRAME, self.__onFrame) player.setFramerate(10000) player.assumePixelsPerMM(1) for k, v in self.CUSTOM_SETTINGS.iteritems(): self.settings.set(k, v) if mainDiv is None: mainDiv = libavg.app.MainDiv() self.run(mainDiv, **runtimeOptions)
def start(self, warnOnImageDiff, actions): self.__setupPlayer() self.__dumpTestFrames = (os.getenv("AVG_DUMP_TEST_FRAMES") is not None) self.__delaying = False self.__warnOnImageDiff = warnOnImageDiff self.assert_(player.isPlaying() == 0) self.actions = flatten(actions) self.curFrame = 0 player.subscribe(player.ON_FRAME, self.__nextAction) player.setFramerate(10000) player.assumePixelsPerMM(1) player.play() self.assert_(player.isPlaying() == 0)
def init(self): ''' Create placeholders for the example. A single ImageNode is used to show the pictures. ''' self.__imageNode = libavg.avg.ImageNode(pos=(10, 20), parent=self._parentNode) self.__spinner = libavg.avg.RectNode(color='222222', fillopacity=1, size=(40, 40), active=False, pos=(10, self._parentNode.size.y - 50), parent=self._parentNode) self.__infoNode = libavg.avg.WordsNode(text='Press space to load the first image', fontsize=11, pos=(10, 5), parent=self._parentNode) self.__pics = sys.argv[1:] self.__currentPic = -1 player.subscribe(player.ON_FRAME, self.__onFrame)
def _setup(self): self.__frameHandlerID = player.subscribe(avg.Player.ON_FRAME, self._nextFrameTimeSample) self._numSamples = 0 self._lastCurUsage = 0 self._maxFrameTime = 0 self._values = []
def onInit(self): ''' Create placeholders for the example. A single ImageNode is used to show the pictures. ''' self.__imageNode = avg.ImageNode(pos=(10, 20), parent=self) self.__spinner = avg.RectNode(color='222222', fillopacity=1, size=(40, 40), active=False, pos=(10, self.size.y - 50), parent=self) self.__infoNode = avg.WordsNode(text='Press space to load the first image', fontsize=11, pos=(10, 5), parent=self) self.__pics = sys.argv[1:] self.__currentPic = -1 player.subscribe(player.ON_FRAME, self.__onFrame) app.keyboardmanager.bindKeyDown(keyname="Space", handler=self.__requestNextBitmap, help="Request next bitmap")
def _enter(self): g_KbManager.push() g_KbManager.bindKey('d', self.__trackerSetDebugImages, 'tracker set debug images') g_KbManager.bindKey('b', self.__bigCamImage, 'big cam image') g_KbManager.bindKey('up', self.__keyFuncUP, 'select parameter up') g_KbManager.bindKey('down', self.__keyFuncDOWN, 'select parameter down') g_KbManager.bindKey('left', self.__keyFuncLEFT, 'value up') g_KbManager.bindKey('right', self.__keyFuncRIGHT, 'value down') g_KbManager.bindKey('page up', self.__keyFuncPAGEUp, 'value up * 10') g_KbManager.bindKey('page down', self.__keyFuncPAGEDown, 'value down * 10') g_KbManager.bindKey('s', self.__trackerSaveConfig, 'save configuration') g_KbManager.bindKey('g', self.__toggleGUI, 'toggle GUI') g_KbManager.bindKey('c', self.__startCoordCalibration, 'start geometry calibration') g_KbManager.bindKey('w', self.__saveTrackerIMG, 'SAVE trager image') g_KbManager.bindKey('h', self.appStarter.tracker.resetHistory, 'RESET history') self.appStarter.showTrackerImage() self.mainNode.active=True self.tracker.setDebugImages(True, True) avg.fadeIn(self.mainNode, 400, 1) Bitmap = self.tracker.getImage(avg.IMG_DISTORTED) # Why is this needed? self.__onFrameID = player.subscribe(player.ON_FRAME, self.__onFrame) #grandparent = self.parentNode.getParent() #if grandparent: # grandparent.reorderChild(grandparent.indexOf(self.parentNode), grandparent.getNumChildren()-1) self.displayParams() if self.hideMainNodeTimeout: player.clearInterval(self.hideMainNodeTimeout)
def __start(self): assert(not self.__frameHandlerId and not self.__spawnTimeoutId) self.__lifeCounter.reset() self.__scoreCounter.reset() self.__player.reset() self.__frameHandlerId = player.subscribe(player.ON_FRAME, self.__onFrame) self.__spawnTimeoutId = player.setInterval(self.ENEMY_SPAWN_TIMEOUT, self.__spawnEnemy)
def showTrackerImage(self): if self.__showTrackerImage: return self.__showTrackerImage = True self.__updateTrackerImageInterval = \ player.subscribe(player.ON_FRAME, self.__updateTrackerImage) self.__trackerImageNode.opacity = 1 self.tracker.setDebugImages(False, True)
def onInit(self): self.__setupMultitouch() avg.WordsNode.addFontDir(libavg.utils.getMediaDir(__file__, 'fonts')) self.mediadir = libavg.utils.getMediaDir(__file__) self.__elapsedTime = 0 self.__pointer = None self.sequencer = Sequencer(self) norm.setSize(self.size) self.createGame() player.subscribe(player.KEY_DOWN, self.sequencer.propagateKeyDown) player.subscribe(player.KEY_UP, self.sequencer.propagateKeyUp) self.subscribe(self.CURSOR_DOWN, self.onCursorDown) self.subscribe(self.CURSOR_MOTION, self.onCursorMotion)
def __init__(self, friction, moveHandler, stopHandler): self.__friction = friction self.__moveHandler = moveHandler self.__stopHandler = stopHandler self.__transVel = avg.Point2D(0, 0) self.__curPivot = avg.Point2D(0, 0) self.__angVel = 0 self.__sizeVel = avg.Point2D(0, 0) self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onDragFrame)
def __onDown(self, event): if self.__contact is None: self.__contact = event.contact event.contact.subscribe(avg.Contact.CURSOR_UP, self.__onUp) self.__rawContactCircle.opacity = 1 self.__filteredContactCircle.opacity = 1 self.__filters = [ filter.OneEuroFilter(self.__minCutoff,self.__cutoffSlope), filter.OneEuroFilter(self.__minCutoff,self.__cutoffSlope)] self.__onFrame = player.subscribe(player.ON_FRAME, self.__moveContact)
def __init__(self, src, endsExtent, orientation=Orientation.HORIZONTAL, minExtent=-1, parent=None, **kwargs): super(AccordionNode, self).__init__(**kwargs) self.registerInstance(self, parent) if endsExtent < 0: raise RuntimeError( "Illegal value for endsExtent: %i. Must be >= 0"%endsExtent) elif endsExtent == 0: # 1 has same effect as 0 - we just create one-pixel wide start and end images. endsExtent = 1 self.__bmp = avg.Bitmap(src) self._orientation = orientation # XXX: Check if bmp is smaller than min size self.__startImg = self.__createImageNode(self.__bmp, endsExtent) self.__centerImg = self.__createImageNode(self.__bmp, 1) self.__endImg = self.__createImageNode(self.__bmp, endsExtent) self.__endsExtent = endsExtent if minExtent == -1: self.__minExtent = self.__endsExtent*2+1 else: self.__minExtent = minExtent if orientation == Orientation.HORIZONTAL: if self.__baseSize.x != 0: self.__baseWidth = self.__baseSize.x if self.__baseSize.y == 0: self.__baseHeight = self.__startImg.height else: if self.__baseSize.y != 0: self.__baseHeight = self.__baseSize.y if self.__baseSize.x == 0: self.__baseWidth = self.__startImg.width self.__positionNodes(self.__baseSize) if player.isPlaying(): self.__renderImages() else: player.subscribe(avg.Player.PLAYBACK_START, self.__renderImages)
def testVideoLoop(self): def onEOF(): self.eof = True def onFrame(): if self.eof: if not(threaded): self.compareImage("testVideoLoop") player.stop() for threaded in [False, True]: self.eof = False player.setFakeFPS(25) root = self.loadEmptyScene() videoNode = avg.VideoNode(parent=root, loop=True, fps=25, size=(96,96), threaded=threaded, href="mpeg1-48x48.mov") videoNode.subscribe(avg.Node.END_OF_FILE, onEOF) videoNode.play() player.subscribe(player.ON_FRAME, onFrame) player.play()
def testVideoLoop(self): def onEOF(): self.eof = True def onFrame(): if self.eof: if not(threaded): self.compareImage("testVideoLoop") player.stop() for threaded in [False, True]: self.eof = False player.setFakeFPS(25) root = self.loadEmptyScene() videoNode = avg.VideoNode(parent=root, loop=True, fps=25, size=(96,96), threaded=threaded, href="mpeg1-48x48.mpg") videoNode.subscribe(avg.Node.END_OF_FILE, onEOF) videoNode.play() player.subscribe(player.ON_FRAME, onFrame) player.play()
def init(self): self.curFrame = 0 global g_options self.optdict = {} for attr in dir(g_options): if attr[0] != "_": self.optdict[attr] = eval("g_options.%s" % attr) 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.camNode = avg.CameraNode( driver=g_options.driver, device=g_options.device, unit=g_options.unit, fw800=g_options.fw800, framerate=g_options.framerate, capturewidth=g_options.width, captureheight=g_options.height, pixelformat=g_options.pixelFormat, ) player.getRootNode().appendChild(self.camNode) if not g_options.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=player.getRootNode(), ) frameText = avg.WordsNode(color="ff3333", pos=(5, 25), fontsize=14, parent=player.getRootNode()) player.subscribe(player.ON_FRAME, lambda: self.updateFrameDisplay(frameText))
def __onDown(self, event): nodeGone = self._handleNodeGone() if not(nodeGone): if self.__maxContacts == None or len(self._contacts) < self.__maxContacts: event.contact.subscribe(avg.Contact.CURSOR_MOTION, self.__onMotion) event.contact.subscribe(avg.Contact.CURSOR_UP, self.__onUp) self._contacts.add(event.contact) if len(self._contacts) == 1: self.__frameHandlerID = player.subscribe(player.ON_FRAME, self._onFrame) self.__dirty = True return self._handleDown(event)
def __onDown(self, event): if self.__contact is None: self.__contact = event.contact event.contact.subscribe(avg.Contact.CURSOR_UP, self.__onUp) self.__rawContactCircle.opacity = 1 self.__filteredContactCircle.opacity = 1 self.__filters = [ filter.OneEuroFilter(self.__minCutoff, self.__cutoffSlope), filter.OneEuroFilter(self.__minCutoff, self.__cutoffSlope) ] self.__onFrame = player.subscribe(player.ON_FRAME, self.__moveContact)
def __onDown(self, event): nodeGone = self._handleNodeGone() if event.contact and not (nodeGone): if (self.__maxContacts == None or len(self._contacts) < self.__maxContacts): event.contact.subscribe(avg.Contact.CURSOR_MOTION, self.__onMotion) event.contact.subscribe(avg.Contact.CURSOR_UP, self.__onUp) self._contacts.add(event.contact) if len(self._contacts) == 1: self.__frameHandlerID = player.subscribe( player.ON_FRAME, self._onFrame) self.__dirty = True return self._handleDown(event)
def __init__(self, keyDef, downBmp, feedbackBmp, sticky=False, parent=None, **kwargs): self.__keyCode = keyDef[0] if not(isinstance(self.__keyCode, tuple)): self.__keyCode = (self.__keyCode,) kwargs['pos'] = avg.Point2D(keyDef[1]) kwargs['size'] = avg.Point2D(keyDef[2]) if len(keyDef) == 4: self.__isCommand = keyDef[3] else: self.__isCommand = False super(Key, self).__init__(**kwargs) self.registerInstance(self, parent) self.__sticky = sticky self.__stickyIsDown = False self.__cursorID = None if downBmp: if player.isPlaying(): self.__createImages(downBmp, feedbackBmp) else: player.subscribe(avg.Player.PLAYBACK_START, lambda: self.__createImages(downBmp, feedbackBmp))
def onInit(self): ''' Create placeholders for the example. A single ImageNode is used to show the pictures. ''' self.__imageNode = avg.ImageNode(pos=(10, 20), parent=self) self.__spinner = avg.RectNode(color='222222', fillopacity=1, size=(40, 40), active=False, pos=(10, self.size.y - 50), parent=self) self.__infoNode = avg.WordsNode( text='Press space to load the first image', fontsize=11, pos=(10, 5), parent=self) self.__pics = sys.argv[1:] self.__currentPic = -1 player.subscribe(player.ON_FRAME, self.__onFrame) app.keyboardmanager.bindKeyDown(keyname="Space", handler=self.__requestNextBitmap, help="Request next bitmap")
def _handleDown(self, event): self.__startTime = player.getFrameTime() if self.__stateMachine.state == "IDLE": self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onFrame) self.__stateMachine.changeState("DOWN1") self.__startPos = event.pos self._setPossible(event) elif self.__stateMachine.state == "UP1": if ((event.pos - self.__startPos).getNorm() > self.__maxDist*player.getPixelsPerMM()): self.__stateMachine.changeState("IDLE") self._setFail(event) else: self.__stateMachine.changeState("DOWN2") else: assert(False), self.__stateMachine.state
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 _handleDown(self, event): numContacts = len(self._contacts) self.__newPhase() if self.__isFiltered(): self.__filters[event.contact] = [ filter.OneEuroFilter(mincutoff=TransformRecognizer.FILTER_MIN_CUTOFF, beta=TransformRecognizer.FILTER_BETA), filter.OneEuroFilter(mincutoff=TransformRecognizer.FILTER_MIN_CUTOFF, beta=TransformRecognizer.FILTER_BETA)] if numContacts == 1: if self.__inertiaHandler: self.__inertiaHandler.abort() self._setEnd(event) self._setDetected(event) self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onFrame) if self.__friction != -1: self.__inertiaHandler = InertiaHandler(self.__friction, self.__onInertiaMove, self.__onInertiaStop)
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 init(g_avg, catchKeyboard=True, repeatDelay=0.2, charDelay=0.1): """ Initialization routine for the module This method should be called immediately after avg file load (Player.loadFile()) @param g_avg: avg package @param catchKeyboard: boolean, if true events from keyboard are catched @param repeatDelay: wait time (seconds) before starting to repeat a key which is held down @param charDelay: delay among character repetition (of an steadily pressed key) """ global avg, g_RepeatDelay, g_CharDelay avg = g_avg g_RepeatDelay = repeatDelay g_CharDelay = charDelay player.subscribe(player.ON_FRAME, _onFrame) if catchKeyboard: player.subscribe(avg.Player.KEY_DOWN, _onKeyDown) player.subscribe(avg.Player.KEY_UP, _onKeyUp)
def onInit(self): if self.argvoptions.fake == 'True': config_app.fake_data_mode = True config_app.data_mode_string = 'fake' if self.argvoptions.session != '-1': config_app.SESSION = int(self.argvoptions.session) self.__key_messages = {} self._study_handler = None if config_app.study_mode: with open("assets/study_preparations/key_messages.json") as f: self.__key_messages = json.load(f) self._study_handler = StudyHandler( block_question_file=config_app.study_tasks_file, study_order_file=config_app.study_order_file, session_id=config_app.SESSION) add_aid_lines_to_factory() add_intersections_methods_to_method_holder() add_selection_methods_to_method_holder() add_snapping_methods_to_method_holder() self.__grid_groups = [ [0, 1, 2, 3], [4, 5, 6, 7, 8, 9, 10], [11], [12], [13], [16], [17], [22], [23], [24], [25], [26], [27], [32], [33], [34], [35], [36], [37], [38], [39], [40], [41], [42], [43], [44, 45, 46, 47, 48], [49, 50, 51, 52, 53], [54], ] self.__grid_labels = {} sql = SqlInterface( sql_db_path=config_app.db_filename[config_app.data_mode_string], table_mapper_method=table_name_to_query, query_file="examples/data/crime_data.queries") if len(self.__grid_labels) == 0: for grid_group in self.__grid_groups: for grid_id in grid_group: self.__grid_labels[grid_id] = T.tl( msg=sql.get_query_label(str(grid_id)), lang=config_app.default_language) self.__grid_labels[grid_id] += " [{}]".format( grid_id) if not config_app.study_mode else "" self.__grid_labels[21] = T.tl( msg="Weapons <--> Types", lang=config_app.default_language) + ( " [21]" if not config_app.study_mode else "") self.__grid_labels[15] = T.tl( msg="Map of Crimes/Neighborhood", lang=config_app.default_language) + ( " [15]" if not config_app.study_mode else "") if not os.path.exists(config_app.sql_result_dump_filename[ config_app.data_mode_string]) or config_app.force_sql_reload: start_time = time.time() last_time = start_time sql_results = {} for grid_group in self.__grid_groups: for grid_id in grid_group: sql_results[str(grid_id)] = sql.get_query_results( str(grid_id)) now = time.time() print "Duration:", now - last_time, "| loaded chart for query ", self.__grid_labels[ grid_id] last_time = now for query_name in [ "map data from neighborhoods", "districts per neighborhood", "crime types per neighborhood", "crime type names", "highest weapon usage per neighborhood" ]: sql_results[query_name] = sql.get_query_results(query_name) now = time.time() print "Duration:", now - last_time, "| loaded chart for map" print "The complete creation needed ", time.time() - start_time # dumping sql results for later use try: if not os.path.exists("tmp"): os.makedirs("tmp") with open( config_app.sql_result_dump_filename[ config_app.data_mode_string], 'wb') as f: pickle.dump(sql_results, f, 0) print 'Saved sql results locally!' except IOError: print 'Error: Failed to save sql results locally!' self.__wall_divico = None self.__touch_test_view = None self.__touch_visualization_overlay = None self.__task_text_view = None self.__task_text_view_canvas = None self.__task_text_view_image_bottom = None self.__task_text_view_image_top = None self.__phase_block_label = None self.__interaction_activation_label = None if config_app.show_test_touch_view and config_app.study_mode: self.__draw_pre_view() else: self.__draw_main_view() player.subscribe(player.KEY_DOWN, self.__on_key_down)
def onInit(self): player.subscribe(player.KEY_DOWN, self.onKey) player.subscribe(player.KEY_UP, self.onKey)
def onEOF(): node.seekToTime(0) player.subscribe(avg.Player.ON_FRAME, onFrame)
def init(): player.subscribe(player.KEY_DOWN, _onKeyDown) player.subscribe(player.KEY_UP, _onKeyUp) avg.logger.debug('Keyboardmanager initialized', LOGCAT)
def onUp(self): player.unsubscribe(player.ON_FRAME, self.__frameHandlerID) self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onInertiaFrame) self.__onInertiaFrame()
def init(self): self.singleKeyPress('s') self.singleKeyPress('s') self.timeStarted = time.time() self.timerId = player.subscribe(player.ON_FRAME, self.onFrame)
def testPublisher(self): def onDown(event): self.assert_(event.type == avg.Event.CURSOR_DOWN) curEvent = player.getCurrentEvent() self.assert_(curEvent.type == avg.Event.CURSOR_DOWN) self.assert_(curEvent.when == event.when) self.downCalled = True def unsubscribe(): self.assert_(self.img.isSubscribed(avg.Node.CURSOR_DOWN, onDown)) self.img.unsubscribe(avg.Node.CURSOR_DOWN, onDown) self.assert_(not(self.img.isSubscribed(avg.Node.CURSOR_DOWN, onDown))) self.assert_(self.img.getNumSubscribers(avg.Node.CURSOR_DOWN) == 0) self.downCalled = False self.assertRaises(avg.Exception, lambda: self.img.unsubscribe(avg.Node.CURSOR_DOWN, onDown)) def initUnsubscribeInEvent(useMessageID): self.subscriberID = self.img.subscribe(avg.Node.CURSOR_DOWN, lambda event: onDownUnsubscribe(event, useMessageID)) def onDownUnsubscribe(event, useMessageID): if useMessageID: self.img.unsubscribe(avg.Node.CURSOR_DOWN, self.subscriberID) self.assertRaises(avg.Exception, lambda: self.img.unsubscribe(avg.Node.CURSOR_DOWN, self.subscriberID)) else: self.img.unsubscribe(self.subscriberID) self.assertRaises(avg.Exception, lambda: self.img.unsubscribe(self.subscriberID)) self.downCalled = True def onFrame(): self.onFrameCalled = True self.downCalled = False self.onFrameCalled = False root = self.loadEmptyScene() player.subscribe(player.ON_FRAME, onFrame) self.img = avg.ImageNode(pos=(0,0), href="rgb24-65x65.png", parent=root) self.img.subscribe(avg.Node.CURSOR_DOWN, onDown) self.assertRaises(Exception, lambda: self.img.subscribe(23, onDown)) self.assertRaises(avg.Exception, lambda: self.img.subscribe(avg.Node.CURSOR_DOWN, 23)) self.assertRaises(avg.Exception, lambda: self.img.unsubscribe(avg.Node.CURSOR_DOWN, 23)) self.start(False, (lambda: self.fakeClick(10,10), lambda: self.assert_(self.downCalled), lambda: self.assert_(self.onFrameCalled), unsubscribe, lambda: self.fakeClick(10,10), lambda: self.assert_(not(self.downCalled)), lambda: initUnsubscribeInEvent(True), lambda: self.fakeClick(10,10), lambda: self.assert_(self.downCalled), lambda: initUnsubscribeInEvent(False), lambda: self.fakeClick(10,10), lambda: self.assert_(self.downCalled), ))
#!/usr/bin/env python # -*- coding: utf-8 -*- from libavg import avg, player def moveText(): global node if node.x < 200: node.x += 1 canvas = player.createMainCanvas(size=(640, 480)) rootNode = canvas.getRootNode() node = avg.WordsNode(pos=(10, 10), text="Hello World", parent=rootNode) player.subscribe(player.ON_FRAME, moveText) player.play()
def play(self): if not self.__playing: self.__playing = True self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onFrame)