def testStateMachine(self):
def atob(oldState, newState):
self.atobCalled = True
def btoc(dummy):
# Dummy argument so we can test handling of lambda expressions.
self.btocCalled = True
def aEntered():
self.aEnteredCalled = True
def aLeft():
self.aLeftCalled = True
self.atobCalled = False
self.btocCalled = False
self.btoaCalled = False
self.aLeftCalled = False
self.aEnteredCalled = False
machine = statemachine.StateMachine("testmachine", 'A')
machine.addState('A', {'B': atob, 'nostate': atob}, aEntered, aLeft)
machine.addState('B', {'C': lambda: btoc("dummy"), 'A': self.btoa})
machine.addState('C', {'A': None})
self.assertRaises(avg.Exception,
lambda: machine.addState('C', {'A': None}))
self.assertRaises(avg.Exception, lambda: machine.changeState('C'))
self.assertRaises(avg.Exception,
lambda: machine.changeState('nostate'))
machine.changeState('B')
self.assert_(self.atobCalled)
self.assert_(self.aLeftCalled)
machine.changeState('A')
self.assert_(self.aEnteredCalled)
self.assert_(self.btoaCalled)
machine.changeState('B')
machine.changeState('C')
self.assert_(self.btocCalled)
machine.changeState('A')
self.assertEqual(machine.state, 'A')
# machine.dump()
self.assertRaises(avg.Exception,
lambda: machine.addState('illegal', {}))
# Create a machine without transition callbacks
machine = statemachine.StateMachine("testmachine", 'A')
machine.addState('A', ('B', ), aEntered, aLeft)
machine.addState('B', ('C', 'A'))
machine.addState('C', ('A', ))
machine.changeState('B')
# Make a machine with a transition to a nonexistent state.
kaputtMachine = statemachine.StateMachine("kaputt", 'A')
kaputtMachine.addState('A', {'B': None})
self.assertRaises(avg.Exception,
lambda: kaputtMachine.changeState('B'))
def __init__(self,
node,
maxTime=None,
maxDist=None,
initialEvent=None,
possibleHandler=None,
failHandler=None,
detectedHandler=None):
if maxTime == None:
maxTime = DoubletapRecognizer.MAX_DOUBLETAP_TIME
self.__maxTime = maxTime
if maxDist == None:
maxDist = TapRecognizer.MAX_TAP_DIST
self.__maxDist = maxDist
self.__stateMachine = statemachine.StateMachine(
"DoubletapRecognizer", "IDLE")
self.__stateMachine.addState("IDLE", ("DOWN1", ),
enterFunc=self.__enterIdle)
self.__stateMachine.addState("DOWN1", ("UP1", "IDLE"))
self.__stateMachine.addState("UP1", ("DOWN2", "IDLE"))
self.__stateMachine.addState("DOWN2", ("IDLE", ))
#self.__stateMachine.traceChanges(True)
self.__frameHandlerID = None
super(DoubletapRecognizer,
self).__init__(node, False, 1, initialEvent, possibleHandler,
failHandler, detectedHandler)
def __init__(self,
upNode,
downNode,
disabledNode=None,
activeAreaNode=None,
enabled=True,
fatFingerEnlarge=False,
**kwargs):
super(Button, self).__init__(**kwargs)
if disabledNode is None:
disabledNode = upNode
nodeMap = {"UP": upNode, "DOWN": downNode, "DISABLED": disabledNode}
self.__switchNode = SwitchNode(nodeMap=nodeMap,
visibleid="UP",
parent=self)
self.publish(self.CLICKED)
self.__stateMachine = statemachine.StateMachine("Button", "UP")
self.__stateMachine.addState("UP", ("DOWN", "DISABLED"),
enterFunc=self._enterUp,
leaveFunc=self._leaveUp)
self.__stateMachine.addState("DOWN", ("UP", "DISABLED"),
enterFunc=self._enterDown,
leaveFunc=self._leaveDown)
self.__stateMachine.addState("DISABLED", ("UP", ),
enterFunc=self._enterDisabled,
leaveFunc=self._leaveDisabled)
self._setActiveArea(upNode, activeAreaNode, fatFingerEnlarge)
if not (enabled):
self.setEnabled(False)
def __init__(self, parentNode, world, renderer):
self.world, self.field, self.renderer = world, parentNode, renderer
self.machine = statemachine.StateMachine('manager', 'idle')
self.machine.addState('idle', ['started'])
self.machine.addState('started', {'idle':self.reset, 'created':None})
self.machine.addState('created', ['started'], enterFunc=self.createBat, leaveFunc=self.destroyBat)
self.pos = [] # it's a list of tuples of the form (cursorid, position)
self.bat = None
self.field.setEventHandler(avg.CURSORDOWN, avg.TOUCH, self.onDown)
self.field.setEventHandler(avg.CURSOROUT, avg.TOUCH, self.onUp)
self.rec = ui.TransformRecognizer(self.field, moveHandler=self.onTransform)
def __init__(self,
node,
isContinuous,
maxContacts,
initialEvent,
possibleHandler=None,
failHandler=None,
detectedHandler=None,
endHandler=None):
super(Recognizer, self).__init__()
if node:
self.__node = weakref.ref(node)
else:
self.__node = None
self.__isContinuous = isContinuous
self.__maxContacts = maxContacts
self.__downHandlerID = None
self.__moveHandlerID = {}
self.__upHandlerID = {}
self.__setEventHandler()
self.__isEnabled = True
self._contacts = set()
self.__dirty = False
self.publish(Recognizer.POSSIBLE)
self.publish(Recognizer.DETECTED)
self.publish(Recognizer.FAILED)
self.publish(Recognizer.END)
self.__stateMachine = statemachine.StateMachine(
str(type(self)), "IDLE")
if self.__isContinuous:
self.publish(Recognizer.MOTION)
self.publish(Recognizer.UP)
self.__stateMachine.addState("IDLE", ("POSSIBLE", "RUNNING"))
self.__stateMachine.addState("POSSIBLE", ("IDLE", "RUNNING"))
self.__stateMachine.addState("RUNNING", ("IDLE", ))
else:
self.__stateMachine.addState("IDLE", ("POSSIBLE", ))
self.__stateMachine.addState("POSSIBLE", ("IDLE", ))
self.subscribe(Recognizer.POSSIBLE, possibleHandler)
self.subscribe(Recognizer.FAILED, failHandler)
self.subscribe(Recognizer.DETECTED, detectedHandler)
self.subscribe(Recognizer.END, endHandler)
# self.__stateMachine.traceChanges(True)
self.__frameHandlerID = None
if initialEvent:
self.__onDown(initialEvent)
def init(self):
gameobjects.displayWidth, gameobjects.displayHeight = self._parentNode.size
gameobjects.bricksPerLine = (int)(self._parentNode.height / (brickSize * PPM))
gameobjects.preRender()
self.bonusjob = None
self.cleanup = None
self.keepPushingBalls = None
self.tutorialMode = False
self.backgroundpic = None
self.lines = None
self.preRender()
self.machine = statemachine.StateMachine('UPM', 'MainMenu')
self.machine.addState('MainMenu', ['Playing', 'Tutorial', 'About'], enterFunc=self.showMenu, leaveFunc=self.hideMenu)
self.machine.addState('Tutorial', ['MainMenu', 'Playing', 'Tutorial'], enterFunc=self.startTutorial, leaveFunc=self.hideTutorial)
self.machine.addState('Playing', ['MainMenu'], enterFunc=self.startPlaying)
self.machine.addState('About', ['MainMenu'], enterFunc=self.showAbout, leaveFunc=self.hideAbout)
self.showMenu()
def testStateMachineDiagram(self):
def aEntered():
pass
if not (self._isCurrentDirWriteable()):
self.skip("Current dir not writeable")
return
machine = statemachine.StateMachine("testmachine", 'A')
machine.addState('A', {'B': None, 'nostate': None}, aEntered)
machine.addState('B', {'C': None, 'A': self.btoa})
machine.addState('C', {'A': None})
imageFName = AVGTestCase.imageResultDirectory + "/stateMachineGraphViz.png"
try:
machine.makeDiagram(imageFName)
except avg.Exception:
self.skip("graphviz not installed.")
def __init__(self,
uncheckedUpNode,
uncheckedDownNode,
checkedUpNode,
checkedDownNode,
uncheckedDisabledNode=None,
checkedDisabledNode=None,
activeAreaNode=None,
enabled=True,
fatFingerEnlarge=False,
checked=False,
**kwargs):
super(ToggleButton, self).__init__(**kwargs)
nodeMap = {
"UNCHECKED_UP": uncheckedUpNode,
"UNCHECKED_DOWN": uncheckedDownNode,
"CHECKED_UP": checkedUpNode,
"CHECKED_DOWN": checkedDownNode,
"UNCHECKED_DISABLED": uncheckedDisabledNode,
"CHECKED_DISABLED": checkedDisabledNode,
}
if uncheckedDisabledNode is None:
nodeMap["UNCHECKED_DISABLED"] = uncheckedUpNode
if checkedDisabledNode is None:
nodeMap["CHECKED_DISABLED"] = checkedUpNode
self.__switchNode = SwitchNode(nodeMap=nodeMap,
visibleid="UNCHECKED_UP",
parent=self)
self.publish(ToggleButton.TOGGLED)
self.__stateMachine = statemachine.StateMachine(
"ToggleButton", "UNCHECKED_UP")
self.__stateMachine.addState("UNCHECKED_UP",
("UNCHECKED_DOWN", "UNCHECKED_DISABLED"),
enterFunc=self._enterUncheckedUp,
leaveFunc=self._leaveUncheckedUp)
self.__stateMachine.addState(
"UNCHECKED_DOWN",
("UNCHECKED_UP", "UNCHECKED_DISABLED", "CHECKED_UP"),
enterFunc=self._enterUncheckedDown,
leaveFunc=self._leaveUncheckedDown)
self.__stateMachine.addState("CHECKED_UP",
("CHECKED_DOWN", "CHECKED_DISABLED"),
enterFunc=self._enterCheckedUp,
leaveFunc=self._leaveCheckedUp)
self.__stateMachine.addState(
"CHECKED_DOWN", ("CHECKED_UP", "UNCHECKED_UP", "CHECKED_DISABLED"),
enterFunc=self._enterCheckedDown,
leaveFunc=self._leaveCheckedDown)
self.__stateMachine.addState("UNCHECKED_DISABLED", ("UNCHECKED_UP", ),
enterFunc=self._enterUncheckedDisabled,
leaveFunc=self._leaveUncheckedDisabled)
self.__stateMachine.addState("CHECKED_DISABLED", ("CHECKED_UP", ),
enterFunc=self._enterCheckedDisabled,
leaveFunc=self._leaveCheckedDisabled)
self._setActiveArea(uncheckedUpNode, activeAreaNode, fatFingerEnlarge)
if not enabled:
self.__stateMachine.changeState("UNCHECKED_DISABLED")
if checked:
self.setChecked(True)
